openloops 0.1.9 → 0.1.10

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

@@ -0,0 +1,78 @@
+import "../../../chunk-XRJFNASX.mjs";
+var AgentStatus = /* @__PURE__ */ ((AgentStatus2) => {
+  AgentStatus2["IDLE"] = "idle";
+  AgentStatus2["FAILED"] = "failed";
+  AgentStatus2["PROCESSING"] = "processing";
+  AgentStatus2["AWAITING_USER_INPUT"] = "awaiting_user_input";
+  AgentStatus2["AWAITING_USER_CONFIRMATION"] = "awaiting_user_confirmation";
+  return AgentStatus2;
+})(AgentStatus || {});
+class AgentState {
+  constructor(status, language, lastError, activeTaskId, stopRequested, currentActivity) {
+    this.status = status;
+    this.language = language;
+    this.lastError = lastError;
+    this.activeTaskId = activeTaskId;
+    this.stopRequested = stopRequested;
+    this.currentActivity = currentActivity;
+  }
+  status;
+  language;
+  lastError;
+  activeTaskId;
+  stopRequested;
+  currentActivity;
+  static fromJSON(props = {}) {
+    return new AgentState(
+      props.status,
+      props.language,
+      props.lastError,
+      props.activeTaskId,
+      props.stopRequested,
+      props.currentActivity
+    );
+  }
+  toJSON() {
+    return {
+      currentActivity: this.currentActivity,
+      language: this.language,
+      status: this.status,
+      activeTaskId: this.activeTaskId,
+      lastError: this.lastError,
+      stopRequested: this.stopRequested
+    };
+  }
+  setLanguage(language) {
+    if (language) this.language = language;
+  }
+  setCurrentActivity(currentActivity) {
+    this.currentActivity = currentActivity;
+  }
+  setStatus(status) {
+    this.status = status;
+  }
+  setActiveTaskId(taskId) {
+    this.activeTaskId = taskId;
+  }
+  setLastError(lastError) {
+    this.lastError = lastError;
+  }
+  setStopRequested(stopRequested = true) {
+    this.stopRequested = stopRequested;
+  }
+  interruptExecution() {
+    this.stopRequested = true;
+  }
+  cleanContext() {
+    this.currentActivity = "";
+    this.language = "en";
+    this.status = "idle" /* IDLE */;
+    this.activeTaskId = void 0;
+    this.lastError = void 0;
+    this.stopRequested = false;
+  }
+}
+export {
+  AgentState,
+  AgentStatus
+};

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

