mcp-use 1.3.4-canary.2 → 1.4.0-canary.3

package/dist/src/agents/display.d.ts

@@ -0,0 +1,54 @@
+import type { StreamEvent } from "@langchain/core/tracers/log_stream";
+interface ExecuteCodeResult {
+    result: unknown;
+    logs: string[];
+    error: string | null;
+    execution_time: number;
+}
+export declare function printBox(content: string, title?: string, language?: string, bgColor?: boolean): void;
+/**
+ * Extract code from tool input if present
+ */
+export declare function extractCodeFromToolInput(input: unknown): string | null;
+/**
+ * Parse execute_code tool result
+ */
+export declare function parseExecuteCodeResult(output: unknown): ExecuteCodeResult | null;
+/**
+ * Render content with appropriate formatting
+ */
+export declare function renderContent(content: unknown): string;
+/**
+ * Unwrap tool input if it's wrapped in an "input" field with JSON string
+ */
+export declare function unwrapToolInput(input: unknown): unknown;
+/**
+ * Handle tool start event with pretty printing
+ */
+export declare function handleToolStart(event: StreamEvent): void;
+/**
+ * Extract content from LangChain ToolMessage structure
+ */
+export declare function extractToolMessageContent(output: unknown): {
+    toolName: string;
+    status: string;
+    content: unknown;
+} | null;
+/**
+ * Format search_tools result as a tree structure
+ */
+export declare function formatSearchToolsAsTree(tools: Array<{
+    server: string;
+    name: string;
+    description?: string;
+}>): string;
+/**
+ * Handle tool end event with pretty printing
+ */
+export declare function handleToolEnd(event: StreamEvent): void;
+/**
+ * Stream events with pretty printing
+ */
+export declare function prettyStreamEvents(streamEventsGenerator: AsyncGenerator<StreamEvent, void, void>): AsyncGenerator<void, string, void>;
+export {};
+//# sourceMappingURL=display.d.ts.map

package/dist/src/agents/display.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display.d.ts","sourceRoot":"","sources":["../../../src/agents/display.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AAWtE,UAAU,iBAAiB;IACzB,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB;AAkDD,wBAAgB,QAAQ,CACtB,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,MAAM,EACd,QAAQ,CAAC,EAAE,MAAM,EACjB,OAAO,UAAQ,QA2ChB;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAMtE;AAmBD;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,OAAO,GACd,iBAAiB,GAAG,IAAI,CAiB1B;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAUtD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAevD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,QAqBjD;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,OAAO,GACd;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAsC/D;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,KAAK,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACnE,MAAM,CAgDR;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,WAAW,QAyK/C;AAED;;GAEG;AACH,wBAAuB,kBAAkB,CACvC,qBAAqB,EAAE,cAAc,CAAC,WAAW,EAAE,IAAI,EAAE,IAAI,CAAC,GAC7D,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,CAoCpC"}

package/dist/src/agents/index.cjs

@@ -559,15 +559,467 @@ var init_langfuse = __esm({
   }
 });
 
