fix(ai-bot): login token refresh and update actor flow with agent

Author: ascariandrea

packages/@liexp/backend/src/providers/ai/agent.provider.ts

@@ -0,0 +1,89 @@
+import { readFileSync } from "fs";
+import path from "path";
+import { type AIMessage, type ToolMessage } from "@langchain/core/messages.js";
+import { type DynamicStructuredTool } from "@langchain/core/tools.js";
+import { MemorySaver } from "@langchain/langgraph";
+import { createReactAgent } from "@langchain/langgraph/prebuilt";
+import { fp } from "@liexp/core/lib/fp/index.js";
+import { type TaskEither } from "fp-ts/lib/TaskEither.js";
+import { type LangchainContext } from "../../context/langchain.context.js";
+import { type LoggerContext } from "../../context/logger.context.js";
+import { ServerError } from "../../errors/index.js";
+import { AIMessageLogger } from "./aiMessage.helper.js";
+
+type Agent = ReturnType<typeof createReactAgent>;
+
+export type AgentProvider = {
+  agent: Agent;
+  tools: DynamicStructuredTool[];
+  invoke: (
+    input: Parameters<Agent["invoke"]>[0],
+    options: Parameters<Agent["invoke"]>[1],
+  ) => TaskEither<ServerError, Awaited<ReturnType<Agent["invoke"]>>>;
+  stream: (
+    input: Parameters<Agent["stream"]>[0],
+    options: Parameters<Agent["stream"]>[1],
+  ) => TaskEither<ServerError, (ToolMessage | AIMessage)[]>;
+};
+
+const toAgentError = (e: unknown) => {
+  // eslint-disable-next-line no-console
+  console.log(JSON.stringify(e, null, 2));
+  return ServerError.fromUnknown(e);
+};
+
+export const GetAgentProvider =
+  () =>
+  <C extends LangchainContext & LoggerContext>(
+    ctx: C,
+  ): TaskEither<ServerError, AgentProvider> => {
+    const aiMessageLogger = AIMessageLogger(ctx.logger);
+
+    return fp.TE.tryCatch(async () => {
+      // Initialize memory to persist state between graph runs
+      const agentCheckpointer = new MemorySaver();
+
+      const agent = createReactAgent({
+        llm: ctx.langchain.chat.withConfig({ tool_choice: "required" }),
+        tools: [],
+        checkpointSaver: agentCheckpointer,
+        prompt: readFileSync(path.resolve(process.cwd(), "AGENT.md"), "utf-8"),
+      });
+
+      ctx.logger.info.log(`Agent created: %s`, agent.getName());
+
+      const invoke = (
+        input: Parameters<typeof agent.invoke>[0],
+        options: Parameters<typeof agent.invoke>[1],
+      ): TaskEither<ServerError, Awaited<ReturnType<typeof agent.invoke>>> =>
+        fp.TE.tryCatch(() => {
+          ctx.logger.info.log(`Invoke agent with %O (%O)`, input, options);
+          return agent.invoke(input, options);
+        }, toAgentError);
+
+      const stream = (
+        input: Parameters<typeof agent.stream>[0],
+        options: Parameters<typeof agent.stream>[1],
+      ) =>
+        fp.TE.tryCatch(async () => {
+          ctx.logger.info.log(`Invoke agent with %O (%O)`, input, options);
+          const stream = await agent.stream(input, options);
+
+          const result: (ToolMessage | AIMessage)[] = [];
+          for await (const chunk of stream) {
+            if (Array.isArray(chunk.agent?.messages)) {
+              result.push(...(chunk.agent.messages as any[]));
+            }
+
+            const messages = (chunk.agent?.messages ??
+              chunk.tools?.messages ??
+              []) as (ToolMessage | AIMessage)[];
+
+            messages.forEach(aiMessageLogger);
+          }
+          return result;
+        }, toAgentError);
+
+      return Promise.resolve({ agent, tools: [], invoke, stream });
+    }, ServerError.fromUnknown);
+  };

packages/@liexp/backend/src/providers/ai/aiMessage.helper.ts

@@ -0,0 +1,18 @@
+import { type AIMessage, type ToolMessage } from "@langchain/core/messages";
+import { type Logger } from "@liexp/core/lib/index.js";
+
+export const AIMessageLogger =
+  (logger: Logger) => (message: ToolMessage | AIMessage) => {
+    const content = message.content;
+
+    const tool_calls =
+      "tool_calls" in message ? (message.tool_calls ?? []) : [];
+
+    if (content !== "") {
+      logger.info.log(`Content: %O`, content);
+    }
+
+    tool_calls.forEach((t) => {
+      logger.info.log(`Run tool: %s: %O`, t.name, t.args);
+    });
+  };