@@ -0,0 +1,70 @@
+import 'reflect-metadata';
+import { CurrentUser, CurrentSession } from '@services/app/core';
+import { McpServer, McpServerProps } from '@services/agent/modules/mcp-servers/entities';
+import { Params as UsageParams, Output as UsageOutput } from '@services/agent/modules/llmcalls/lambdas/get-llm-usage';
+import { QueryOptions } from '@common/repositories';
+import { Chat, ChatProps } from '@services/agent/modules/chats/entities/chat.entity';
+import { Tool } from '@services/agent/tools/tool';
+import { AgentLoop } from './agent-loop';
+export declare const AGENT_ERROR_CODES: {
+    readonly NODE_NOT_FOUND: "AGENT_NODE_NOT_FOUND";
+};
+export interface AgentOptions {
+    loop: AgentLoop;
+    tools?: Tool[];
+}
+interface Input {
+    message: string;
+    chatId?: string;
+    messageId?: string;
+    isPrivateSession?: boolean;
+}
+type HookType = 'pre_execution' | 'post_execution';
+export 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: UsageParams['filters'], currentUser: CurrentUser): Promise<UsageOutput['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 {};

package/dist/services/agent/core/agent.js

@@ -0,0 +1,351 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var agent_exports = {};
+__export(agent_exports, {
+  AGENT_ERROR_CODES: () => AGENT_ERROR_CODES,
+  Agent: () => Agent
+});
+module.exports = __toCommonJS(agent_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_tsyringe = require("tsyringe");
+var import_logger = require("@common/logger");
+var import_create_chat = require("@services/agent/modules/chats/lambdas/create-chat/");
+var import_update_chat = require("@services/agent/modules/chats/lambdas/update-chat/");
+var import_list_chats_by_user = require("@services/agent/modules/chats/lambdas/list-chats-by-user");
+var import_list_mcpservers_by_user = require("@services/agent/modules/mcp-servers/lambdas/list-mcpservers-by-user");
+var import_entities = require("@services/agent/modules/mcp-servers/entities");
+var import_create_mcpserver = require("@services/agent/modules/mcp-servers/lambdas/create-mcpserver");
+var import_repositories = require("@services/agent/modules/chats/repositories");
+var import_get_llm_usage = require("@services/agent/modules/llmcalls/lambdas/get-llm-usage");
+var import_chat = require("@services/agent/modules/chats/entities/chat.entity");
+var import_tool = require("@services/agent/tools/tool");
+var import_core2 = require("@services/agent/tools/core");
+var import_rank_tools_by_keywords = require("@services/agent/utils/rank-tools-by-keywords");
+var import_agent_state = require("./agent-state");
+const AGENT_ERROR_CODES = {
+  NODE_NOT_FOUND: "AGENT_NODE_NOT_FOUND"
+};
+const MAX_ITERATIONS = 50;
+class Agent {
+  updateChatUseCase = import_tsyringe.container.resolve(import_update_chat.UpdateChatUseCase);
+  chatRepository = import_tsyringe.container.resolve(import_repositories.ChatRepository);
+  logger = new import_logger.Logger();
+  _loop;
+  _tools;
+  _mcps = [];
+  _preHooks = [];
+  _postHooks = [];
+  currentChat;
+  currentUser;
+  currentSession;
+  currentMessage = "";
+  answerId = "";
+  stopLoop = false;
+  stopRequested = false;
+  pendingNextNode;
+  static async getChat(chatId) {
+    const chatRepository = import_tsyringe.container.resolve(import_repositories.ChatRepository);
+    return chatRepository.findById(chatId);
+  }
+  static async interruptExecution(chatId, currentUser) {
+    const updateChatUseCase = import_tsyringe.container.resolve(import_update_chat.UpdateChatUseCase);
+    const logger = new import_logger.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 = import_tsyringe.container.resolve(import_create_chat.CreateChatUseCase);
+    const newChat = import_chat.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 import_chat.Chat.fromJSON(data);
+  }
+  static async listUserChats(options, currentUser) {
+    const listChatsByUserUseCase = import_tsyringe.container.resolve(import_list_chats_by_user.ListChatsByUserUseCase);
+    const { page, limit } = options || {};
+    const { data } = await listChatsByUserUseCase.execute({
+      options: { page, limit },
+      currentUser
+    });
+    return data;
+  }
+  static async getLLMUsage(filters, currentUser) {
+    const getLLMUsageUseCase = import_tsyringe.container.resolve(import_get_llm_usage.GetLLMUsageUseCase);
+    const { data } = await getLLMUsageUseCase.execute({ filters, currentUser });
+    return data;
+  }
+  static async listUserMcpServers(options, currentUser) {
+    const listMcpServersByUserUseCase = import_tsyringe.container.resolve(import_list_mcpservers_by_user.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 = import_tsyringe.container.resolve(import_create_mcpserver.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 = import_chat.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(import_agent_state.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 = import_chat.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(import_agent_state.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 = import_entities.McpServer.fromJSON(props);
+      try {
+        const mcpClient = await mcpServer.connect();
+        const { tools: mcpTools } = await mcpClient.listTools();
+        const tools = mcpTools.map((mcpTool) => import_tool.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(import_agent_state.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(import_agent_state.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 === import_agent_state.AgentStatus.IDLE || this.currentChat.state?.status === import_agent_state.AgentStatus.FAILED || this.currentChat.state?.status === import_agent_state.AgentStatus.AWAITING_USER_INPUT || this.currentChat.state?.status === import_agent_state.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 = (0, import_rank_tools_by_keywords.rankToolsByKeywords)(keywords, this._tools);
+    if (matchedTools.length <= 5 && !matchedTools.some((t) => t.toolName === import_core2.webSearchTool.name)) {
+      matchedTools.push({ toolName: import_core2.webSearchTool.name, score: 0.1, matchedKeywords: [], tool: import_core2.webSearchTool });
+    }
+    if (matchedTools.length <= 5 && !matchedTools.some((t) => t.toolName === import_core2.callAiTool.name)) {
+      matchedTools.push({ toolName: import_core2.callAiTool.name, score: 0.1, matchedKeywords: [], tool: import_core2.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
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AGENT_ERROR_CODES,
+  Agent
+});