openloops 0.1.8 → 0.1.10

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
+});

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
+};