+// src/agents/display.ts
+var display_exports = {};
+__export(display_exports, {
+  extractCodeFromToolInput: () => extractCodeFromToolInput,
+  extractToolMessageContent: () => extractToolMessageContent,
+  formatSearchToolsAsTree: () => formatSearchToolsAsTree,
+  handleToolEnd: () => handleToolEnd,
+  handleToolStart: () => handleToolStart,
+  parseExecuteCodeResult: () => parseExecuteCodeResult,
+  prettyStreamEvents: () => prettyStreamEvents,
+  printBox: () => printBox,
+  renderContent: () => renderContent,
+  unwrapToolInput: () => unwrapToolInput
+});
+function stripAnsi(str) {
+  return (0, import_strip_ansi.default)(str);
+}
+function wrapAnsiLine(line, maxWidth) {
+  const stripped = stripAnsi(line);
+  if (stripped.length <= maxWidth) return [line];
+  const result = [];
+  let visibleCount = 0;
+  let current = "";
+  let i = 0;
+  while (i < line.length) {
+    const char = line[i];
+    if (char === "\x1B") {
+      let sequence = char;
+      i++;
+      while (i < line.length) {
+        const nextChar = line[i];
+        sequence += nextChar;
+        i++;
+        if (nextChar === "m") break;
+      }
+      current += sequence;
+      continue;
+    }
+    current += char;
+    visibleCount++;
+    i++;
+    if (visibleCount >= maxWidth) {
+      result.push(current);
+      current = "";
+      visibleCount = 0;
+    }
+  }
+  if (current) result.push(current);
+  return result;
+}
+function printBox(content, title, language, bgColor = false) {
+  const width = TERMINAL_WIDTH;
+  let displayContent = content;
+  if (language) {
+    try {
+      displayContent = (0, import_cli_highlight.highlight)(content, { language, ignoreIllegals: true });
+    } catch {
+    }
+  }
+  const lines = displayContent.split("\n").flatMap((line) => wrapAnsiLine(line, width - 4));
+  console.log(import_chalk.default.gray("\u250C" + "\u2500".repeat(width - 2) + "\u2510"));
+  if (title) {
+    const stripped = stripAnsi(title);
+    const lineText = `${title} `;
+    const padding = Math.max(0, width - 4 - stripped.length - 2);
+    console.log(
+      import_chalk.default.gray("\u2502 ") + import_chalk.default.bold.white(lineText) + " ".repeat(padding) + import_chalk.default.gray(" \u2502")
+    );
+    console.log(import_chalk.default.gray("\u251C" + "\u2500".repeat(width - 2) + "\u2524"));
+  }
+  lines.forEach((line) => {
+    const stripped = stripAnsi(line);
+    const padding = Math.max(0, width - 4 - stripped.length);
+    const finalLine = bgColor ? import_chalk.default.bgGray(line + " ".repeat(padding)) : line + " ".repeat(padding);
+    console.log(import_chalk.default.gray("\u2502 ") + finalLine + import_chalk.default.gray(" \u2502"));
+  });
+  console.log(import_chalk.default.gray("\u2514" + "\u2500".repeat(width - 2) + "\u2518"));
+}
+function extractCodeFromToolInput(input) {
+  if (typeof input === "object" && input !== null && "code" in input) {
+    const inputObj = input;
+    return typeof inputObj.code === "string" ? inputObj.code : null;
+  }
+  return null;
+}
+function isExecuteCodeResult(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const result = obj;
+  return "result" in result && "logs" in result && Array.isArray(result.logs) && "execution_time" in result && typeof result.execution_time === "number" && "error" in result && (typeof result.error === "string" || result.error === null);
+}
+function parseExecuteCodeResult(output) {
+  try {
+    if (typeof output === "string") {
+      const parsed = JSON.parse(output);
+      if (isExecuteCodeResult(parsed)) {
+        return parsed;
+      }
+    }
+    if (isExecuteCodeResult(output)) {
+      return output;
+    }
+  } catch (e) {
+  }
+  return null;
+}
+function renderContent(content) {
+  if (content === null || content === void 0) {
+    return "null";
+  }
+  if (typeof content === "object") {
+    return JSON.stringify(content, null, 2);
+  }
+  return String(content);
+}
+function unwrapToolInput(input) {
+  if (typeof input === "object" && input !== null && "input" in input) {
+    const inputObj = input;
+    if (typeof inputObj.input === "string") {
+      try {
+        return JSON.parse(inputObj.input);
+      } catch (e) {
+        return inputObj.input;
+      }
+    }
+  }
+  return input;
+}
+function handleToolStart(event) {
+  const toolName = event.name || "unknown";
+  let input = event.data?.input || {};
+  input = unwrapToolInput(input);
+  const code = extractCodeFromToolInput(input);
+  if (code) {
+    printBox(code, `${toolName} - input`, "javascript", false);
+    const otherParams = { ...input };
+    delete otherParams.code;
+    if (Object.keys(otherParams).length > 0) {
+      printBox(renderContent(otherParams), "Other Parameters", "json", false);
+    }
+  } else {
+    printBox(renderContent(input), `${toolName} - input`, "json", false);
+  }
+}
+function extractToolMessageContent(output) {
+  try {
+    if (typeof output === "object" && output !== null && "name" in output && "content" in output) {
+      const outputObj = output;
+      const toolName = (typeof outputObj.name === "string" ? outputObj.name : null) || "unknown";
+      const lcKwargs = outputObj.lc_kwargs;
+      const status = lcKwargs?.status || outputObj.status || "unknown";
+      let content = outputObj.content;
+      if (typeof content === "string") {
+        try {
+          content = JSON.parse(content);
+        } catch (e) {
+        }
+      }
+      return { toolName, status, content };
+    }
+  } catch (e) {
+  }
+  return null;
+}
+function formatSearchToolsAsTree(tools) {
+  if (!Array.isArray(tools) || tools.length === 0) {
+    return "(no tools found)";
+  }
+  const toolsByServer = {};
+  for (const tool of tools) {
+    const server = tool.server || "unknown";
+    if (!toolsByServer[server]) {
+      toolsByServer[server] = [];
+    }
+    toolsByServer[server].push(tool);
+  }
+  const lines = [];
+  const servers = Object.keys(toolsByServer).sort();
+  for (let i = 0; i < servers.length; i++) {
+    const server = servers[i];
+    const serverTools = toolsByServer[server];
+    const isLastServer = i === servers.length - 1;
+    const serverPrefix = isLastServer ? "\u2514\u2500" : "\u251C\u2500";
+    lines.push(
+      `${serverPrefix} ${import_chalk.default.cyan(server)} (${serverTools.length} tools)`
+    );
+    for (let j = 0; j < serverTools.length; j++) {
+      const tool = serverTools[j];
+      const isLastTool = j === serverTools.length - 1;
+      const indent = isLastServer ? "  " : "\u2502 ";
+      const toolPrefix = isLastTool ? "\u2514\u2500" : "\u251C\u2500";
+      let toolLine = `${indent}${toolPrefix} ${tool.name}`;
+      if (tool.description) {
+        toolLine += import_chalk.default.dim(` - ${tool.description}`);
+      }
+      lines.push(toolLine);
+    }
+  }
+  return lines.join("\n");
+}
+function handleToolEnd(event) {
+  const output = event.data?.output;
+  const toolMessage = extractToolMessageContent(output);
+  if (toolMessage) {
+    const { toolName, status, content } = toolMessage;
+    if (toolName === "execute_code") {
+      let actualContent = content;
+      if (typeof content === "object" && content !== null && "content" in content) {
+        const innerContent = content.content;
+        if (Array.isArray(innerContent) && innerContent.length > 0) {
+          if (innerContent[0].type === "text" && innerContent[0].text) {
+            actualContent = innerContent[0].text;
+          }
+        }
+      }
+      const execResult2 = parseExecuteCodeResult(actualContent);
+      if (execResult2) {
+        const timeMs = execResult2.execution_time ? Math.round(execResult2.execution_time * 1e3) : 0;
+        const timeStr = `${timeMs}ms`;
+        const isError2 = execResult2.error !== null && execResult2.error !== void 0 && execResult2.error !== "";
+        const statusText = isError2 ? import_chalk.default.red("error") : import_chalk.default.green("success");
+        const title2 = `${toolName} - ${statusText} - ${timeStr}`;
+        if (execResult2.result !== null && execResult2.result !== void 0) {
+          const resultStr = renderContent(execResult2.result);
+          const language3 = typeof execResult2.result === "object" ? "json" : void 0;
+          printBox(resultStr, title2, language3, false);
+        } else {
+          printBox("(no result)", title2, void 0, false);
+        }
+        if (execResult2.logs && execResult2.logs.length > 0) {
+          printBox(execResult2.logs.join("\n"), `Logs`, void 0, false);
+        }
+        if (execResult2.error) {
+          printBox(execResult2.error, import_chalk.default.red("Error"), void 0, false);
+        }
+        return;
+      }
+    }
+    if (toolName === "search_tools") {
+      let actualContent = content;
+      if (typeof content === "object" && content !== null && !Array.isArray(content) && "content" in content) {
+        const innerContent = content.content;
+        if (Array.isArray(innerContent) && innerContent.length > 0) {
+          if (innerContent[0].type === "text" && innerContent[0].text) {
+            try {
+              actualContent = JSON.parse(innerContent[0].text);
+            } catch (e) {
+              actualContent = innerContent[0].text;
+            }
+          }
+        }
+      }
+      if (Array.isArray(actualContent)) {
+        const treeStr = formatSearchToolsAsTree(actualContent);
+        const statusText = status === "success" ? import_chalk.default.green("Success") : import_chalk.default.red("Error");
+        const title2 = `${statusText}: ${toolName} - Result`;
+        printBox(treeStr, title2, void 0, false);
+        return;
+      }
+    }
+    const contentObj = typeof content === "object" && content !== null ? content : null;
+    const isError = contentObj && "isError" in contentObj && contentObj.isError === true || status === "error";
+    let displayContent = content;
+    if (typeof content === "object" && content !== null && "content" in content) {
+      displayContent = content.content;
+      if (Array.isArray(displayContent) && displayContent.length > 0) {
+        if (displayContent[0].type === "text" && displayContent[0].text) {
+          displayContent = displayContent[0].text;
+        }
+      }
+    }
+    const contentStr = renderContent(displayContent);
+    const language2 = typeof displayContent === "object" ? "json" : void 0;
+    const statusLabel = status === "success" ? import_chalk.default.green("Success") : isError ? import_chalk.default.red("Error") : "Result";
+    const title = `${statusLabel}: ${toolName} - Result`;
+    printBox(contentStr, title, language2, false);
+    return;
+  }
+  const execResult = parseExecuteCodeResult(output);
+  if (execResult) {
+    const timeMs = execResult.execution_time ? Math.round(execResult.execution_time * 1e3) : 0;
+    const timeStr = `${timeMs}ms`;
+    if (execResult.result !== null && execResult.result !== void 0) {
+      const resultStr = renderContent(execResult.result);
+      const language2 = typeof execResult.result === "object" ? "json" : void 0;
+      printBox(resultStr, `Result - ${timeStr}`, language2, false);
+    }
+    if (execResult.logs && execResult.logs.length > 0) {
+      printBox(execResult.logs.join("\n"), `Logs`, void 0, false);
+    }
+    if (execResult.error) {
+      printBox(execResult.error, import_chalk.default.red("Error"), void 0, false);
+    }
+    return;
+  }
+  const outputStr = renderContent(output);
+  const language = typeof output === "object" ? "json" : void 0;
+  printBox(outputStr, "Result", language, false);
+}
+async function* prettyStreamEvents(streamEventsGenerator) {
+  let finalResponse = "";
+  let isFirstTextChunk = true;
+  let hasStreamedText = false;
+  for await (const event of streamEventsGenerator) {
+    if (event.event === "on_tool_start") {
+      if (hasStreamedText) {
+        process.stdout.write("\n");
+        hasStreamedText = false;
+        isFirstTextChunk = true;
+      }
+      handleToolStart(event);
+    } else if (event.event === "on_tool_end") {
+      handleToolEnd(event);
+    } else if (event.event === "on_chat_model_stream") {
+      if (event.data?.chunk?.text) {
+        const text = event.data.chunk.text;
+        if (typeof text === "string" && text.length > 0) {
+          if (isFirstTextChunk) {
+            process.stdout.write("\n\u{1F916} ");
+            isFirstTextChunk = false;
+          }
+          process.stdout.write(text);
+          finalResponse += text;
+          hasStreamedText = true;
+        }
+      }
+    }
+    yield;
+  }
+  return finalResponse;
+}
+var import_chalk, import_cli_highlight, import_strip_ansi, TERMINAL_WIDTH;
+var init_display = __esm({
+  "src/agents/display.ts"() {
+    "use strict";
+    import_chalk = __toESM(require("chalk"), 1);
+    import_cli_highlight = require("cli-highlight");
+    import_strip_ansi = __toESM(require("strip-ansi"), 1);
+    TERMINAL_WIDTH = process.stdout.columns || 120;
+    __name(stripAnsi, "stripAnsi");
+    __name(wrapAnsiLine, "wrapAnsiLine");
+    __name(printBox, "printBox");
+    __name(extractCodeFromToolInput, "extractCodeFromToolInput");
+    __name(isExecuteCodeResult, "isExecuteCodeResult");
+    __name(parseExecuteCodeResult, "parseExecuteCodeResult");
+    __name(renderContent, "renderContent");
+    __name(unwrapToolInput, "unwrapToolInput");
+    __name(handleToolStart, "handleToolStart");
+    __name(extractToolMessageContent, "extractToolMessageContent");
+    __name(formatSearchToolsAsTree, "formatSearchToolsAsTree");
+    __name(handleToolEnd, "handleToolEnd");
+    __name(prettyStreamEvents, "prettyStreamEvents");
+  }
+});
+
 // src/agents/index.ts
 var agents_exports = {};
 __export(agents_exports, {
   BaseAgent: () => BaseAgent,
   MCPAgent: () => MCPAgent,
+  PROMPTS: () => PROMPTS,
   RemoteAgent: () => RemoteAgent
 });
 module.exports = __toCommonJS(agents_exports);
 
