@tonyclaw/agent-inspector 2.1.13 → 2.1.14

package/src/components/proxy-viewer/viewerState.ts

@@ -44,7 +44,29 @@ export type ToolTraceEvent = {
   argumentsPreview: string | null;
 };
 
+type ToolTraceCacheEntry = {
+  apiFormat: CapturedLog["apiFormat"];
+  responseText: string | null;
+  events: ToolTraceEvent[];
+};
+
 const PREVIEW_LIMIT = 180;
+const toolTraceCache = new WeakMap<CapturedLog, ToolTraceCacheEntry>();
+type ResolvedLogFormat = ReturnType<typeof resolveLogFormat>;
+
+function responseMayContainToolTrace(log: CapturedLog, format: ResolvedLogFormat): boolean {
+  const responseText = log.responseText;
+  if (responseText === null) return false;
+
+  switch (format) {
+    case "anthropic":
+      return responseText.includes("tool_use");
+    case "openai":
+      return responseText.includes("tool_calls") || responseText.includes("function_call");
+    case "unknown":
+      return false;
+  }
+}
 
 export function shouldRenderConversationContent(standalone: boolean, expanded: boolean): boolean {
   return standalone || expanded;
@@ -177,19 +199,66 @@ function extractOpenAIToolTraceEvents(log: CapturedLog): ToolTraceEvent[] {
       });
     }
   }