packages/@liexp/backend/src/providers/ai/langchain.provider.ts

@@ -114,7 +114,7 @@ export const GetLangchainProvider = (
       timeout: 60 * 30 * 1000, // 30 minutes
       maxConcurrency: 1,
       maxRetries: 2,
-      streaming: false,
+      streaming: true,
       ...opts.options?.chat,
       ...chatOptions,
       configuration: {

packages/@liexp/backend/src/queries/actors/fetchActors.query.ts

@@ -56,9 +56,9 @@ export const fetchActors = <C extends DatabaseContext & ENVContext>(
 
             if (O.isSome(search)) {
               return q.andWhere(
-                "lower(unaccent(actors.fullName)) LIKE :fullName",
+                "lower(unaccent(actors.fullName)) ILIKE :search OR lower(unaccent(actors.username)) ILIKE :search",
                 {
-                  fullName: `%${search.value}%`,
+                  search: `%${search.value}%`,
                 },
               );
             }

packages/@liexp/backend/src/queries/links/fetchLinks.query.ts

@@ -14,7 +14,7 @@ import {
 import { DBService } from "../../services/db.service.js";
 import { addOrder } from "../../utils/orm.utils.js";
 
-const getListQueryEmpty: GetListLinkQuery = {
+export const getListQueryEmpty: GetListLinkQuery = {
   q: O.none(),
   ids: O.none(),
   _sort: O.none(),

packages/@liexp/shared/src/io/openai/prompts/actor.prompts.ts

@@ -1,23 +1,15 @@
 import { type PromptFn } from "./prompt.type.js";
 
-export const EMBED_ACTOR_PROMPT: PromptFn<{
-  text: string;
-  question: string;
-}> = ({ vars: { text, question } }) => `
+export const EMBED_ACTOR_PROMPT: PromptFn = () => `
 You are an expert in giving description about people.
 Your goal is to give a description of a given person in a text format, including the requested fields, without inventing details.
+Execute the tools available to retrieve the info you need.
 The text should be minimum 100 words long, but not exceeding 300 words long.
 
 The requested fields are:
   - the name of the person
   - the birth date of the person (in the format "YYYY-MM-DD")
   - if has passed away, the death date of the person (in the format "YYYY-MM-DD")
 
-Here's the text you should use to extract the information from:
-
----------------------------------------------------------------
-${text}
----------------------------------------------------------------
-
-There may be an additional question which answer should be included in the body of the text: ${question}
+If the user poses a specific question, try to include the answer in your description.
 `;

packages/@liexp/shared/src/utils/user.utils.ts

@@ -1,4 +1,9 @@
-import { AdminCreate, AdminDelete, AdminEdit } from "../io/http/User.js";
+import {
+  AdminCreate,
+  AdminDelete,
+  AdminEdit,
+  AdminRead,
+} from "../io/http/User.js";
 import { type User } from "../io/http/index.js";
 
 export const checkIsAdmin = (pp: readonly User.UserPermission[]): boolean => {
@@ -8,6 +13,7 @@ export const checkIsAdmin = (pp: readonly User.UserPermission[]): boolean => {
       AdminDelete.literals[0],
       AdminEdit.literals[0],
       AdminCreate.literals[0],
+      AdminRead.literals[0],
     ].some((p) => pp.includes(p))
   );
 };

services/ai-bot/AGENT.md

@@ -0,0 +1,51 @@
+# AI Agent Integration Guide
+
+This document describes how to integrate and configure AI agents to work with the lies.exposed platform using the Model Context Protocol (MCP) servers.
+
+## Overview
+
+The lies.exposed platform provides several MCP servers that expose domain-specific tools for working with various types of content. AI agents should proactively use these tools as their primary knowledge source and execution capability.
+
+When you identify a tool that can help with a task, you should:
+1. Execute the tool directly using the available methods
+2. Use the tool's response to complete the task
+3. Never output tool calls in your response - execute them instead
+
+When a tool call is needed, use it directly through the provided interface. Do not describe the tool call or show it in your response.
+
+### Available Tools
+
+The platform provides several domain-specific tools through MCP:
+
+#### Content Search Tools
+- `findActor` - Search for people and organizations
+- `findArea` - Search for geographical and thematic areas
+- `findEvents` - Search for events and timelines
+- `findGroup` - Search for groups and organizations
+- `findLink` - Search for web resources and references
+- `findMedia` - Search for images, videos and documents
+
+Each search tool supports:
+- Full-text search via the `query` parameter
+- Sorting options (typically by `createdAt` and resource-specific fields)
+- Order control (`ASC`/`DESC`)
+
+#### Content Parsing Tools
+- `blockNoteToText` - Convert BlockNote JSON documents to plain text
+
+### Tool Usage Guidelines
+
+1. **Proactive Tool Use**: 
+   - AI agents should actively use MCP tools without waiting for explicit user permission
+   - Tools should be used as the primary source of domain knowledge
+   - Multiple tools can be queried in parallel when needed
+
+2. **Search Strategy**:
+   - Start with broad searches using key terms
+   - Refine searches based on initial results
+   - Use multiple content types to build comprehensive context
+
+3. **Content Processing**:
+   - Parse BlockNote content when encountering formatted text
+   - Extract key entities (actors, areas, events) from search results
+   - Build relationships between different content types

services/ai-bot/config/ai-bot.config.json

@@ -6,7 +6,7 @@
     "models": {
       "summarize": "gpt-4o",
       "chat": "qwen3-4b",
-      "embeddings": "qwen3-embedding-4b"
+      "embeddings": "qwen3-4b"
     }
   }
 }

services/ai-bot/src/cli/agent.command.ts

@@ -1,69 +1,38 @@
-import { MemorySaver } from "@langchain/langgraph";
-import { createReactAgent } from "@langchain/langgraph/prebuilt";
+import { type AIMessage, type ToolMessage } from "@langchain/core/messages";
+import { AIMessageLogger } from "@liexp/backend/lib/providers/ai/aiMessage.helper.js";
 import { fp } from "@liexp/core/lib/fp/index.js";
+import { uuid } from "@liexp/shared/lib/io/http/Common/UUID.js";
 import { throwTE } from "@liexp/shared/lib/utils/task.utils.js";
 import { pipe } from "fp-ts/lib/function.js";
 import prompts from "prompts";
 import { toAIBotError } from "../common/error/index.js";
 import { type CommandFlow } from "./CommandFlow.js";
 
-// const GraphState = Annotation.Root({
-//   messages: Annotation<BaseMessage[]>({
-//     reducer: (x, y) => x.concat(y),
-//     default: () => [],
-//   }),
-// });
-
-// export const ConfigurationSchema = Annotation.Root({
-//   /**
-//    * The system prompt to be used by the agent.
-//    */
-//   systemPromptTemplate: Annotation<string>,
-
-//   /**
-//    * The name of the language model to be used by the agent.
-//    */
-//   model: Annotation<string>,
-// });
-
-// Define the function that determines whether to continue or not
-// function routeModelOutput(state: typeof MessagesAnnotation.State): string {
-//   const messages = state.messages;
-//   const lastMessage = messages[messages.length - 1];
-//   // If the LLM is invoking tools, route there.
-//   if ((lastMessage as AIMessage)?.tool_calls?.length || 0 > 0) {
-//     return "tools";
-//   }
-//   // Otherwise end the graph.
-//   else {
-//     return "__end__";
-//   }
-// }
-
 export const agentCommand: CommandFlow = async (ctx, args) => {
-  // Initialize memory to persist state between graph runs
-
-  const agentCheckpointer = new MemorySaver();
-  const agent = createReactAgent({
-    llm: ctx.langchain.chat,
-    tools: [],
-    checkpointSaver: agentCheckpointer,
+  const threadId = uuid();
+  const agent = ctx.agent.agent.withConfig({
+    configurable: {
+      thread_id: threadId,
+    },
   });
 
   const ask = async (ag: typeof agent, message: string) => {
     const agentFinalState = await ag.stream(
       {
         messages: [message],
       },
-      { configurable: { thread_id: "42" } },
+      {},
     );
 
-    const messages = [];
+    const aiMessageLogger = AIMessageLogger(ctx.logger);
+
     for await (const chunk of agentFinalState) {
-      ctx.logger.debug.log(`Chunk %O`, chunk.agent.messages);
-      messages.push(chunk);
+      const messages = (chunk.agent?.messages ??
+        chunk.tools?.messages ??
+        []) as (ToolMessage | AIMessage)[];
+
+      messages.forEach(aiMessageLogger);
     }
-    return messages;
   };
 
   const chat = async (ag: typeof agent) => {
@@ -73,7 +42,7 @@ export const agentCommand: CommandFlow = async (ctx, args) => {
       name: "question",
     });
 
-    if (question.toLowerCase() === "exit") {
+    if (!question || question.toLowerCase() === "exit") {
       ctx.logger.info.log("Goodbye!");
       return;
     } else {