@mcp-use/agent 2.0.0-beta.13 → 2.0.0-beta.15

package/dist/index.js

@@ -478,6 +478,62 @@ function toolImageFollowupHeader(toolName, count) {
 }
 
 // src/llm/messageFormat.ts
+function messageText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.map(
+      (part) => part && typeof part === "object" && "text" in part && typeof part.text === "string" ? part.text : ""
+    ).join("");
+  }
+  return JSON.stringify(content ?? "");
+}
+function langChainMessageType(message) {
+  try {
+    if (typeof message._getType === "function") return message._getType();
+    if (typeof message.getType === "function") return message.getType();
+  } catch {
+  }
+  return message.type ?? "";
+}
+function convertExternalHistoryToProvider(messages) {
+  return messages.map((raw, index) => {
+    const message = raw;
+    const type = langChainMessageType(message);
+    const content = messageText(message.content);
+    if (type === "human" || type === "user") {
+      return { role: "user", content };
+    }
+    if (type === "system") {
+      return { role: "system", content };
+    }
+    if (type === "ai" || type === "assistant") {
+      const toolCalls = message.tool_calls?.map((call, callIndex) => ({
+        id: call.id ?? `external_${index}_${callIndex}`,
+        name: call.name,
+        args: call.args ?? {}
+      }));
+      return {
+        role: "assistant",
+        content,
+        ...toolCalls?.length ? { toolCalls } : {}
+      };
+    }
+    if (type === "tool") {
+      const toolIsError = message.status === "error" || isToolResultError(message.content);
+      return {
+        role: "tool",
+        content,
+        toolCallId: message.tool_call_id ?? `external_${index}`,
+        ...message.name ? { toolName: message.name } : {},
+        toolResult: message.content,
+        ...toolIsError ? { toolIsError: true } : {}
+      };
+    }
+    throw new TypeError(
+      `Unsupported external history message type at index ${index}: ${type || "unknown"}`
+    );
+  });
+}
 function extractText(m) {
   const raw = typeof m.content === "string" ? m.content : Array.isArray(m.content) ? m.content.map((x) => x?.text ?? "").join("\n") : JSON.stringify(m.content ?? "");
   if (raw.trim()) return raw.trim();
@@ -878,7 +934,11 @@ async function* streamChat(params) {
           try {
             args = JSON.parse(entry.argsJson);
           } catch {
-            args = {};
+            yield {
+              type: "error",
+              message: `Anthropic returned invalid JSON arguments for tool "${entry.name}".`
+            };
+            return;
           }
         }
         yield {
@@ -1941,14 +2001,21 @@ function appendToolOutputsToInput(input, callId, toolName, result) {
     });
   }
 }
+function responsesReasoningFields(config) {
+  const effort = config.reasoningEffort;
+  if (!effort || effort === "none") return {};
+  return {
+    include: ["reasoning.encrypted_content"],
+    reasoning: { effort }
+  };
+}
 function buildResponsesBody(params, stream) {
   const body = {
     model: params.config.model,
     input: params.input,
     store: false,
-    include: ["reasoning.encrypted_content"],
-    reasoning: { effort: params.config.reasoningEffort ?? "low" },
-    stream
+    stream,
+    ...responsesReasoningFields(params.config)
   };
   if (params.instructions) body.instructions = params.instructions;
   if (params.tools && params.tools.length > 0) {
@@ -2455,12 +2522,12 @@ async function* streamNativeAgent(driver, options) {
 }
 async function* streamNativeAgentSteps(driver, options) {
   let finalText = "";
-  let pendingStep = null;
+  const pendingSteps = /* @__PURE__ */ new Map();
   for await (const ev of streamNativeAgent(driver, options)) {
     if (ev.type === "text-delta") {
       finalText += ev.delta;
     } else if (ev.type === "tool-call-ready") {
-      pendingStep = {
+      const pendingStep = {
         action: {
           tool: ev.toolName,
           toolInput: ev.args,
@@ -2468,14 +2535,17 @@ async function* streamNativeAgentSteps(driver, options) {
         },
         observation: ""
       };
+      pendingSteps.set(ev.toolCallId, pendingStep);
       yield pendingStep;
-    } else if (ev.type === "tool-result" && pendingStep) {
+    } else if (ev.type === "tool-result") {
+      const pendingStep = pendingSteps.get(ev.toolCallId);
+      if (!pendingStep) continue;
       const observation = typeof ev.result === "string" ? ev.result : JSON.stringify(ev.result ?? "");
       yield {
         action: pendingStep.action,
         observation
       };
-      pendingStep = null;
+      pendingSteps.delete(ev.toolCallId);
     } else if (ev.type === "error") {
       throw new Error(ev.message);
     }
@@ -2567,27 +2637,34 @@ function providerConfigFromOptions(provider, model, config) {
 }
 
 // src/version.ts
-var VERSION = "2.0.0-beta.12";
+var VERSION = "2.0.0-beta.15";
 function getPackageVersion() {
   return VERSION;
 }
 
 // src/agents/normalize_run_options.ts
-function normalizeRunOptions(queryOrOptions, maxSteps, manageConnector, _externalHistory, outputSchema, signal) {
+function normalizeRunOptions(queryOrOptions, maxSteps, manageConnector, externalHistory, outputSchema, signal) {
   if (typeof queryOrOptions === "object" && queryOrOptions !== null) {
     return {
       prompt: queryOrOptions.prompt,
       maxSteps: queryOrOptions.maxSteps,
       manageConnector: queryOrOptions.manageConnector,
+      externalHistory: queryOrOptions.externalHistory,
       messages: queryOrOptions.messages,
       schema: queryOrOptions.schema,
       signal: queryOrOptions.signal
     };
   }
+  if (externalHistory !== void 0 && !Array.isArray(externalHistory)) {
+    throw new TypeError(
+      "externalHistory must be an array of LangChain messages"
+    );
+  }
   return {
     prompt: queryOrOptions,
     maxSteps,
     manageConnector,
+    externalHistory,
     schema: outputSchema,
     signal
   };
@@ -2959,11 +3036,6 @@ var MCPAgent = class {
     }
     if (this.initialized) return;
     if (this.isSimplifiedMode) {
-      if (!this.client && this.mcpServersConfig) {
-        const { MCPClient } = await import("@mcp-use/client");
-        this.client = new MCPClient({ mcpServers: this.mcpServersConfig });
-        this.clientOwnedByAgent = true;
-      }
       if (this.llmString) {
         this.driver = createLlmDriver(
           parseLLMStringToProviderConfig(this.llmString, this.llmConfig)
@@ -2972,6 +3044,11 @@ var MCPAgent = class {
     } else if (this.explicitProviderConfig) {
       this.driver = createLlmDriver(this.explicitProviderConfig);
     }
+    if (!this.client && this.mcpServersConfig && !this.hasLiveConnections()) {
+      const { MCPClient } = await import("@mcp-use/client");
+      this.client = new MCPClient({ mcpServers: this.mcpServersConfig });
+      this.clientOwnedByAgent = true;
+    }
     if (!this.driver) {
       throw new Error("LLM driver not configured.");
     }
@@ -3078,6 +3155,11 @@ var MCPAgent = class {
     if (this.memoryEnabled && this.conversationMessages.length > 0) {
       messages.push(...this.conversationMessages);
     }
+    if (options.externalHistory?.length) {
+      messages.push(
+        ...convertExternalHistoryToProvider(options.externalHistory)
+      );
+    }
     if (options.messages?.length) {
       messages.push(...options.messages);
     }