@mcp-use/inspector 7.0.0-canary.9 → 7.0.0

package/dist/cli.js

@@ -14,6 +14,142 @@ import open from "open";
 import { telFetch } from "mcp-use/telemetry/tel-fetch";
 import { mountMcpProxy, mountOAuthProxy } from "mcp-use/server";
 
+// src/llm/toolResultParts.ts
+function makeText(text) {
+  return { type: "text", text };
+}
+function makeImage(data, mimeType) {
+  return {
+    type: "image",
+    url: `data:${mimeType};base64,${data}`,
+    mimeType,
+    data
+  };
+}
+function isMcpResultShape(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (Array.isArray(v.content)) return true;
+  return "structuredContent" in v;
+}
+function isToolResultError(result) {
+  return typeof result === "object" && result !== null && result.isError === true;
+}
+function blockToPart(block) {
+  if (!block || typeof block !== "object") return null;
+  switch (block.type) {
+    case "text": {
+      const text = block.text;
+      return typeof text === "string" && text.length > 0 ? makeText(text) : null;
+    }
+    case "image": {
+      const b = block;
+      if (typeof b.data !== "string" || !b.data) return null;
+      const mime = typeof b.mimeType === "string" && b.mimeType ? b.mimeType : "image/png";
+      return makeImage(b.data, mime);
+    }
+    case "audio": {
+      const b = block;
+      const mime = typeof b.mimeType === "string" && b.mimeType ? b.mimeType : "audio/*";
+      const bytes = typeof b.data === "string" ? b.data.length : 0;
+      return makeText(`[audio: ${mime}, base64 omitted (${bytes} chars)]`);
+    }
+    case "resource": {
+      const r = block.resource ?? {};
+      if (typeof r.text === "string" && r.text.length > 0) {
+        return makeText(r.text);
+      }
+      if (typeof r.blob === "string" && typeof r.mimeType === "string" && r.mimeType.startsWith("image/")) {
+        return makeImage(r.blob, r.mimeType);
+      }
+      const uri = typeof r.uri === "string" ? r.uri : "<unknown>";
+      const mime = typeof r.mimeType === "string" ? r.mimeType : "unknown";
+      return makeText(`[resource: ${uri} (${mime})]`);
+    }
+    case "resource_link": {
+      const b = block;
+      const uri = typeof b.uri === "string" ? b.uri : "<unknown>";
+      const name = typeof b.name === "string" ? ` "${b.name}"` : "";
+      return makeText(`[resource_link${name}: ${uri}]`);
+    }
+    default: {
+      return makeText(
+        `[unsupported tool content block: ${String(block.type)}]`
+      );
+    }
+  }
+}
+function stripMeta(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const { _meta: _ignored, ...rest } = value;
+    return rest;
+  }
+  return value;
+}
+function extractToolResultParts(result) {
+  const stripped = stripMeta(result);
+  if (typeof stripped === "string") {
+    return stripped.length > 0 ? [makeText(stripped)] : [];
+  }
+  if (isMcpResultShape(stripped)) {
+    const r = stripped;
+    const parts = [];
+    if (Array.isArray(r.content)) {
+      for (const block of r.content) {
+        const p = blockToPart(block);
+        if (p) parts.push(p);
+      }
+    }
+    if (r.structuredContent !== void 0) {
+      try {
+        parts.push(
+          makeText(`structuredContent: ${JSON.stringify(r.structuredContent)}`)
+        );
+      } catch {
+      }
+    }
+    if (r.isError) {
+      parts.unshift(makeText("[tool reported isError=true]"));
+    }
+    return parts;
+  }
+  try {
+    return [makeText(JSON.stringify(stripped))];
+  } catch {
+    return [makeText(String(stripped))];
+  }
+}
+function collapseToString(parts) {
+  if (parts.length === 0) return "";
+  if (parts.every((p) => p.type === "text")) {
+    return parts.map((p) => p.text).join("\n");
+  }
+  return null;
+}
+function toolResultToContent(result) {
+  const parts = extractToolResultParts(result);
+  const collapsed = collapseToString(parts);
+  return collapsed !== null ? collapsed : parts;
+}
+function partitionToolContent(content) {
+  if (typeof content === "string") {
+    return { text: content, imageParts: [], isString: true };
+  }
+  const texts = [];
+  const imageParts = [];
+  for (const p of content) {
+    if (p.type === "text") {
+      if (p.text) texts.push(p.text);
+    } else if (p.type === "image") {
+      imageParts.push(p);
+    }
+  }
+  return { text: texts.join("\n"), imageParts, isString: false };
+}
+function toolImageFollowupHeader(toolName, count) {
+  return `(Tool "${toolName ?? "<tool>"}" returned the following image${count === 1 ? "" : "s"}:)`;
+}
+
 // src/llm/messageFormat.ts
 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 ?? "");