+// src/connectors/base.ts
+init_logging();
+
+// src/client/connectors/codeMode.ts
+var CODE_MODE_AGENT_PROMPT = `
+## MCP Code Mode Tool Usage Guide
+
+You have access to an MCP Code Mode Client that allows you to execute JavaScript/TypeScript code with access to registered tools. Follow this workflow:
+
+### 1. Tool Discovery Phase
+**Always start by discovering available tools:**
+- Tools are organized by server namespace (e.g., \`server_name.tool_name\`)
+- Use the \`search_tools(query, detail_level)\` function to find available tools
+- You can access \`__tool_namespaces\` to see all available server namespaces
+
+\`\`\`javascript
+// Find all GitHub-related tools
+const tools = await search_tools("github");
+for (const tool of tools) {
+    console.log(\`\${tool.server}.\${tool.name}: \${tool.description}\`);
+}
+
+// Get only tool names for quick overview
+const tools = await search_tools("", "names");
+\`\`\`
+
+### 2. Interface Introspection
+**Understand tool contracts before using them:**
+- Use \`search_tools\` to get tool descriptions and input schemas
+- Look for "Access as: server.tool(args)" patterns in descriptions
+
+### 3. Code Execution Guidelines
+**When writing code:**
+- Use \`await server.tool({ param: value })\` syntax for all tool calls
+- Tools are async functions that return promises
+- You have access to standard JavaScript globals: \`console\`, \`JSON\`, \`Math\`, \`Date\`, etc.
+- All console output (\`console.log\`, \`console.error\`, etc.) is automatically captured and returned
+- Build properly structured input objects based on interface definitions
+- Handle errors appropriately with try/catch blocks
+- Chain tool calls by using results from previous calls
+
+### 4. Best Practices
+- **Discover first, code second**: Always explore available tools before writing execution code
+- **Respect namespaces**: Use full \`server.tool\` names to avoid conflicts
+- **Minimize Context**: Process large data in code, return only essential results
+- **Error handling**: Wrap tool calls in try/catch for robustness
+- **Data flow**: Chain tools by passing outputs as inputs to subsequent tools
+
+### 5. Available Runtime Context
+- \`search_tools(query, detail_level)\`: Function to discover tools
+- \`__tool_namespaces\`: Array of available server namespaces
+- All registered tools as \`server.tool\` functions
+- Standard JavaScript built-ins for data processing
+
+### Example Workflow
+
+\`\`\`javascript
+// 1. Discover available tools
+const github_tools = await search_tools("github pull request");
+console.log(\`Available GitHub PR tools: \${github_tools.map(t => t.name)}\`);
+
+// 2. Call tools with proper parameters
+const pr = await github.get_pull_request({
+    owner: "facebook",
+    repo: "react",
+    number: 12345
+});
+
+// 3. Process results
+let result;
+if (pr.state === 'open' && pr.labels.some(l => l.name === 'bug')) {
+    // 4. Chain with other tools
+    await slack.post_message({
+        channel: "#bugs",
+        text: \`\u{1F41B} Bug PR needs review: \${pr.title}\`
+    });
+    result = "Notification sent";
+} else {
+    result = "No action needed";
+}
+
+// 5. Return structured results
+return {
+    pr_number: pr.number,
+    pr_title: pr.title,
+    action_taken: result
+};
+\`\`\`
+
+Remember: Always discover and understand available tools before attempting to use them in code execution.
+`;
+
+// src/client/prompts.ts
+var PROMPTS = {
+  CODE_MODE: CODE_MODE_AGENT_PROMPT
+};
+
 // src/agents/base.ts
 var BaseAgent = class {
   static {
@@ -2162,18 +2614,35 @@ var MCPAgent = class {
         logger.info(
           `\u{1F50C} Found ${Object.keys(this.sessions).length} existing sessions`
         );
-        if (Object.keys(this.sessions).length === 0) {
+        const nonCodeModeSessions = Object.keys(this.sessions).filter(
+          (name) => name !== "code_mode"
+        );
+        if (nonCodeModeSessions.length === 0) {
           logger.info("\u{1F504} No active sessions found, creating new ones...");
           this.sessions = await this.client.createAllSessions();
           logger.info(
             `\u2705 Created ${Object.keys(this.sessions).length} new sessions`
           );
         }
-        this._tools = await LangChainAdapter.createTools(this.client);
+        if (this.client.codeMode) {
+          const codeModeSession = this.sessions["code_mode"];
+          if (codeModeSession) {
+            this._tools = await this.adapter.createToolsFromConnectors([
+              codeModeSession.connector
+            ]);
+            logger.info(`\u{1F6E0}\uFE0F Created ${this._tools.length} code mode tools`);
+          } else {
+            throw new Error(
+              "Code mode enabled but code_mode session not found"
+            );
+          }
+        } else {
+          this._tools = await LangChainAdapter.createTools(this.client);
+          logger.info(
+            `\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain tools from client`
+          );
+        }
         this._tools.push(...this.additionalTools);
-        logger.info(
-          `\u{1F6E0}\uFE0F Created ${this._tools.length} LangChain tools from client`
-        );
       } else {
         logger.info(
           `\u{1F517} Connecting to ${this.connectors.length} direct connectors...`
@@ -2738,6 +3207,8 @@ var MCPAgent = class {
           tags: this.getTags(),
           // Set trace name for LangChain/Langfuse
           runName: this.metadata.trace_name || "mcp-use-agent",
+          // Set recursion limit to 3x maxSteps to account for model calls + tool executions
+          recursionLimit: this.maxSteps * 3,
           // Pass sessionId for Langfuse if present in metadata
           ...this.metadata.session_id && {
             sessionId: this.metadata.session_id
@@ -2951,8 +3422,8 @@ var MCPAgent = class {
       this._agentExecutor = null;
       this._tools = [];
       if (this.client) {
-        logger.info("\u{1F504} Closing sessions through client");
-        await this.client.closeAllSessions();
+        logger.info("\u{1F504} Closing client and cleaning up resources");
+        await this.client.close();
         this.sessions = {};
       } else {
         for (const connector of this.connectors) {
@@ -2968,6 +3439,26 @@ var MCPAgent = class {
       logger.info("\u{1F44B} Agent closed successfully");
     }
   }
+  /**
+   * Yields with pretty-printed output for code mode.
+   * This method formats and displays tool executions in a user-friendly way with syntax highlighting.
+   */
+  async *prettyStreamEvents(query, maxSteps, manageConnector = true, externalHistory, outputSchema) {
+    const { prettyStreamEvents: prettyStream } = await Promise.resolve().then(() => (init_display(), display_exports));
+    const finalResponse = "";
+    for await (const _ of prettyStream(
+      this.streamEvents(
+        query,
+        maxSteps,
+        manageConnector,
+        externalHistory,
+        outputSchema
+      )
+    )) {
+      yield;
+    }
+    return finalResponse;
+  }
   /**
    * Yields LangChain StreamEvent objects from the underlying streamEvents() method.
    * This provides token-level streaming and fine-grained event updates.
@@ -2995,11 +3486,11 @@ var MCPAgent = class {
         throw new Error("MCP agent failed to initialize");
       }
       this.maxSteps = maxSteps ?? this.maxSteps;
-      const display_query = query.length > 50 ? `${query.slice(0, 50).replace(/\n/g, " ")}...` : query.replace(/\n/g, " ");
+      const display_query = typeof query === "string" && query.length > 50 ? `${query.slice(0, 50).replace(/\n/g, " ")}...` : typeof query === "string" ? query.replace(/\n/g, " ") : String(query);
       logger.info(`\u{1F4AC} Received query for streamEvents: '${display_query}'`);
       if (this.memoryEnabled) {
-        logger.info(`\u{1F504} Adding user message to history: ${query}`);
-        this.addToHistory(new import_langchain2.HumanMessage(query));
+        logger.info(`\u{1F504} Adding user message to history: ${display_query}`);
+        this.addToHistory(new import_langchain2.HumanMessage({ content: query }));
       }
       const historyToUse = externalHistory ?? this.conversationHistory;
       const langchainHistory = [];
@@ -3027,6 +3518,8 @@ var MCPAgent = class {
           tags: this.getTags(),
           // Set trace name for LangChain/Langfuse
           runName: this.metadata.trace_name || "mcp-use-agent",
+          // Set recursion limit to 3x maxSteps to account for model calls + tool executions
+          recursionLimit: this.maxSteps * 3,
           // Pass sessionId for Langfuse if present in metadata
           ...this.metadata.session_id && {
             sessionId: this.metadata.session_id
@@ -3126,6 +3619,7 @@ var MCPAgent = class {
       } else if (this.memoryEnabled && finalResponse) {
         this.addToHistory(new import_langchain2.AIMessage(finalResponse));
       }
+      console.log("\n\n");
       logger.info(`\u{1F389} StreamEvents complete - ${eventCount} events emitted`);
       success = true;
     } catch (e) {

package/dist/src/agents/index.d.ts

@@ -1,3 +1,4 @@
+export { PROMPTS } from "../client/prompts.js";
 export { BaseAgent } from "./base.js";
 export { MCPAgent } from "./mcp_agent.js";
 export { RemoteAgent } from "./remote.js";

package/dist/src/agents/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/agents/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/agents/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}

package/dist/src/agents/index.js

@@ -1,28 +1,20 @@
+import {
+  BaseAgent
+} from "../../chunk-ZFZPZ4GE.js";
 import {
   MCPAgent,
   RemoteAgent
-} from "../../chunk-6EHM3S3M.js";
+} from "../../chunk-35A6O3YH.js";
+import {
+  PROMPTS
+} from "../../chunk-WERYJ6PF.js";
+import "../../chunk-DSBKVAWD.js";
 import "../../chunk-YURRUCIM.js";
 import "../../chunk-34R6SIER.js";
-import {
-  __name
-} from "../../chunk-3GQAWCBQ.js";
-
-// src/agents/base.ts
-var BaseAgent = class {
-  static {
-    __name(this, "BaseAgent");
-  }
-  session;
-  /**
-   * @param session MCP session used for tool invocation
-   */
-  constructor(session) {
-    this.session = session;
-  }
-};
+import "../../chunk-3GQAWCBQ.js";
 export {
   BaseAgent,
   MCPAgent,
+  PROMPTS,
   RemoteAgent
 };