openloops 0.1.9 → 0.1.10

package/dist/services/agent/core/agent.mjs

@@ -0,0 +1,327 @@
+import "../../../chunk-XRJFNASX.mjs";
+import "reflect-metadata";
+import { container } from "tsyringe";
+import { Logger } from "@common/logger";
+import { CreateChatUseCase } from "@services/agent/modules/chats/lambdas/create-chat/";
+import { UpdateChatUseCase } from "@services/agent/modules/chats/lambdas/update-chat/";
+import { ListChatsByUserUseCase } from "@services/agent/modules/chats/lambdas/list-chats-by-user";
+import { ListMcpServersByUserUseCase } from "@services/agent/modules/mcp-servers/lambdas/list-mcpservers-by-user";
+import { McpServer } from "@services/agent/modules/mcp-servers/entities";
+import { CreateMcpServerUseCase } from "@services/agent/modules/mcp-servers/lambdas/create-mcpserver";
+import { ChatRepository } from "@services/agent/modules/chats/repositories";
+import { GetLLMUsageUseCase } from "@services/agent/modules/llmcalls/lambdas/get-llm-usage";
+import { Chat } from "@services/agent/modules/chats/entities/chat.entity";
+import { Tool } from "@services/agent/tools/tool";
+import { webSearchTool, callAiTool } from "@services/agent/tools/core";
+import { rankToolsByKeywords } from "@services/agent/utils/rank-tools-by-keywords";
+import { AgentStatus } from "./agent-state";
+const AGENT_ERROR_CODES = {
+  NODE_NOT_FOUND: "AGENT_NODE_NOT_FOUND"
+};
+const MAX_ITERATIONS = 50;
+class Agent {
+  updateChatUseCase = container.resolve(UpdateChatUseCase);
+  chatRepository = container.resolve(ChatRepository);
+  logger = new Logger();
+  _loop;
+  _tools;
+  _mcps = [];
+  _preHooks = [];
+  _postHooks = [];
+  currentChat;
+  currentUser;
+  currentSession;
+  currentMessage = "";
+  answerId = "";
+  stopLoop = false;
+  stopRequested = false;
+  pendingNextNode;
+  static async getChat(chatId) {
+    const chatRepository = container.resolve(ChatRepository);
+    return chatRepository.findById(chatId);
+  }
+  static async interruptExecution(chatId, currentUser) {
+    const updateChatUseCase = container.resolve(UpdateChatUseCase);
+    const logger = new Logger();
+    logger.debug("[AGENT] Interrupt execution triggered");
+    await updateChatUseCase.execute({
+      id: chatId,
+      payload: { state: { stopRequested: true } },
+      currentUser
+    });
+  }
+  static async createChatSession(currentUser, loop) {
+    if (!currentUser) throw new Error("[AGENT] CurrentUser is required to create a new chat");
+    const createChatUseCase = container.resolve(CreateChatUseCase);
+    const newChat = Chat.withDefaults(loop?.name);
+    const { data } = await createChatUseCase.execute({
+      payload: newChat.toJSON(),
+      currentUser
+    });
+    if (!data) throw new Error("[AGENT] There was an error creating the chat");
+    return Chat.fromJSON(data);
+  }
+  static async listUserChats(options, currentUser) {
+    const listChatsByUserUseCase = container.resolve(ListChatsByUserUseCase);
+    const { page, limit } = options || {};
+    const { data } = await listChatsByUserUseCase.execute({
+      options: { page, limit },
+      currentUser
+    });
+    return data;
+  }
+  static async getLLMUsage(filters, currentUser) {
+    const getLLMUsageUseCase = container.resolve(GetLLMUsageUseCase);
+    const { data } = await getLLMUsageUseCase.execute({ filters, currentUser });
+    return data;
+  }
+  static async listUserMcpServers(options, currentUser) {
+    const listMcpServersByUserUseCase = container.resolve(ListMcpServersByUserUseCase);
+    const { page, limit } = options || {};
+    const { data } = await listMcpServersByUserUseCase.execute({
+      options: { page, limit },
+      currentUser
+    });
+    return data;
+  }
+  static async createMcpServer(payload, currentUser) {
+    if (!currentUser) throw new Error("[AGENT] CurrentUser is required to create a new mcp server");
+    const createMcpServerUseCase = container.resolve(CreateMcpServerUseCase);
+    const { data } = await createMcpServerUseCase.execute({
+      payload,
+      currentUser
+    });
+    if (!data) throw new Error("[AGENT] There was an error creating the mcp server");
+    return data;
+  }
+  constructor(agentOptions) {
+    if (!agentOptions?.loop) throw new Error("[AGENT] An AgentLoop instance is required");
+    this._loop = agentOptions.loop;
+    this._tools = agentOptions.tools ?? [];
+    this.currentChat = Chat.withDefaults(this._loop.name);
+  }
+  get tools() {
+    return this._tools;
+  }
+  get mcps() {
+    return this._mcps;
+  }
+  get notifyOnCompletion() {
+    return this.currentChat?.settings?.notifyOnCompletion;
+  }
+  get lastAssistantAnswer() {
+    return this.currentChat.lastAnswer;
+  }
+  async run(input, currentUser, currentSession) {
+    try {
+      const { chatId, message } = input || {};
+      this.logger.debug(input, "[AGENT] Agent started");
+      if (!message) throw new Error("[AGENT] Message is required");
+      if (!currentUser) throw new Error("[AGENT] CurrentUser is required");
+      this.stopLoop = false;
+      this.stopRequested = false;
+      this.pendingNextNode = void 0;
+      this.currentUser = currentUser;
+      this.currentSession = currentSession;
+      this.currentMessage = message;
+      this.answerId = new (require("mongodb")).ObjectId().toString();
+      await this.preRunner(chatId);
+      await this.runLoop();
+      await this.postRunner();
+      return { data: this.currentChat };
+    } catch (error) {
+      this.currentChat.state?.setStatus(AgentStatus.FAILED);
+      this.currentChat.state?.setCurrentActivity("stopped");
+      await this.saveChat();
+      await this.disconnectMcpServers();
+    }
+  }
+  stopAgent() {
+    this.stopLoop = true;
+  }
+  addTool(tool) {
+    this._tools.push(tool);
+  }
+  addHook(type, fn) {
+    if (type === "pre_execution") this._preHooks.push(fn);
+    if (type === "post_execution") this._postHooks.push(fn);
+  }
+  async preRunner(chatId) {
+    let chatData;
+    if (chatId) {
+      chatData = await this.chatRepository?.findById(chatId);
+    }
+    if (!chatData) {
+      this.logger.debug("[AGENT] Not existing chat found");
+      if (!this.currentUser) throw new Error("[AGENT] CurrentUser params is required");
+      this.currentChat = await Agent.createChatSession(this.currentUser, this._loop);
+    } else {
+      this.logger.debug("[AGENT] Existing chat found");
+      this.currentChat = Chat.fromJSON(chatData);
+      this.currentChat.state?.setStopRequested(false);
+      this.currentChat.switchLoop(this._loop.name);
+    }
+    this.currentChat.pushMessage({
+      role: "user",
+      content: this.currentMessage
+    });
+    this.currentChat.state?.setStatus(AgentStatus.PROCESSING);
+    this.currentChat.state?.setCurrentActivity("Starting...");
+    await this.saveChat({ resetStop: true });
+    await this.loadMcpServers();
+    for (const hook of this._preHooks) {
+      await hook();
+    }
+  }
+  async postRunner() {
+    for (const hook of this._postHooks) {
+      await hook();
+    }
+    this.currentChat.state?.setCurrentActivity("stopped");
+    await this.saveChat();
+    await this.disconnectMcpServers();
+  }
+  async loadMcpServers() {
+    if (!this.currentUser) return;
+    const servers = await Agent.listUserMcpServers({}, this.currentUser);
+    for (const props of servers ?? []) {
+      const mcpServer = McpServer.fromJSON(props);
+      try {
+        const mcpClient = await mcpServer.connect();
+        const { tools: mcpTools } = await mcpClient.listTools();
+        const tools = mcpTools.map((mcpTool) => Tool.fromMcp(mcpTool, mcpClient, { namespace: mcpServer.name ?? "mcp" }));
+        this._tools.push(...tools);
+        this._mcps.push(mcpServer);
+      } catch (error) {
+        this.logger.error({ error, mcpServer: mcpServer.name }, "[AGENT] Failed to connect MCP server");
+      }
+    }
+  }
+  async disconnectMcpServers() {
+    for (const mcpServer of this._mcps) {
+      await mcpServer.disconnect().catch((error) => {
+        this.logger.error({ error, mcpServer: mcpServer.name }, "[AGENT] Failed to disconnect MCP server");
+      });
+    }
+    this._mcps = [];
+  }
+  async saveChat(props) {
+    if (this.currentChat?._id) {
+      this.logger.debug("[AGENT] Updating chat...");
+      if (!props?.resetStop) {
+        this.logger.debug("[Agent] Removing stopRequested");
+        delete this.currentChat.state?.stopRequested;
+      }
+      await this.updateChatUseCase?.execute({
+        id: this.currentChat?._id.toString(),
+        payload: this.currentChat.toJSON(),
+        currentUser: this.currentUser
+      }) ?? {};
+    }
+  }
+  async checkInterruptionRequest() {
+    const chatId = this.currentChat?._id?.toString();
+    const chatData = chatId && await this.chatRepository.findById(chatId, { state: 1 });
+    if (chatData && chatData.state?.stopRequested) this.stopRequested = true;
+  }
+  async runLoop() {
+    this.logger.info("[AGENT] Agent Loop started");
+    let iterations = 0;
+    while (!this.stopLoop && iterations < MAX_ITERATIONS) {
+      iterations++;
+      await this.checkInterruptionRequest();
+      if (this.stopRequested) {
+        this.stopLoop = true;
+        this.currentChat.state?.setStatus(AgentStatus.IDLE);
+        this.resetNextNode();
+        this.currentChat.state?.setStopRequested(false);
+        break;
+      }
+      const activeTask = this.currentChat.activeTask;
+      const nodeName = activeTask?.nextNode ?? this.pendingNextNode ?? this.resolveNodeName(this._loop.initialNode);
+      const nodeFn = nodeName ? this._loop.nodes[nodeName] : void 0;
+      if (!nodeFn) {
+        this.logger.error({ nodeName, loop: this._loop.name }, "[AGENT] Node not found in current loop");
+        this.currentChat.state?.setStatus(AgentStatus.FAILED);
+        this.currentChat.state?.setLastError({
+          code: AGENT_ERROR_CODES.NODE_NOT_FOUND,
+          message: `Node "${nodeName}" is not implemented by loop "${this._loop.name}"`,
+          isRetryable: false,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+        this.currentChat.addTrace({ node: nodeName ?? "", reasoning: "Node not found" });
+        this.stopLoop = true;
+        break;
+      }
+      await nodeFn.call(this._loop, this.buildRunContext());
+      await this.saveChat();
+      if (!this.currentChat.state || this.currentChat.state?.status === AgentStatus.IDLE || this.currentChat.state?.status === AgentStatus.FAILED || this.currentChat.state?.status === AgentStatus.AWAITING_USER_INPUT || this.currentChat.state?.status === AgentStatus.AWAITING_USER_CONFIRMATION) {
+        this.stopLoop = true;
+        break;
+      }
+    }
+    this.logger.info("[AGENT] Agent Loop stopped");
+  }
+  resetNextNode() {
+    const resolved = this.resolveNodeName(this._loop.initialNode);
+    const active = this.currentChat.activeTask;
+    if (active) active.setNextNode(resolved);
+    else this.pendingNextNode = resolved;
+  }
+  resolveNodeName(node) {
+    if (typeof node !== "function") return node;
+    return Object.entries(this._loop.nodes).find(([, fn]) => fn === node)?.[0];
+  }
+  searchTools(keywords, opts) {
+    this.logger.debug({ opts }, "[AGENT] Searching tools");
+    const page = opts?.page ?? 1;
+    const limit = opts?.limit ?? 5;
+    const matchedTools = rankToolsByKeywords(keywords, this._tools);
+    if (matchedTools.length <= 5 && !matchedTools.some((t) => t.toolName === webSearchTool.name)) {
+      matchedTools.push({ toolName: webSearchTool.name, score: 0.1, matchedKeywords: [], tool: webSearchTool });
+    }
+    if (matchedTools.length <= 5 && !matchedTools.some((t) => t.toolName === callAiTool.name)) {
+      matchedTools.push({ toolName: callAiTool.name, score: 0.1, matchedKeywords: [], tool: callAiTool });
+    }
+    const startIndex = (page - 1) * limit;
+    return matchedTools.slice(startIndex, startIndex + limit);
+  }
+  buildRunContext() {
+    const sessionId = this.currentChat._id?.toString() ?? "";
+    return {
+      task: this.currentChat.activeTask,
+      chat: this.currentChat,
+      currentUser: this.currentUser,
+      currentSession: this.currentSession,
+      currentMessage: this.currentMessage,
+      answerId: this.answerId,
+      tools: this._tools,
+      searchTools: this.searchTools.bind(this),
+      baseParams: {
+        currentUser: this.currentUser,
+        sessionId,
+        answerId: this.answerId
+      },
+      skillParams: {
+        sessionId,
+        answerId: this.answerId,
+        userMessage: this.currentMessage,
+        currentUser: this.currentUser,
+        currentSession: this.currentSession,
+        chat: this.currentChat
+      },
+      reply: (content) => this.currentChat.pushMessage({ _id: this.answerId, role: "assistant", content }),
+      setNextNode: (node) => {
+        const resolved = this.resolveNodeName(node);
+        const active = this.currentChat.activeTask;
+        if (active) active.setNextNode(resolved);
+        else this.pendingNextNode = resolved;
+      },
+      logger: this.logger
+    };
+  }
+}
+export {
+  AGENT_ERROR_CODES,
+  Agent
+};

package/dist/services/agent/core/index.d.ts

@@ -1,122 +1,3 @@
-import { A as AgentLoop } from '../../../agent-loop-ZH4GRi4A.js';
-export { a as AgentLoopNode, b as Author, R as RunContext } from '../../../agent-loop-ZH4GRi4A.js';
-import { c as ChatProps, C as Chat } from '../../../skill-CtYQbG6-.js';
-export { d as AgentError, e as AgentState, f as AgentStateProps, g as AgentStatus } from '../../../skill-CtYQbG6-.js';
-import { C as CurrentSession } from '../../../current-session-DC-SF7rl.js';
-import { B as BaseEntityProps, b as BaseEntity, C as CurrentUser } from '../../../current-user-4BppBUBP.js';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { B as BaseUseCaseParams, a as BaseUseCaseOutput } from '../../../base.use-case-ChEb3nh6.js';
-import { T as Tool } from '../../../tool-DMR_ZdjP.js';
-import 'bson';
-import '@modelcontextprotocol/sdk/types.js';
-
-interface QueryOptions {
-    page?: number;
-    limit?: number;
-    offset?: number;
-    sortBy?: {
-        [key: string]: 1 | -1;
-    };
-    aggregate?: boolean;
-    includeDeleted?: boolean;
-}
-
-type McpType = 'http';
-interface McpServerProps extends BaseEntityProps {
-    name?: string;
-    url?: string;
-    type?: McpType;
-    headers?: Record<string, string>;
-}
-declare class McpServer extends BaseEntity {
-    private readonly props;
-    name?: string | undefined;
-    url?: string | undefined;
-    type?: McpType | undefined;
-    headers?: Record<string, string> | undefined;
-    mcpClient?: Client;
-    static fromJSON(props: McpServerProps): McpServer;
-    constructor(props: McpServerProps, name?: string | undefined, url?: string | undefined, type?: McpType | undefined, headers?: Record<string, string> | undefined);
-    toJSON(): McpServerProps;
-    connect(): Promise<Client>;
-    disconnect(): Promise<void>;
-}
-
-interface Params extends BaseUseCaseParams {
-    filters: {
-        sessionId?: string;
-        messageId?: string;
-        fromDate?: string;
-        toDate?: string;
-    };
-}
-interface Output extends BaseUseCaseOutput {
-    data: {
-        totalTokens?: number;
-        tokensLimit?: number;
-    };
-}
-
-declare const AGENT_ERROR_CODES: {
-    readonly NODE_NOT_FOUND: "AGENT_NODE_NOT_FOUND";
-};
-interface AgentOptions {
-    loop: AgentLoop;
-    tools?: Tool[];
-}
-interface Input {
-    message: string;
-    chatId?: string;
-    messageId?: string;
-    isPrivateSession?: boolean;
-}
-type HookType = 'pre_execution' | 'post_execution';
-declare class Agent {
-    private readonly updateChatUseCase;
-    private readonly chatRepository;
-    private readonly logger;
-    private readonly _loop;
-    private _tools;
-    private _mcps;
-    private _preHooks;
-    private _postHooks;
-    private currentChat;
-    private currentUser?;
-    private currentSession?;
-    private currentMessage;
-    private answerId;
-    private stopLoop;
-    private stopRequested;
-    private pendingNextNode?;
-    static getChat(chatId: string): Promise<ChatProps | null>;
-    static interruptExecution(chatId: string, currentUser: CurrentUser): Promise<void>;
-    static createChatSession(currentUser: CurrentUser, loop?: AgentLoop): Promise<Chat>;
-    static listUserChats(options: QueryOptions, currentUser: CurrentUser): Promise<ChatProps[] | null>;
-    static getLLMUsage(filters: Params['filters'], currentUser: CurrentUser): Promise<Output['data']>;
-    static listUserMcpServers(options: QueryOptions, currentUser: CurrentUser): Promise<McpServerProps[] | null>;
-    static createMcpServer(payload: McpServerProps, currentUser: CurrentUser): Promise<McpServerProps>;
-    constructor(agentOptions: AgentOptions);
-    get tools(): Tool[];
-    get mcps(): McpServer[];
-    get notifyOnCompletion(): boolean | undefined;
-    get lastAssistantAnswer(): string | undefined;
-    run(input: Input, currentUser: CurrentUser, currentSession?: CurrentSession): Promise<{
-        data: Chat;
-    } | undefined>;
-    stopAgent(): void;
-    addTool(tool: Tool): void;
-    addHook(type: HookType, fn: Function): void;
-    private preRunner;
-    private postRunner;
-    private loadMcpServers;
-    private disconnectMcpServers;
-    private saveChat;
-    private checkInterruptionRequest;
-    private runLoop;
-    private resetNextNode;
-    private resolveNodeName;
-    private searchTools;
-    private buildRunContext;
-}
-
-export { AGENT_ERROR_CODES, Agent, AgentLoop, type AgentOptions };
+export * from './agent-loop';
+export * from './agent-state';
+export * from './agent';