@tonyclaw/agent-inspector 2.0.38 → 2.0.40

package/src/components/providers/SettingsDialog.tsx

@@ -293,6 +293,18 @@ function OnboardingSettingsTab(): JSX.Element {
         label: "Codex prompt",
         value: "Use the agent-inspector-onboard skill",
       },
+      {
+        id: "opencode-config",
+        label: "OpenCode config",
+        value: "agent-inspector onboard --opencode-only",
+      },
+      {
+        id: "opencode-status",
+        label: "OpenCode status",
+        value: "agent-inspector onboard --status --opencode-only",
+      },
+      { id: "opencode-verify", label: "OpenCode verify", value: "opencode mcp list" },
+      { id: "opencode-proxy", label: "OpenCode proxy", value: `LLM_BASE_URL=${origin}/proxy` },
       { id: "mcp", label: "MCP URL", value: `${origin}/api/mcp` },
       { id: "proxy", label: "Proxy URL", value: `${origin}/proxy` },
       { id: "anthropic", label: "Anthropic base", value: `ANTHROPIC_BASE_URL=${origin}/proxy` },
@@ -345,6 +357,24 @@ function OnboardingSettingsTab(): JSX.Element {
             instead. Configure only one entry for the same Inspector.
           </span>
         </div>
+        <div className="flex items-start gap-2">
+          <Check className="mt-0.5 size-3.5 text-emerald-500" />
+          <span>
+            OpenCode onboarding safely merges{" "}
+            <code className="rounded bg-muted px-1 py-0.5 font-mono text-[11px] text-foreground">
+              mcp.agent-inspector
+            </code>{" "}
+            into{" "}
+            <code className="rounded bg-muted px-1 py-0.5 font-mono text-[11px] text-foreground">
+              opencode.json
+            </code>
+            , then verify with{" "}
+            <code className="rounded bg-muted px-1 py-0.5 font-mono text-[11px] text-foreground">
+              opencode mcp list
+            </code>
+            .
+          </span>
+        </div>
         <div className="flex items-start gap-2">
           <Check className="mt-0.5 size-3.5 text-emerald-500" />
           <span>

package/src/components/proxy-viewer/LogEntry.tsx

@@ -1,4 +1,4 @@
-import { GitCompareArrows } from "lucide-react";
+import { AlertTriangle, GitCompareArrows } from "lucide-react";
 import { Suspense, type JSX } from "react";
 import { useEffect, useMemo, useRef, useState, memo } from "react";
 import type { CapturedLog } from "../../contracts";
@@ -295,6 +295,7 @@ export const LogEntry = memo(function ({
     () => parseRequestTools(requestExpansion.parsedData),
     [requestExpansion.parsedData],
   );
+  const warnings = log.warnings ?? [];
   const anatomyPaths = useMemo(() => {
     if (anatomySegments === null) return undefined;
     return new Set(anatomySegments.map((s) => s.path));
@@ -392,6 +393,19 @@ export const LogEntry = memo(function ({
               <TabsContent value="request">
                 {activeTab === "request" && (
                   <div className="px-4 pt-1 pb-3">
+                    {warnings.length > 0 && (
+                      <div className="mb-3 rounded border border-amber-500/30 bg-amber-500/10 p-3 text-xs">
+                        <div className="flex items-center gap-2 font-semibold text-amber-300">
+                          <AlertTriangle className="size-3.5" />
+                          Tool schema warnings
+                        </div>
+                        <ul className="mt-2 space-y-1 text-muted-foreground">
+                          {warnings.map((warning) => (
+                            <li key={warning}>{warning}</li>
+                          ))}
+                        </ul>
+                      </div>
+                    )}
                     <RequestTools
                       summary={requestTools}
                       calledToolNames={responseAnalysis.toolNames ?? []}

package/src/components/proxy-viewer/LogEntryHeader.tsx

@@ -159,6 +159,7 @@ export const LogEntryHeader = memo(function ({
   const firstChunkLabel = firstChunkMs === null ? null : formatElapsed(firstChunkMs);
   const tokenRateLabel =
     tokensPerSecond === null || tokensPerSecond <= 0 ? null : formatTokenRate(tokensPerSecond);
+  const warningCount = log.warnings?.length ?? 0;
 
   return (
     <TooltipProvider>
@@ -229,6 +230,25 @@ export const LogEntryHeader = memo(function ({
           </Badge>
         )}
 
+        {warningCount > 0 && (
+          <Tooltip>
+            <TooltipTrigger asChild>
+              <Badge
+                variant="outline"
+                className="text-[10px] px-1.5 py-0 h-5 font-mono tabular-nums gap-1 bg-amber-500/15 text-amber-400 border-amber-500/25"
+              >
+                <AlertTriangle className="size-3" aria-label="Tool schema warnings" />
+                {warningCount}
+              </Badge>
+            </TooltipTrigger>
+            <TooltipContent>
+              {warningCount === 1
+                ? "1 tool schema warning"
+                : `${warningCount} tool schema warnings`}
+            </TooltipContent>
+          </Tooltip>
+        )}
+
         {/* Elapsed time */}
         {log.elapsedMs !== null && (
           <Tooltip>

package/src/contracts/log.ts

@@ -58,6 +58,7 @@ export const CapturedLogSchema = z.object({
   rawRequestBodyBytes: z.number().int().nonnegative().nullable().optional(),
   responseTextBytes: z.number().int().nonnegative().nullable().optional(),
   bodyContentMode: z.enum(["full", "compact", "truncated"]).optional(),
+  warnings: z.array(z.string()).optional(),
   /** Error message from streaming response (e.g., SSE error event) */
   error: z.string().nullable().optional(),
 });

package/src/proxy/logFinalizer.ts

@@ -9,6 +9,7 @@ import type { CapturedLog } from "./schemas";
 import { getSessionProcess, isSessionProcessAvailable } from "./sessionProcess";
 import { finalizeLogUpdate } from "./store";
 import { computeTokensPerSecond } from "./streamTiming";
+import { analyzeToolSchemaWarnings } from "./toolSchemaWarnings";
 
 type BaseFinalizeLogJob = {
   log: CapturedLog;
@@ -91,6 +92,7 @@ export function buildFileLogEntry(log: CapturedLog, upstreamUrl: string): Record
     clientProjectFolder: log.clientProjectFolder,
     streamingChunks: log.streamingChunks,
     streamingChunksPath: log.streamingChunksPath,
+    warnings: log.warnings,
     error: log.error,
   };
 }
@@ -152,6 +154,57 @@ function applyOptionalStreamingTiming(log: CapturedLog, job: FinalizeLogJob): vo
   }
 }
 
+type ToolSchemaWarningAnalysisJob = {
+  log: CapturedLog;
+  upstreamUrl: string;
+  error: string | null;
+};
+
+let toolSchemaWarningQueue: Promise<void> = Promise.resolve();
+
+function deferToolSchemaWarningAnalysis(): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, 0);
+  });
+}
+
+function withToolSchemaWarnings(log: CapturedLog): CapturedLog | null {
+  const warnings = analyzeToolSchemaWarnings({
+    rawRequestBody: log.rawRequestBody,
+    responseText: log.responseText,
+    apiFormat: log.apiFormat,
+  });
+  if (warnings.length === 0) return null;
+  const mergedWarnings = Array.from(new Set([...(log.warnings ?? []), ...warnings]));
+  if (mergedWarnings.length === (log.warnings?.length ?? 0)) return null;
+  return { ...log, warnings: mergedWarnings };
+}
+
+async function runToolSchemaWarningAnalysis(job: ToolSchemaWarningAnalysisJob): Promise<void> {
+  await deferToolSchemaWarningAnalysis();
+  const updatedLog = withToolSchemaWarnings(job.log);
+  if (updatedLog === null) return;
+
+  appendLogEntry({ ...buildFileLogEntry(updatedLog, job.upstreamUrl), error: job.error });
+  finalizeLogUpdate(updatedLog);
+}
+
+function scheduleToolSchemaWarningAnalysis(job: ToolSchemaWarningAnalysisJob): void {
+  toolSchemaWarningQueue = toolSchemaWarningQueue
+    .catch(() => undefined)
+    .then(() => runToolSchemaWarningAnalysis(job))
+    .catch((err: unknown) => {
+      logger.warn(
+        `[logFinalizer] Tool schema warning analysis failed for log #${job.log.id}:`,
+        errorMessage(err),
+      );
+    });
+}
+
+export async function flushToolSchemaWarningAnalysis(): Promise<void> {
+  await toolSchemaWarningQueue;
+}
+
 function finalizeNonStreaming(
   job: FinalizeNonStreamingLogJob,
   log: CapturedLog,
@@ -384,6 +437,11 @@ export function buildFinalizeLogResult(job: FinalizeLogJob): FinalizeLogResult {
 export function commitFinalizeLogResult(result: FinalizeLogResult): void {
   appendLogEntry({ ...buildFileLogEntry(result.log, result.upstreamUrl), error: result.error });
   finalizeLogUpdate(result.log);
+  scheduleToolSchemaWarningAnalysis({
+    log: cloneLog(result.log),
+    upstreamUrl: result.upstreamUrl,
+    error: result.error,
+  });
   if (result.cleanupRawStreamPath !== undefined && result.cleanupRawStreamPath !== null) {
     try {
       rmSync(result.cleanupRawStreamPath, { force: true });

package/src/proxy/logSearch.ts

@@ -70,6 +70,7 @@ function searchableFields(log: CapturedLog): string[] {
     optionalText(log.clientCwd),
     optionalText(log.clientProjectFolder),
     optionalText(log.error),
+    ...(log.warnings ?? []),
   ].filter((value): value is string => value !== null && value.length > 0);
 }