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

package/dist/chunk-WERYJ6PF.js

@@ -0,0 +1,209 @@
+import {
+  BaseConnector
+} from "./chunk-DSBKVAWD.js";
+import {
+  __name
+} from "./chunk-3GQAWCBQ.js";
+
+// 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.
+`;
+var CodeModeConnector = class extends BaseConnector {
+  static {
+    __name(this, "CodeModeConnector");
+  }
+  mcpClient;
+  _tools;
+  constructor(client) {
+    super();
+    this.mcpClient = client;
+    this.connected = true;
+    this._tools = this._createToolsList();
+  }
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+  }
+  get publicIdentifier() {
+    return { name: "code_mode", version: "1.0.0" };
+  }
+  _createToolsList() {
+    return [
+      {
+        name: "execute_code",
+        description: "Execute JavaScript/TypeScript code with access to MCP tools. This is the PRIMARY way to interact with MCP servers in code mode. Write code that discovers tools using search_tools(), calls tools as async functions (e.g., await github.get_pull_request(...)), processes data efficiently, and returns results. Use 'await' for async operations and 'return' to return values. Available in code: search_tools(), __tool_namespaces, and server.tool_name() functions.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            code: {
+              type: "string",
+              description: "JavaScript/TypeScript code to execute. Use 'await' for async operations. Use 'return' to return a value. Available: search_tools(), server.tool_name(), __tool_namespaces"
+            },
+            timeout: {
+              type: "number",
+              description: "Execution timeout in milliseconds",
+              default: 3e4
+            }
+          },
+          required: ["code"]
+        }
+      },
+      {
+        name: "search_tools",
+        description: "Search and discover available MCP tools across all servers. Use this to find out what tools are available before writing code. Returns tool information including names, descriptions, and schemas. Can filter by query and control detail level.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Search query to filter tools by name or description",
+              default: ""
+            },
+            detail_level: {
+              type: "string",
+              description: "Detail level: 'names', 'descriptions', or 'full'",
+              enum: ["names", "descriptions", "full"],
+              default: "full"
+            }
+          }
+        }
+      }
+    ];
+  }
+  // Override tools getter to return static list immediately
+  get tools() {
+    return this._tools;
+  }
+  async initialize() {
+    this.toolsCache = this._tools;
+    return { capabilities: {}, version: "1.0.0" };
+  }
+  async callTool(name, args) {
+    if (name === "execute_code") {
+      const code = args.code;
+      const timeout = args.timeout || 3e4;
+      const result = await this.mcpClient.executeCode(code, timeout);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ]
+      };
+    } else if (name === "search_tools") {
+      const query = args.query || "";
+      const detailLevel = args.detail_level;
+      const result = await this.mcpClient.searchTools(
+        query,
+        detailLevel && detailLevel in ["names", "descriptions", "full"] ? detailLevel : "full"
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result)
+          }
+        ]
+      };
+    }
+    throw new Error(`Unknown tool: ${name}`);
+  }
+};
+
+// src/client/prompts.ts
+var PROMPTS = {
+  CODE_MODE: CODE_MODE_AGENT_PROMPT
+};
+
+export {
+  CodeModeConnector,
+  PROMPTS
+};

package/dist/chunk-ZFZPZ4GE.js

@@ -0,0 +1,21 @@
+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;
+  }
+};
+
+export {
+  BaseAgent
+};

package/dist/display-LIYVTGEU.js

@@ -0,0 +1,350 @@
+import {
+  __name
+} from "./chunk-3GQAWCBQ.js";
+
+// src/agents/display.ts
+import chalk from "chalk";
+import { highlight } from "cli-highlight";
+import stripAnsiLib from "strip-ansi";
+var TERMINAL_WIDTH = process.stdout.columns || 120;
+function stripAnsi(str) {
+  return stripAnsiLib(str);
+}
+__name(stripAnsi, "stripAnsi");
+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;
+}
+__name(wrapAnsiLine, "wrapAnsiLine");
+function printBox(content, title, language, bgColor = false) {
+  const width = TERMINAL_WIDTH;
+  let displayContent = content;
+  if (language) {
+    try {
+      displayContent = highlight(content, { language, ignoreIllegals: true });
+    } catch {
+    }
+  }
+  const lines = displayContent.split("\n").flatMap((line) => wrapAnsiLine(line, width - 4));
+  console.log(chalk.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(
+      chalk.gray("\u2502 ") + chalk.bold.white(lineText) + " ".repeat(padding) + chalk.gray(" \u2502")
+    );
+    console.log(chalk.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 ? chalk.bgGray(line + " ".repeat(padding)) : line + " ".repeat(padding);
+    console.log(chalk.gray("\u2502 ") + finalLine + chalk.gray(" \u2502"));
+  });
+  console.log(chalk.gray("\u2514" + "\u2500".repeat(width - 2) + "\u2518"));
+}
+__name(printBox, "printBox");
+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;
+}
+__name(extractCodeFromToolInput, "extractCodeFromToolInput");
+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);
+}
+__name(isExecuteCodeResult, "isExecuteCodeResult");
+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;
+}
+__name(parseExecuteCodeResult, "parseExecuteCodeResult");
+function renderContent(content) {
+  if (content === null || content === void 0) {
+    return "null";
+  }
+  if (typeof content === "object") {
+    return JSON.stringify(content, null, 2);
+  }
+  return String(content);
+}
+__name(renderContent, "renderContent");
+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;
+}
+__name(unwrapToolInput, "unwrapToolInput");
+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);
+  }
+}
+__name(handleToolStart, "handleToolStart");
+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;
+}
+__name(extractToolMessageContent, "extractToolMessageContent");
+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} ${chalk.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 += chalk.dim(` - ${tool.description}`);
+      }
+      lines.push(toolLine);
+    }
+  }
+  return lines.join("\n");
+}
+__name(formatSearchToolsAsTree, "formatSearchToolsAsTree");
+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 ? chalk.red("error") : chalk.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, chalk.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" ? chalk.green("Success") : chalk.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" ? chalk.green("Success") : isError ? chalk.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, chalk.red("Error"), void 0, false);
+    }
+    return;
+  }
+  const outputStr = renderContent(output);
+  const language = typeof output === "object" ? "json" : void 0;
+  printBox(outputStr, "Result", language, false);
+}
+__name(handleToolEnd, "handleToolEnd");
+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;
+}
+__name(prettyStreamEvents, "prettyStreamEvents");
+export {
+  extractCodeFromToolInput,
+  extractToolMessageContent,
+  formatSearchToolsAsTree,
+  handleToolEnd,
+  handleToolStart,
+  parseExecuteCodeResult,
+  prettyStreamEvents,
+  printBox,
+  renderContent,
+  unwrapToolInput
+};