+  const output = safeGetOwnProperty(parsed, "output");
+  if (Array.isArray(output)) {
+    for (const item of output) {
+      if (safeGetOwnProperty(item, "type") !== "function_call") continue;
+      const name = safeGetOwnProperty(item, "name");
+      if (typeof name !== "string" || name.length === 0) continue;
+      const args = safeGetOwnProperty(item, "arguments");
+      events.push({
+        id: `${String(log.id)}-openai-tool-${String(events.length)}`,
+        logId: log.id,
+        index: events.length,
+        provider: "openai",
+        name,
+        argumentsText: copyValue(args),
+        argumentsPreview: previewValue(args),
+      });
+    }
+  }
   return events;
 }
 
 export function extractToolTraceEvents(log: CapturedLog): ToolTraceEvent[] {
+  const cached = toolTraceCache.get(log);
+  if (
+    cached !== undefined &&
+    cached.apiFormat === log.apiFormat &&
+    cached.responseText === log.responseText
+  ) {
+    return cached.events;
+  }
+
   const format = resolveLogFormat(log);
+  if (!responseMayContainToolTrace(log, format)) {
+    const events: ToolTraceEvent[] = [];
+    toolTraceCache.set(log, {
+      apiFormat: log.apiFormat,
+      responseText: log.responseText,
+      events,
+    });
+    return events;
+  }
+
+  let events: ToolTraceEvent[];
   switch (format) {
     case "anthropic":
-      return extractAnthropicToolTraceEvents(log);
+      events = extractAnthropicToolTraceEvents(log);
+      break;
     case "openai":
-      return extractOpenAIToolTraceEvents(log);
+      events = extractOpenAIToolTraceEvents(log);
+      break;
     case "unknown":
-      return [];
+      events = [];
+      break;
   }
+  toolTraceCache.set(log, {
+    apiFormat: log.apiFormat,
+    responseText: log.responseText,
+    events,
+  });
+  return events;
 }
 
 export function buildTraceSummary(

package/src/components/ui/json-viewer-bulk.ts

@@ -1,17 +1,52 @@
 import { useCallback, useMemo, useState, useTransition } from "react";
 
 type JsonPrimitive = string | number | boolean | null;
-export type JsonValue =
-  | JsonPrimitive
-  | ReadonlyArray<JsonValue>
-  | Readonly<{ [key: string]: JsonValue }>;
+type JsonObject = Readonly<{ [key: string]: JsonValue }>;
+export type JsonValue = JsonPrimitive | ReadonlyArray<JsonValue> | JsonObject;
 
 export type JsonExpansionPolicy = {
   depth: number;
 };
 
-export function getJsonExpansionPolicy(_value: JsonValue): JsonExpansionPolicy {
-  return { depth: Number.POSITIVE_INFINITY };
+const FULL_EXPAND_NODE_LIMIT = 400;
+const STRUCTURE_EXPAND_NODE_LIMIT = 2_000;
+
+function isJsonArray(value: JsonValue): value is ReadonlyArray<JsonValue> {
+  return Array.isArray(value);
+}
+
+function countJsonNodesUpTo(value: JsonValue, limit: number): number {
+  const stack: JsonValue[] = [value];
+  let count = 0;
+
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (current === undefined) continue;
+    count += 1;
+    if (count > limit) return count;
+
+    if (current === null || typeof current !== "object") continue;
+    if (isJsonArray(current)) {
+      for (const child of current) {
+        stack.push(child);
+      }
+      continue;
+    }
+
+    for (const key of Object.keys(current)) {
+      const child = current[key];
+      if (child !== undefined) stack.push(child);
+    }
+  }
+
+  return count;
+}
+
+export function getJsonExpansionPolicy(value: JsonValue): JsonExpansionPolicy {
+  const nodeCount = countJsonNodesUpTo(value, STRUCTURE_EXPAND_NODE_LIMIT + 1);
+  if (nodeCount <= FULL_EXPAND_NODE_LIMIT) return { depth: Number.POSITIVE_INFINITY };
+  if (nodeCount <= STRUCTURE_EXPAND_NODE_LIMIT) return { depth: 3 };
+  return { depth: 2 };
 }
 
 export type JsonBulkExpansion = {

package/src/components/ui/json-viewer.tsx

@@ -1,6 +1,5 @@
 import { Check, ChevronDown, ChevronRight, ChevronsDown, Copy } from "lucide-react";
 import { type JSX, memo, useEffect, useMemo, useState } from "react";
-import ReactMarkdown from "react-markdown";
 import { copyTextToClipboard } from "../../lib/clipboard";
 import { cn } from "../../lib/utils";
 import { Button } from "./button";
@@ -46,6 +45,10 @@ function getEntries(value: JsonValue): ReadonlyArray<readonly [string, JsonValue
 
 const STRING_TRUNCATE_LIMIT = 120;
 
+function JsonStringText({ text }: { text: string }): JSX.Element {
+  return <span className="whitespace-pre-wrap break-words">{text}</span>;
+}
+
 function StringValue({ text }: { text: string }): JSX.Element {
   const [expanded, setExpanded] = useState(false);
   const isLong = text.length > STRING_TRUNCATE_LIMIT;
@@ -54,9 +57,7 @@ function StringValue({ text }: { text: string }): JSX.Element {
     return (
       <span className="text-emerald-400 break-all">
         &quot;
-        <span className="prose prose-sm dark:prose-invert inline max-w-none [&_p]:inline [&_p]:my-0 [&_code]:text-emerald-300 [&_a]:text-emerald-300">
-          <ReactMarkdown>{text}</ReactMarkdown>
-        </span>
+        <JsonStringText text={text} />
         &quot;
       </span>
     );
@@ -67,7 +68,7 @@ function StringValue({ text }: { text: string }): JSX.Element {
       &quot;
       {expanded ? (
         <span
-          className="cursor-pointer prose prose-sm dark:prose-invert inline max-w-none [&_p]:inline [&_p]:my-0 [&_code]:text-emerald-300 [&_a]:text-emerald-300"
+          className="cursor-pointer"
           onClick={(e) => {
             e.stopPropagation();
             setExpanded(false);
@@ -81,7 +82,7 @@ function StringValue({ text }: { text: string }): JSX.Element {
           role="button"
           tabIndex={0}
         >
-          <ReactMarkdown>{text}</ReactMarkdown>
+          <JsonStringText text={text} />
         </span>
       ) : (
         <Tooltip delayDuration={300}>
@@ -93,14 +94,14 @@ function StringValue({ text }: { text: string }): JSX.Element {
             className="text-left cursor-pointer"
           >
             <span>{text.slice(0, STRING_TRUNCATE_LIMIT)}</span>
-            <span className="text-emerald-400/50">…</span>
+            <span className="text-emerald-400/50">...</span>
           </TooltipTrigger>
           <TooltipContent
             side="bottom"
             className="max-w-md text-xs p-2 break-words whitespace-pre-wrap"
           >
             {text.slice(0, 500)}
-            {text.length > 500 ? "…" : ""}
+            {text.length > 500 ? "..." : ""}
           </TooltipContent>
         </Tooltip>
       )}

package/src/contracts/index.ts

@@ -31,10 +31,24 @@ export {
   OpenAIMessage,
   OpenAIMessageContent,
   OpenAIRequestSchema,
+  OpenAIResponsesRequestSchema,
+  OpenAIResponsesResponseSchema,
+  OpenAIResponsesSSEventSchema,
+  OpenAIResponsesToolDefinition,
+  OpenAIResponsesUsageSchema,
+  OpenAIResponsesOutputItemSchema,
   OpenAIResponseSchema,
   OpenAISSERawChunkSchema,
   OpenAIToolCallSchema,
   OpenAIToolDefinition,
+  parseOpenAIResponsesResponse,
   parseOpenAIResponse,
 } from "./openai";
-export type { OpenAIResponse, OpenAIToolCall } from "./openai";
+export type {
+  OpenAIResponse,
+  OpenAIResponsesRequest,
+  OpenAIResponsesResponse,
+  OpenAIResponsesSSEvent,
+  OpenAIResponsesOutputItem,
+  OpenAIToolCall,
+} from "./openai";

package/src/contracts/openai.ts

@@ -75,6 +75,37 @@ export const OpenAIRequestSchema = z.object({
   user: z.string().optional(),
 });
 
+export const OpenAIResponsesToolDefinition = z
+  .object({
+    type: z.string(),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    parameters: JsonValueSchema.optional(),
+    function: z
+      .object({
+        name: z.string().optional(),
+        description: z.string().optional(),
+        parameters: JsonValueSchema.optional(),
+      })
+      .optional(),
+  })
+  .passthrough();
+
+export const OpenAIResponsesRequestSchema = z
+  .object({
+    model: z.string(),
+    input: z.unknown().optional(),
+    instructions: z.union([z.string(), z.null()]).optional(),
+    stream: z.boolean().optional(),
+    tools: z.array(OpenAIResponsesToolDefinition).optional(),
+    tool_choice: z.unknown().optional(),
+    max_output_tokens: z.number().optional(),
+    temperature: z.number().optional(),
+    user: z.string().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+  })
+  .passthrough();
+
 export const OpenAIChoiceDelta = z.object({
   role: z.enum(["assistant"]).optional(),
   content: z.string().nullable().optional(),
@@ -162,7 +193,59 @@ export const OpenAISSERawChunkSchema = z
   })
   .passthrough();
 
+export const OpenAIResponsesUsageSchema = z
+  .object({
+    input_tokens: z.number().nullable().optional(),
+    output_tokens: z.number().nullable().optional(),
+    total_tokens: z.number().nullable().optional(),
+    input_tokens_details: z
+      .object({
+        cached_tokens: z.number().nullable().optional(),
+      })
+      .passthrough()
+      .nullable()
+      .optional(),
+    output_tokens_details: z
+      .object({
+        reasoning_tokens: z.number().nullable().optional(),
+      })
+      .passthrough()
+      .nullable()
+      .optional(),
+  })
+  .passthrough();
+
+export const OpenAIResponsesOutputItemSchema = z
+  .object({
+    type: z.string(),
+  })
+  .passthrough();
+
+export const OpenAIResponsesResponseSchema = z
+  .object({
+    id: z.string(),
+    object: z.literal("response").optional(),
+    created_at: z.number().optional(),
+    status: z.string().nullable().optional(),
+    model: z.string().optional(),
+    output: z.array(OpenAIResponsesOutputItemSchema).optional(),
+    output_text: z.string().optional(),
+    usage: OpenAIResponsesUsageSchema.nullable().optional(),
+    error: z.unknown().optional(),
+  })
+  .passthrough();
+
+export const OpenAIResponsesSSEventSchema = z
+  .object({
+    type: z.string(),
+  })
+  .passthrough();
+
 export type OpenAIResponse = z.infer<typeof OpenAIResponseSchema>;
+export type OpenAIResponsesRequest = z.infer<typeof OpenAIResponsesRequestSchema>;
+export type OpenAIResponsesResponse = z.infer<typeof OpenAIResponsesResponseSchema>;
+export type OpenAIResponsesSSEvent = z.infer<typeof OpenAIResponsesSSEventSchema>;
+export type OpenAIResponsesOutputItem = z.infer<typeof OpenAIResponsesOutputItemSchema>;
 
 export function parseOpenAIResponse(rawBody: string): OpenAIResponse | null {
   try {
@@ -174,3 +257,14 @@ export function parseOpenAIResponse(rawBody: string): OpenAIResponse | null {
     return null;
   }
 }
+
+export function parseOpenAIResponsesResponse(rawBody: string): OpenAIResponsesResponse | null {
+  try {
+    const json: unknown = JSON.parse(rawBody);
+    const result = OpenAIResponsesResponseSchema.safeParse(json);
+    if (result.success) return result.data;
+    return null;
+  } catch {
+    return null;
+  }
+}

package/src/lib/providerContract.ts

@@ -25,6 +25,7 @@ export const ProviderConfigSchema = z.object({
   baseUrl: z.string().optional(),
   anthropicBaseUrl: z.string().optional(),
   openaiBaseUrl: z.string().optional(),
+  openaiResponsesBaseUrl: z.string().optional(),
   authHeader: z.enum(["bearer", "x-api-key"]).optional().default("bearer"),
   apiDocsUrl: z.string().optional(),
   modelMetadataUrl: z.string().optional(),

package/src/lib/providerModelMetadata.ts

@@ -81,7 +81,7 @@ export const BUILTIN_PROVIDER_MODEL_REGISTRY: ProviderModelRegistry = {
     {
       name: "MiniMax",
       aliases: ["minimax"],
-      baseUrls: ["https://api.minimaxi.com/anthropic"],
+      baseUrls: ["https://api.minimaxi.com/anthropic", "https://api.minimaxi.com"],
       models: [
         {
           id: "MiniMax M3",
@@ -245,6 +245,12 @@ function providerBaseUrls(provider: ProviderConfig): string[] {
   if (provider.openaiBaseUrl !== undefined && provider.openaiBaseUrl.trim() !== "") {
     urls.push(provider.openaiBaseUrl);
   }
+  if (
+    provider.openaiResponsesBaseUrl !== undefined &&
+    provider.openaiResponsesBaseUrl.trim() !== ""
+  ) {
+    urls.push(provider.openaiResponsesBaseUrl);
+  }
   if (provider.baseUrl !== undefined && provider.baseUrl.trim() !== "") {
     urls.push(provider.baseUrl);
   }

package/src/lib/stopReason.ts

@@ -43,6 +43,18 @@ export function extractStopReason(log: CapturedLog): StopReason {
       return "stop";
     }
 
+    // OpenAI Responses shape: { status: "completed", output: [...] }
+    if (Array.isArray(json.output)) {
+      for (const item of json.output) {
+        if (isRecord(item) && item.type === "function_call") {
+          return "tool_use";
+        }
+      }
+      if (json.status === "completed") {
+        return "stop";
+      }
+    }
+
     return null;
   } catch {
     return null;

package/src/lib/upstreamUrl.ts

@@ -0,0 +1,46 @@
+export const PATH_V1_CHAT_COMPLETIONS = "/v1/chat/completions";
+export const PATH_V1_RESPONSES = "/v1/responses";
+
+export function buildUpstreamUrl(upstreamBase: string, normalizedPath: string): string {
+  const base = upstreamBase.endsWith("/") ? upstreamBase.slice(0, -1) : upstreamBase;
+  const endpointPath = normalizedPath.split("?")[0] ?? normalizedPath;
+  const queryIndex = normalizedPath.indexOf("?");
+  const search = queryIndex >= 0 ? normalizedPath.slice(queryIndex) : "";
+
+  // Some providers expose a format-specific URL as the exact endpoint rather
+  // than a base URL. Keep existing configs with exact endpoints compatible.
+  if (endpointPath !== "" && base.endsWith(endpointPath)) {
+    return base + search;
+  }
+
+  if (isZhipuVersionedOpenAIBase(base) && isVersionedChatCompletionsPath(normalizedPath)) {
+    return base + normalizedPath.slice(3);
+  }
+
+  // Many OpenAI-compatible base URLs already include /v1. Avoid producing /v1/v1.
+  if (base.endsWith("/v1") && normalizedPath.startsWith("/v1/")) {
+    return base + normalizedPath.slice(3);
+  }
+  return base + normalizedPath;
+}
+
+function isVersionedChatCompletionsPath(normalizedPath: string): boolean {
+  return (
+    normalizedPath === PATH_V1_CHAT_COMPLETIONS ||
+    normalizedPath.startsWith(`${PATH_V1_CHAT_COMPLETIONS}?`) ||
+    normalizedPath.startsWith(`${PATH_V1_CHAT_COMPLETIONS}/`)
+  );
+}
+
+function isZhipuVersionedOpenAIBase(base: string): boolean {
+  try {
+    const parsed = new URL(base);
+    const path = parsed.pathname.replace(/\/+$/, "");
+    return (
+      parsed.hostname === "open.bigmodel.cn" &&
+      (path === "/api/paas/v4" || path === "/api/coding/paas/v4")
+    );
+  } catch {
+    return false;
+  }
+}

package/src/mcp/previewExtractor.ts

@@ -19,12 +19,20 @@
  *   - the relevant content is non-text (e.g., image-only multimodal block)
  */
 
+import { z } from "zod";
 import type { CapturedLog } from "../contracts";
 import { AnthropicRequestSchema, AnthropicResponseSchema } from "../contracts/anthropic";
-import { OpenAIRequestSchema, OpenAIResponseSchema } from "../contracts/openai";
+import {
+  OpenAIRequestSchema,
+  OpenAIResponseSchema,
+  OpenAIResponsesRequestSchema,
+  OpenAIResponsesResponseSchema,
+} from "../contracts/openai";
+import { safeGetOwnProperty } from "../lib/objectUtils";
 
 /** Preview length cap, per design D5. */
 const PREVIEW_MAX_CHARS = 500;
+const UnknownArraySchema = z.array(z.unknown());
 
 function truncate(text: string): string {
   return text.length <= PREVIEW_MAX_CHARS ? text : text.slice(0, PREVIEW_MAX_CHARS);
@@ -68,6 +76,58 @@ function firstOpenAIText(
   return null;
 }
 
+function firstResponsesInputText(input: unknown): string | null {
+  if (typeof input === "string") return input.length > 0 ? input : null;
+  const parsedInput = UnknownArraySchema.safeParse(input);
+  if (!parsedInput.success) return null;
+  for (let i = parsedInput.data.length - 1; i >= 0; i--) {
+    const item = parsedInput.data[i];
+    const role = safeGetOwnProperty(item, "role");
+    if (role !== "user" && role !== undefined) continue;
+    const directText = safeGetOwnProperty(item, "text");
+    if (typeof directText === "string" && directText.length > 0) return directText;
+    const content = safeGetOwnProperty(item, "content");
+    if (typeof content === "string" && content.length > 0) return content;
+    if (Array.isArray(content)) {
+      for (const part of content) {
+        const type = safeGetOwnProperty(part, "type");
+        const text = safeGetOwnProperty(part, "text");
+        if (
+          (type === "input_text" || type === "text") &&
+          typeof text === "string" &&
+          text.length > 0
+        ) {
+          return text;
+        }
+      }
+    }
+  }
+  return null;
+}
+
+function firstResponsesOutputText(response: unknown): string | null {
+  const outputText = safeGetOwnProperty(response, "output_text");
+  if (typeof outputText === "string" && outputText.length > 0) return outputText;
+  const output = safeGetOwnProperty(response, "output");
+  if (!Array.isArray(output)) return null;
+  for (const item of output) {
+    const content = safeGetOwnProperty(item, "content");
+    if (!Array.isArray(content)) continue;
+    for (const part of content) {
+      const type = safeGetOwnProperty(part, "type");
+      const text = safeGetOwnProperty(part, "text");
+      if (
+        (type === "output_text" || type === "text") &&
+        typeof text === "string" &&
+        text.length > 0
+      ) {
+        return text;
+      }
+    }
+  }
+  return null;
+}
+
 /**
  * Extract a 500-char preview of the last `role: "user"` message's first text
  * block. Returns `null` for unknown format, parse failures, or non-text
@@ -100,7 +160,12 @@ export function extractLastUserMessagePreview(log: CapturedLog): string | null {
 
   if (log.apiFormat === "openai") {
     const parsed = OpenAIRequestSchema.safeParse(json);
-    if (!parsed.success) return null;
+    if (!parsed.success) {
+      const responsesParsed = OpenAIResponsesRequestSchema.safeParse(json);
+      if (!responsesParsed.success) return null;
+      const text = firstResponsesInputText(responsesParsed.data.input);
+      return text === null ? null : truncate(text);
+    }
     for (let i = parsed.data.messages.length - 1; i >= 0; i--) {
       const msg = parsed.data.messages[i];
       if (msg && msg.role === "user") {
@@ -143,7 +208,12 @@ export function extractResponsePreview(log: CapturedLog): string | null {
 
   if (log.apiFormat === "openai") {
     const parsed = OpenAIResponseSchema.safeParse(json);
-    if (!parsed.success) return null;
+    if (!parsed.success) {
+      const responsesParsed = OpenAIResponsesResponseSchema.safeParse(json);
+      if (!responsesParsed.success) return null;
+      const text = firstResponsesOutputText(responsesParsed.data);
+      return text === null ? null : truncate(text);
+    }
     // Pick the first choice that actually carries a text-like content.
     for (const choice of parsed.data.choices) {
       const msg = choice.message;

package/src/mcp/server.ts

@@ -1057,6 +1057,7 @@ function registerTools(server: McpServer): void {
         model: z.string().min(1),
         anthropicBaseUrl: z.string().optional(),
         openaiBaseUrl: z.string().optional(),
+        openaiResponsesBaseUrl: z.string().optional(),
         authHeader: z.enum(["bearer", "x-api-key"]).optional(),
         apiDocsUrl: z.string().optional(),
       }),
@@ -1081,6 +1082,7 @@ PATCH-style update: only the fields you supply are changed. Returns the updated
         authHeader: z.enum(["bearer", "x-api-key"]).optional(),
         anthropicBaseUrl: z.string().optional(),
         openaiBaseUrl: z.string().optional(),
+        openaiResponsesBaseUrl: z.string().optional(),
         apiDocsUrl: z.string().optional(),
       }),
     },

package/src/mcp/toolHandlers.ts

@@ -719,6 +719,7 @@ export type AddProviderInput = {
   model: string;
   anthropicBaseUrl?: string;
   openaiBaseUrl?: string;
+  openaiResponsesBaseUrl?: string;
   authHeader?: "bearer" | "x-api-key";
   apiDocsUrl?: string;
 };
@@ -746,6 +747,7 @@ export type UpdateProviderInput = {
   authHeader?: "bearer" | "x-api-key";
   anthropicBaseUrl?: string;
   openaiBaseUrl?: string;
+  openaiResponsesBaseUrl?: string;
   apiDocsUrl?: string;
 };
 

package/src/proxy/constants.ts

@@ -9,6 +9,8 @@ export const PROXY_IDENTITY = process.env["PROXY_IDENTITY"] ?? "inspector9527@To
 // API paths
 export const PATH_V1_CHAT_COMPLETIONS = "/v1/chat/completions";
 export const PATH_CHAT_COMPLETIONS = "/chat/completions";
+export const PATH_V1_RESPONSES = "/v1/responses";
+export const PATH_RESPONSES = "/responses";
 export const PATH_V1_MESSAGES = "/v1/messages";
 
 // Header names