@tonyclaw/agent-inspector 3.1.7 → 3.1.9

package/src/lib/toolTrace.ts

@@ -0,0 +1,290 @@
+import type { ApiFormat, CapturedLog, StreamingChunk, ToolTraceEvent } from "../contracts";
+import { apiFormatForPath } from "./apiFormat";
+import { safeGetOwnProperty } from "./objectUtils";
+
+export type { ToolTraceEvent };
+
+const PREVIEW_LIMIT = 180;
+
+type ResolvedLogFormat = ApiFormat;
+
+function resolveLogFormat(log: Pick<CapturedLog, "path" | "apiFormat">): ResolvedLogFormat {
+  const pathFormat = apiFormatForPath(log.path);
+  return pathFormat === "unknown" ? log.apiFormat : pathFormat;
+}
+
+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;
+  }
+}
+
+function parseJsonResponse(responseText: string | null): unknown {
+  if (responseText === null) return null;
+  try {
+    const parsed: unknown = JSON.parse(responseText);
+    if (typeof parsed === "string") {
+      return JSON.parse(parsed);
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function previewValue(value: unknown): string | null {
+  if (value === undefined || value === null) return null;
+  const raw = typeof value === "string" ? value : JSON.stringify(value);
+  if (raw === undefined) return null;
+  const normalized = raw.replace(/\s+/g, " ").trim();
+  if (normalized.length === 0) return null;
+  return normalized.length > PREVIEW_LIMIT
+    ? `${normalized.slice(0, PREVIEW_LIMIT - 1)}...`
+    : normalized;
+}
+
+function copyValue(value: unknown): string | null {
+  if (value === undefined || value === null) return null;
+  if (typeof value === "string") return value.length > 0 ? value : null;
+  const raw = JSON.stringify(value, null, 2);
+  return raw === undefined || raw.length === 0 ? null : raw;
+}
+
+function makeEvent({
+  log,
+  provider,
+  index,
+  name,
+  input,
+}: {
+  log: Pick<CapturedLog, "id">;
+  provider: "anthropic" | "openai";
+  index: number;
+  name: string;
+  input: unknown;
+}): ToolTraceEvent {
+  return {
+    id: `${String(log.id)}-${provider}-tool-${String(index)}`,
+    logId: log.id,
+    index,
+    provider,
+    name,
+    argumentsText: copyValue(input),
+    argumentsPreview: previewValue(input),
+  };
+}
+
+function extractAnthropicResponseToolTraceEvents(log: CapturedLog): ToolTraceEvent[] {
+  const parsed = parseJsonResponse(log.responseText);
+  const content = safeGetOwnProperty(parsed, "content");
+  if (!Array.isArray(content)) return [];
+
+  const events: ToolTraceEvent[] = [];
+  for (const block of content) {
+    const type = safeGetOwnProperty(block, "type");
+    if (type !== "tool_use") continue;
+    const name = safeGetOwnProperty(block, "name");
+    if (typeof name !== "string" || name.length === 0) continue;
+    const input = safeGetOwnProperty(block, "input");
+    events.push(makeEvent({ log, provider: "anthropic", index: events.length, name, input }));
+  }
+  return events;
+}
+
+function extractOpenAIResponseToolTraceEvents(log: CapturedLog): ToolTraceEvent[] {
+  const parsed = parseJsonResponse(log.responseText);
+  const choices = safeGetOwnProperty(parsed, "choices");
+  const events: ToolTraceEvent[] = [];
+
+  if (Array.isArray(choices)) {
+    for (const choice of choices) {
+      const message = safeGetOwnProperty(choice, "message");
+      const toolCalls = safeGetOwnProperty(message, "tool_calls");
+      if (Array.isArray(toolCalls)) {
+        for (const call of toolCalls) {
+          const fn = safeGetOwnProperty(call, "function");
+          const name = safeGetOwnProperty(fn, "name");
+          if (typeof name !== "string" || name.length === 0) continue;
+          const args = safeGetOwnProperty(fn, "arguments");
+          events.push(
+            makeEvent({ log, provider: "openai", index: events.length, name, input: args }),
+          );
+        }
+      }
+      const functionCall = safeGetOwnProperty(message, "function_call");
+      const functionCallName = safeGetOwnProperty(functionCall, "name");
+      if (typeof functionCallName === "string" && functionCallName.length > 0) {
+        const args = safeGetOwnProperty(functionCall, "arguments");
+        events.push(
+          makeEvent({
+            log,
+            provider: "openai",
+            index: events.length,
+            name: functionCallName,
+            input: args,
+          }),
+        );
+      }
+    }
+  }
+
+  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(makeEvent({ log, provider: "openai", index: events.length, name, input: args }));
+    }
+  }
+  return events;
+}
+
+function chunkData(chunk: StreamingChunk): unknown {
+  if (typeof chunk.data === "string") {
+    try {
+      return JSON.parse(chunk.data);
+    } catch {
+      return chunk.data;
+    }
+  }
+  return chunk.data;
+}
+
+function appendUniqueEvent(
+  events: ToolTraceEvent[],
+  seen: Set<string>,
+  event: ToolTraceEvent,
+): void {
+  const key = `${event.provider}:${event.name}:${event.index}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  events.push(event);
+}
+
+function extractAnthropicChunkToolTraceEvents(log: CapturedLog): ToolTraceEvent[] {
+  const chunks = log.streamingChunks?.chunks ?? [];
+  const events: ToolTraceEvent[] = [];
+  const seen = new Set<string>();
+
+  for (const chunk of chunks) {
+    const data = chunkData(chunk);
+    const contentBlock = safeGetOwnProperty(data, "content_block");
+    if (safeGetOwnProperty(contentBlock, "type") !== "tool_use") continue;
+    const name = safeGetOwnProperty(contentBlock, "name");
+    if (typeof name !== "string" || name.length === 0) continue;
+    const input = safeGetOwnProperty(contentBlock, "input");
+    appendUniqueEvent(
+      events,
+      seen,
+      makeEvent({ log, provider: "anthropic", index: chunk.index, name, input }),
+    );
+  }
+
+  return events.map((event, index) => ({
+    ...event,
+    id: `${String(log.id)}-anthropic-tool-${String(index)}`,
+    index,
+  }));
+}
+
+function extractOpenAIChunkToolTraceEvents(log: CapturedLog): ToolTraceEvent[] {
+  const chunks = log.streamingChunks?.chunks ?? [];
+  const events: ToolTraceEvent[] = [];
+  const seen = new Set<string>();
+
+  for (const chunk of chunks) {
+    const data = chunkData(chunk);
+    const choices = safeGetOwnProperty(data, "choices");
+    if (Array.isArray(choices)) {
+      for (const choice of choices) {
+        const delta = safeGetOwnProperty(choice, "delta");
+        const toolCalls = safeGetOwnProperty(delta, "tool_calls");
+        if (Array.isArray(toolCalls)) {
+          for (const call of toolCalls) {
+            const fn = safeGetOwnProperty(call, "function");
+            const name = safeGetOwnProperty(fn, "name");
+            if (typeof name !== "string" || name.length === 0) continue;
+            const args = safeGetOwnProperty(fn, "arguments");
+            appendUniqueEvent(
+              events,
+              seen,
+              makeEvent({ log, provider: "openai", index: events.length, name, input: args }),
+            );
+          }
+        }
+        const functionCall = safeGetOwnProperty(delta, "function_call");
+        const functionCallName = safeGetOwnProperty(functionCall, "name");
+        if (typeof functionCallName === "string" && functionCallName.length > 0) {
+          const args = safeGetOwnProperty(functionCall, "arguments");
+          appendUniqueEvent(
+            events,
+            seen,
+            makeEvent({
+              log,
+              provider: "openai",
+              index: events.length,
+              name: functionCallName,
+              input: args,
+            }),
+          );
+        }
+      }
+    }
+
+    const item = safeGetOwnProperty(data, "item");
+    if (safeGetOwnProperty(item, "type") === "function_call") {
+      const name = safeGetOwnProperty(item, "name");
+      if (typeof name === "string" && name.length > 0) {
+        const args = safeGetOwnProperty(item, "arguments");
+        appendUniqueEvent(
+          events,
+          seen,
+          makeEvent({ log, provider: "openai", index: events.length, name, input: args }),
+        );
+      }
+    }
+  }
+
+  return events.map((event, index) => ({
+    ...event,
+    id: `${String(log.id)}-openai-tool-${String(index)}`,
+    index,
+  }));
+}
+
+export function extractToolTraceEvents(log: CapturedLog): ToolTraceEvent[] {
+  if (log.toolTraceEvents !== undefined && log.toolTraceEvents.length > 0) {
+    return log.toolTraceEvents;
+  }
+
+  const format = resolveLogFormat(log);
+  if (responseMayContainToolTrace(log, format)) {
+    switch (format) {
+      case "anthropic":
+        return extractAnthropicResponseToolTraceEvents(log);
+      case "openai":
+        return extractOpenAIResponseToolTraceEvents(log);
+      case "unknown":
+        return [];
+    }
+  }
+
+  switch (format) {
+    case "anthropic":
+      return extractAnthropicChunkToolTraceEvents(log);
+    case "openai":
+      return extractOpenAIChunkToolTraceEvents(log);
+    case "unknown":
+      return [];
+  }
+}

package/src/proxy/logIndex.ts

@@ -9,8 +9,10 @@ import {
   type ApiFormat,
   type CaptureIncompleteReason,
   type CapturedLog,
+  type ToolTraceEvent,
 } from "./schemas";
 import { textByteLength } from "../lib/unknown";
+import { extractToolTraceEvents } from "../lib/toolTrace";
 import {
   getSqliteLogIndexMaxId,
   replaceSqliteLogIndexEntries,
@@ -60,6 +62,7 @@ export type LogIndexSummary = {
   droppedBytes: number;
   captureIncompleteReason: CaptureIncompleteReason | null;
   warnings?: string[];
+  toolTraceEvents?: ToolTraceEvent[];
   error: string | null;
 };
 
@@ -138,6 +141,7 @@ export function createLogIndexEntryMetadata(log: CapturedLog): LogIndexEntryMeta
       droppedBytes: log.droppedBytes ?? 0,
       captureIncompleteReason: log.captureIncompleteReason ?? null,
       warnings: log.warnings,
+      toolTraceEvents: extractToolTraceEvents(log),
       error: log.error ?? null,
     },
   };

package/src/proxy/schemas.ts

@@ -5,6 +5,7 @@ export {
   CapturedLogSchema,
   JsonValueSchema,
   StreamingChunkSchema,
+  ToolTraceEventSchema,
 } from "../contracts";
 export type {
   CapturedLog,
@@ -12,6 +13,7 @@ export type {
   CaptureIncompleteReason,
   JsonValue,
   StreamingChunk,
+  ToolTraceEvent,
   TokenUsage,
 } from "../contracts";
 

package/src/proxy/sqliteLogIndex.ts

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { logger, resolveLogDir } from "./logger";
-import type { ApiFormat, CaptureIncompleteReason } from "./schemas";
+import { ToolTraceEventSchema, type ApiFormat, type CaptureIncompleteReason } from "./schemas";
 import type { LogIndexEntry, LogIndexSummary } from "./logIndex";
 import { ensurePrivateDirectorySync, securePrivateFileSync } from "./privateDataPath";
 
@@ -52,6 +52,7 @@ CREATE TABLE IF NOT EXISTS log_index (
   dropped_bytes INTEGER NOT NULL DEFAULT 0,
   capture_incomplete_reason TEXT,
   warnings_json TEXT,
+  tool_trace_events_json TEXT,
   error TEXT
 );
 CREATE INDEX IF NOT EXISTS idx_log_index_session_id_id ON log_index(session_id, id);
@@ -98,9 +99,10 @@ INSERT INTO log_index (
   dropped_bytes,
   capture_incomplete_reason,
   warnings_json,
+  tool_trace_events_json,
   error
 ) VALUES (
-  ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
+  ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
 )
 ON CONFLICT(id) DO UPDATE SET
   file = excluded.file,
@@ -139,6 +141,7 @@ ON CONFLICT(id) DO UPDATE SET
   dropped_bytes = excluded.dropped_bytes,
   capture_incomplete_reason = excluded.capture_incomplete_reason,
   warnings_json = excluded.warnings_json,
+  tool_trace_events_json = excluded.tool_trace_events_json,
   error = excluded.error
 `;
 
@@ -232,6 +235,7 @@ const REQUIRED_SCHEMA_COLUMNS = [
   { name: "dropped_chunks", definition: "INTEGER NOT NULL DEFAULT 0" },
   { name: "dropped_bytes", definition: "INTEGER NOT NULL DEFAULT 0" },
   { name: "capture_incomplete_reason", definition: "TEXT" },
+  { name: "tool_trace_events_json", definition: "TEXT" },
 ];
 
 function ensureSchemaColumns(db: unknown): boolean {
@@ -394,6 +398,10 @@ function warningJson(warnings: string[] | undefined): string | null {
   return warnings === undefined ? null : JSON.stringify(warnings);
 }
 
+function toolTraceEventsJson(summary: LogIndexSummary | undefined): string | null {
+  return summary?.toolTraceEvents === undefined ? null : JSON.stringify(summary.toolTraceEvents);
+}
+
 function boolToInt(value: boolean): number {
   return value ? 1 : 0;
 }
@@ -438,6 +446,7 @@ function entryParams(entry: LogIndexEntry): readonly unknown[] {
     summary?.droppedBytes ?? 0,
     summary?.captureIncompleteReason ?? null,
     warningJson(summary?.warnings),
+    toolTraceEventsJson(summary),
     summary?.error ?? null,
   ];
 }
@@ -504,6 +513,18 @@ function readWarnings(row: unknown): string[] | undefined {
   }
 }
 
+function readToolTraceEvents(row: unknown): LogIndexSummary["toolTraceEvents"] {
+  const value = readString(row, "tool_trace_events_json");
+  if (value === null) return undefined;
+  try {
+    const parsed: unknown = JSON.parse(value);
+    const result = ToolTraceEventSchema.array().safeParse(parsed);
+    return result.success ? result.data : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
 function readRequiredNumber(row: unknown, name: string): number | null {
   const value = readNumber(row, name);
   return value === null || !Number.isInteger(value) ? null : value;
@@ -545,6 +566,7 @@ function summaryFromRow(row: unknown, id: number): LogIndexSummary {
     droppedBytes: readNumber(row, "dropped_bytes") ?? 0,
     captureIncompleteReason: readCaptureIncompleteReason(row),
     warnings: readWarnings(row),
+    toolTraceEvents: readToolTraceEvents(row),
     error: readString(row, "error"),
   };
 }

package/src/proxy/store.ts

@@ -36,6 +36,7 @@ import {
 import { writeChunks } from "./chunkStorage";
 import { closeSqliteLogIndex } from "./sqliteLogIndex";
 import type { SessionInfo, SessionLogSummary } from "../lib/sessionInfoContract";
+import { extractToolTraceEvents } from "../lib/toolTrace";
 import { textByteLength } from "../lib/unknown";
 import { buildSessionInfo, buildSessionLogSummary } from "./sessionInfo";
 import type { CapturedLog } from "./schemas";
@@ -338,6 +339,7 @@ export function compactLogForList(log: CapturedLog): CapturedLog {
     rawHeaders: undefined,
     headers: undefined,
     streamingChunks: undefined,
+    toolTraceEvents: log.toolTraceEvents ?? extractToolTraceEvents(log),
     rawRequestBodyBytes: log.rawRequestBodyBytes ?? textByteLength(log.rawRequestBody),
     responseTextBytes: log.responseTextBytes ?? textByteLength(log.responseText),
     bodyContentMode: "compact",
@@ -383,6 +385,7 @@ function compactLogFromIndexSummary(summary: LogIndexSummary): CapturedLog {
     droppedBytes: summary.droppedBytes,
     captureIncompleteReason: summary.captureIncompleteReason,
     warnings: summary.warnings,
+    toolTraceEvents: summary.toolTraceEvents,
     error: summary.error,
   });
 }