@@ -23,13 +159,6 @@ function extractText(m) {
   }
   return "";
 }
-function serializeToolResult(result) {
-  if (result && typeof result === "object") {
-    const { _meta: _ignored, ...rest } = result;
-    return JSON.stringify(rest);
-  }
-  return typeof result === "string" ? result : JSON.stringify(result);
-}
 function convertMessagesToProvider(messages) {
   const out = [];
   messages.forEach((m, mi) => {
@@ -73,12 +202,14 @@ function convertMessagesToProvider(messages) {
       toolCalls
     });
     toolParts.forEach((p, i) => {
+      const result = p.toolInvocation.result;
       out.push({
         role: "tool",
-        content: serializeToolResult(p.toolInvocation.result),
+        content: toolResultToContent(result),
         toolCallId: `call_${mi}_${i}_${p.toolInvocation.toolName}`,
         toolName: p.toolInvocation.toolName,
-        toolResult: p.toolInvocation.result
+        toolResult: result,
+        toolIsError: isToolResultError(result)
       });
     });
   });
@@ -202,6 +333,24 @@ function toAnthropicContent(content) {
   if (blocks.length === 0) blocks.push({ type: "text", text: "[no content]" });
   return blocks;
 }
+function toAnthropicToolResultContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  const blocks = [];
+  for (const p of content) {
+    if (p.type === "text") {
+      if (p.text) blocks.push({ type: "text", text: p.text });
+    } else if (p.type === "image") {
+      const img = buildImageBlock(p);
+      if (img) blocks.push(img);
+    }
+  }
+  if (blocks.length === 0) {
+    return "[no content]";
+  }
+  return blocks;
+}
 function toAnthropicMessages(messages) {
   const out = [];
   for (const m of messages) {
@@ -210,7 +359,7 @@ function toAnthropicMessages(messages) {
       const block = {
         type: "tool_result",
         tool_use_id: m.toolCallId,
-        content: typeof m.content === "string" ? m.content : JSON.stringify(m.toolResult ?? m.content),
+        content: toAnthropicToolResultContent(m.content),
         ...m.toolIsError ? { is_error: true } : {}
       };
       if (last && last.role === "user" && Array.isArray(last.content)) {
@@ -499,21 +648,39 @@ function toGeminiParts(content) {
   if (parts.length === 0) parts.push({ text: "[no content]" });
   return parts;
 }
+function buildGeminiToolResponse(content) {
+  if (typeof content === "string") {
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch {
+      parsed = { result: content };
+    }
+    if (!parsed || typeof parsed !== "object") {
+      parsed = { result: parsed };
+    }
+    return { response: parsed, imageParts: [] };
+  }
+  const { text, imageParts } = partitionToolContent(content);
+  const response = {};
+  if (text) response.text = text;
+  if (imageParts.length > 0) {
+    response.images = imageParts.map((p) => ({
+      mimeType: p.mimeType ?? "image/*",
+      omitted: true
+    }));
+    response.note = "Image bytes were sent in the next user turn as inlineData.";
+  }
+  if (Object.keys(response).length === 0) {
+    response.result = null;
+  }
+  return { response, imageParts };
+}
 function toGeminiContents(messages) {
   const out = [];
   for (const m of messages) {
     if (m.role === "tool") {
-      let response;
-      try {
-        response = typeof m.content === "string" ? JSON.parse(m.content) : m.toolResult;
-      } catch {
-        response = {
-          result: typeof m.content === "string" ? m.content : m.toolResult
-        };
-      }
-      if (!response || typeof response !== "object") {
-        response = { result: response };
-      }
+      const { response, imageParts } = buildGeminiToolResponse(m.content);
       const last = out[out.length - 1];
       const part = {
         functionResponse: {
@@ -526,6 +693,16 @@ function toGeminiContents(messages) {
       } else {
         out.push({ role: "function", parts: [part] });
       }
+      if (imageParts.length > 0) {
+        const userParts = [
+          { text: toolImageFollowupHeader(m.toolName, imageParts.length) }
+        ];
+        for (const p of imageParts) {
+          const block = buildInlineData(p);
+          if (block) userParts.push(block);
+        }
+        out.push({ role: "user", parts: userParts });
+      }
       continue;
     }
     if (m.role === "assistant") {
@@ -671,12 +848,252 @@ async function chat2(params) {
   return { text, toolCalls };
 }
 
+// src/llm/ndjson.ts
+async function* parseNDJSON(body, signal) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      if (signal?.aborted) return;
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        try {
+          yield JSON.parse(trimmed);
+        } catch {
+        }
+      }
+    }
+    const trailing = buffer.trim();
+    if (trailing) {
+      try {
+        yield JSON.parse(trailing);
+      } catch {
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+// src/llm/providers/ollama/utils.ts
+var DEFAULT_OLLAMA_BASE_URL = "http://localhost:11434";
+function normalizeOllamaBaseUrl(baseUrl) {
+  const raw = (baseUrl || DEFAULT_OLLAMA_BASE_URL).trim();
+  let end = raw.length;
+  while (end > 0 && raw.charCodeAt(end - 1) === 47) {
+    end--;
+  }
+  const trimmed = raw.slice(0, end);
+  return trimmed.endsWith("/api") ? trimmed.slice(0, -4) : trimmed;
+}
+function buildOllamaApiUrl(baseUrl, path) {
+  return `${normalizeOllamaBaseUrl(baseUrl)}${path}`;
+}
+
+// src/llm/providers/ollama/index.ts
+function toOllamaImages(content) {
+  const images = [];
+  for (const part of content) {
+    if (part.type !== "image") continue;
+    if (part.data) {
+      images.push(part.data);
+      continue;
+    }
+    const parsed = parseDataUrl(part.url);
+    if (parsed?.data) {
+      images.push(parsed.data);
+    }
+  }
+  return images;
+}
+function toOllamaContent(content) {
+  if (typeof content === "string") {
+    return { content };
+  }
+  const text = content.filter(
+    (part) => part.type === "text"
+  ).map((part) => part.text).join("");
+  const images = toOllamaImages(content);
+  return {
+    content: text,
+    ...images.length > 0 ? { images } : {}
+  };
+}
+function toOllamaMessages(messages) {
+  return messages.map((message) => {
+    if (message.role === "tool") {
+      return {
+        role: "tool",
+        tool_name: message.toolName,
+        content: typeof message.content === "string" ? message.content : JSON.stringify(message.toolResult ?? message.content)
+      };
+    }
+    if (message.role === "assistant") {
+      const content = typeof message.content === "string" ? { content: message.content } : toOllamaContent(message.content);
+      return {
+        role: "assistant",
+        ...content,
+        ...message.toolCalls?.length ? {
+          tool_calls: message.toolCalls.map((toolCall, index) => ({
+            type: "function",
+            function: {
+              index,
+              name: toolCall.name,
+              arguments: toolCall.args
+            }
+          }))
+        } : {}
+      };
+    }
+    return {
+      role: message.role,
+      ...toOllamaContent(message.content)
+    };
+  });
+}
+function buildBody3(params, stream) {
+  const { config, messages, tools } = params;
+  const body = {
+    model: config.model,
+    messages: toOllamaMessages(messages),
+    stream
+  };
+  const options = {};
+  if (config.temperature !== void 0)
+    options.temperature = config.temperature;
+  if (config.maxTokens !== void 0) options.num_predict = config.maxTokens;
+  if (Object.keys(options).length > 0) body.options = options;
+  if (tools && tools.length > 0) {
+    body.tools = tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.inputSchema
+      }
+    }));
+  }
+  return body;
+}
+function buildHeaders(config) {
+  return {
+    "Content-Type": "application/json",
+    ...config.apiKey.trim() ? { Authorization: `Bearer ${config.apiKey.trim()}` } : {}
+  };
+}
+function normalizeToolCalls(toolCalls) {
+  if (!Array.isArray(toolCalls)) return [];
+  return toolCalls.map((toolCall) => {
+    const functionCall = toolCall && typeof toolCall === "object" ? toolCall.function : void 0;
+    const name = typeof functionCall?.name === "string" ? functionCall.name : "";
+    const rawArgs = functionCall?.arguments;
+    const args2 = rawArgs && typeof rawArgs === "object" ? rawArgs : {};
+    return {
+      name,
+      args: args2
+    };
+  }).filter((toolCall) => toolCall.name);
+}
+async function* streamChat3(params) {
+  const { config, signal } = params;
+  const res = await fetch(buildOllamaApiUrl(config.baseUrl, "/api/chat"), {
+    method: "POST",
+    headers: buildHeaders(config),
+    body: JSON.stringify(buildBody3(params, true)),
+    signal
+  });
+  if (!res.ok || !res.body) {
+    const text = await res.text().catch(() => "");
+    throw new Error(
+      `Ollama request failed (${res.status} ${res.statusText}): ${text}`
+    );
+  }
+  let toolCallsEmitted = false;
+  for await (const chunk of parseNDJSON(res.body, signal)) {
+    const message = chunk && typeof chunk === "object" ? chunk.message : void 0;
+    if (typeof message?.content === "string" && message.content.length > 0) {
+      yield { type: "text-delta", delta: message.content };
+    }
+    if (!toolCallsEmitted) {
+      const toolCalls = normalizeToolCalls(message?.tool_calls);
+      if (toolCalls.length > 0) {
+        for (const [index, toolCall] of toolCalls.entries()) {
+          const toolCallId = `call_${index}_${toolCall.name || "tool"}`;
+          yield {
+            type: "tool-call-start",
+            index,
+            toolCallId,
+            toolName: toolCall.name
+          };
+          const argsJson = JSON.stringify(toolCall.args);
+          if (argsJson && argsJson !== "{}") {
+            yield {
+              type: "tool-call-args-delta",
+              index,
+              toolCallId,
+              toolName: toolCall.name,
+              argsDelta: argsJson
+            };
+          }
+          yield {
+            type: "tool-call-ready",
+            index,
+            toolCallId,
+            toolName: toolCall.name,
+            args: toolCall.args
+          };
+        }
+        toolCallsEmitted = true;
+      }
+    }
+    if (chunk && typeof chunk === "object" && chunk.error) {
+      yield {
+        type: "error",
+        message: String(chunk.error)
+      };
+    }
+  }
+  yield { type: "done" };
+}
+async function chat3(params) {
+  const { config, signal } = params;
+  const res = await fetch(buildOllamaApiUrl(config.baseUrl, "/api/chat"), {
+    method: "POST",
+    headers: buildHeaders(config),
+    body: JSON.stringify(buildBody3(params, false)),
+    signal
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(
+      `Ollama request failed (${res.status} ${res.statusText}): ${text}`
+    );
+  }
+  const json = await res.json();
+  const message = json?.message ?? {};
+  return {
+    text: typeof message.content === "string" ? message.content : "",
+    toolCalls: normalizeToolCalls(message.tool_calls).map((tc, index) => ({
+      id: `call_${index}_${tc.name || "tool"}`,
+      name: tc.name,
+      args: tc.args
+    }))
+  };
+}
+
 // src/llm/providers/openai.ts
 var OPENAI_BASE_URL = "https://api.openai.com/v1";
 function buildEndpoint(config, path) {
   return `${config.baseUrl ?? OPENAI_BASE_URL}${path}`;
 }
-function buildHeaders(config) {
+function buildHeaders2(config) {
   const headers = {
     "Content-Type": "application/json",
     ...config.extraHeaders
@@ -697,11 +1114,26 @@ function toOpenAIMessages(messages) {
   const out = [];
   for (const m of messages) {
     if (m.role === "tool") {
+      const { text, imageParts } = partitionToolContent(m.content);
+      const fallback = imageParts.length > 0 ? "[image content; see next message]" : "[no content]";
       out.push({
         role: "tool",
         tool_call_id: m.toolCallId,
-        content: typeof m.content === "string" ? m.content : JSON.stringify(m.toolResult ?? m.content)
+        content: text || fallback
       });
+      if (imageParts.length > 0) {
+        const userParts = [
+          {
+            type: "text",
+            text: toolImageFollowupHeader(m.toolName, imageParts.length)
+          },
+          ...imageParts.map((p) => ({
+            type: "image_url",
+            image_url: { url: p.url }
+          }))
+        ];
+        out.push({ role: "user", content: userParts });
+      }
       continue;
     }
     if (m.role === "assistant") {
@@ -721,10 +1153,9 @@ function toOpenAIMessages(messages) {
     }
     out.push({ role: m.role, content: toOpenAIContent(m.content) });
   }
-  void parseDataUrl;
   return out;
 }
-async function* streamChat3(params) {
+async function* streamChat4(params) {
   const { config, messages, tools, signal } = params;
   const body = {
     model: config.model,
@@ -746,7 +1177,7 @@ async function* streamChat3(params) {
   const endpoint = buildEndpoint(config, "/chat/completions");
   const res = await fetch(endpoint, {
     method: "POST",
-    headers: buildHeaders(config),
+    headers: buildHeaders2(config),
     body: JSON.stringify(body),
     signal
   });
@@ -834,7 +1265,7 @@ async function* streamChat3(params) {
   }
   yield { type: "done" };
 }
-async function chat3(params) {
+async function chat4(params) {
   const { config, messages, tools, signal } = params;
   const body = {
     model: config.model,
@@ -855,7 +1286,7 @@ async function chat3(params) {
   const endpoint = buildEndpoint(config, "/chat/completions");
   const res = await fetch(endpoint, {
     method: "POST",
-    headers: buildHeaders(config),
+    headers: buildHeaders2(config),
     body: JSON.stringify(body),
     signal
   });
@@ -898,32 +1329,36 @@ function withOpenRouter(params) {
     }
   };
 }
-function streamChat4(params) {
+function streamChat5(params) {
   switch (params.config.provider) {
     case "openai":
     case "openai-compatible":
-      return streamChat3(params);
+      return streamChat4(params);
     case "anthropic":
       return streamChat(params);
     case "google":
       return streamChat2(params);
     case "openrouter":
-      return streamChat3(withOpenRouter(params));
+      return streamChat4(withOpenRouter(params));
+    case "ollama":
+      return streamChat3(params);
     default:
       throw new Error(`Unsupported LLM provider: ${params.config.provider}`);
   }
 }
-function chat4(params) {
+function chat5(params) {
   switch (params.config.provider) {
     case "openai":
     case "openai-compatible":
-      return chat3(params);
+      return chat4(params);
     case "anthropic":
       return chat(params);
     case "google":
       return chat2(params);
     case "openrouter":
-      return chat3(withOpenRouter(params));
+      return chat4(withOpenRouter(params));
+    case "ollama":
+      return chat3(params);
     default:
       throw new Error(`Unsupported LLM provider: ${params.config.provider}`);
   }
@@ -939,7 +1374,7 @@ async function* runToolLoop(params) {
     const pendingToolCalls = [];
     let assistantText = "";
     try {
-      for await (const ev of streamChat4({
+      for await (const ev of streamChat5({
         config,
         messages,
         tools,
@@ -977,17 +1412,17 @@ async function* runToolLoop(params) {
       let isError = false;
       try {
         result = await callTool(tc.name, tc.args);
+        isError = isToolResultError(result);
       } catch (err) {
         isError = true;
         result = {
+          isError: true,
           error: err instanceof Error ? err.message : String(err)
         };
       }
-      const normalized = stripMeta(result);
-      const payloadText = typeof normalized === "string" ? normalized : JSON.stringify(normalized);
       messages.push({
         role: "tool",
-        content: payloadText,
+        content: toolResultToContent(result),
         toolCallId: tc.id,
         toolName: tc.name,
         toolResult: result,
@@ -1003,13 +1438,6 @@ async function* runToolLoop(params) {
     }
   }
 }
-function stripMeta(value) {
-  if (value && typeof value === "object" && !Array.isArray(value)) {
-    const { _meta: _ignored, ...rest } = value;
-    return rest;
-  }
-  return value;
-}
 async function runToolLoopNonStreaming(params) {
   const { config, tools, callTool, signal } = params;
   const maxSteps = params.maxSteps ?? 10;
@@ -1018,7 +1446,7 @@ async function runToolLoopNonStreaming(params) {
   let finalText = "";
   for (let step = 0; step < maxSteps; step++) {
     if (signal?.aborted) break;
-    const { text, toolCalls } = await chat4({ config, messages, tools, signal });
+    const { text, toolCalls } = await chat5({ config, messages, tools, signal });
     if (toolCalls.length === 0) {
       finalText = text;
       break;
@@ -1033,9 +1461,11 @@ async function runToolLoopNonStreaming(params) {
       let isError = false;
       try {
         result = await callTool(tc.name, tc.args);
+        isError = isToolResultError(result);
       } catch (err) {
         isError = true;
         result = {
+          isError: true,
           error: err instanceof Error ? err.message : String(err)
         };
       }
@@ -1044,10 +1474,9 @@ async function runToolLoopNonStreaming(params) {
         args: tc.args,
         result
       });
-      const payloadText = typeof result === "string" ? result : JSON.stringify(stripMeta(result));
       messages.push({
         role: "tool",
-        content: payloadText,
+        content: toolResultToContent(result),
         toolCallId: tc.id,
         toolName: tc.name,
         toolResult: result,