@tonyclaw/agent-inspector 3.1.32 → 4.0.2

package/src/proxy/evidenceExporter.ts

@@ -1,235 +0,0 @@
-import assert from "node:assert/strict";
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import {
-  type EvidenceExportOptions,
-  type EvidenceExportResult,
-  type InspectorRun,
-  type InspectorRunEvidence,
-} from "../lib/runContract";
-import { getDataDir } from "./dataDir";
-import { analyzeEvidence } from "./evidenceAnalysis";
-import { getSessionInfo } from "./store";
-import { updateRunEvidence } from "./runStore";
-import {
-  ensurePrivateDirectorySync,
-  PRIVATE_FILE_MODE,
-  securePrivateFileSync,
-} from "./privateDataPath";
-
-type EvidenceDocument = EvidenceExportResult;
-
-function evidenceDir(runId: string): string {
-  return join(getDataDir(), "evidence", runId);
-}
-
-function jsonPath(runId: string): string {
-  return join(evidenceDir(runId), "evidence.json");
-}
-
-function markdownPath(runId: string): string {
-  return join(evidenceDir(runId), "evidence.md");
-}
-
-function htmlPath(runId: string): string {
-  return join(evidenceDir(runId), "evidence.html");
-}
-
-function formatList(values: readonly string[]): string {
-  return values.length > 0 ? values.join(", ") : "n/a";
-}
-
-function escapeHtml(value: string): string {
-  return value
-    .replace(/&/g, "&")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;");
-}
-
-function buildMarkdown(document: EvidenceDocument): string {
-  const session = document.session;
-  const lines = [
-    `# ${document.run.title}`,
-    "",
-    `- Run ID: ${document.run.id}`,
-    `- Session ID: ${document.run.sessionId}`,
-    `- Group ID: ${document.run.groupId ?? "n/a"}`,
-    `- Status: ${document.run.status}`,
-    `- Project: ${document.run.project ?? "n/a"}`,
-    `- Agent: ${document.run.agent ?? "n/a"}`,
-    `- Created: ${document.run.createdAt}`,
-    "",
-    `- Outcome: ${document.classification.outcome}`,
-    `- Failure Category: ${document.classification.category}`,
-    `- Severity: ${document.classification.severity}`,
-    `- Evidence JSON: ${document.evidence.jsonPath}`,
-    `- Evidence HTML: ${document.evidence.htmlPath}`,
-    "",
-  ];
-
-  if (document.run.task !== null) {
-    lines.push("## Task", "", document.run.task, "");
-  }
-
-  if (session === null) {
-    lines.push("## Session", "", "No Inspector session data was available for this run.", "");
-  } else {
-    lines.push(
-      "## Session",
-      "",
-      `- Inspector URL: ${session.inspectorUrl}`,
-      `- Compact Logs URL: ${session.compactLogsUrl}`,
-      `- Status: ${session.status}`,
-      `- Coverage: ${session.logCoverage}`,
-      `- Requests: ${session.requestCount}`,
-      `- Errors: ${session.errorCount}`,
-      `- Models: ${formatList(session.models)}`,
-      `- Providers: ${formatList(session.providers)}`,
-      `- Tokens: ${session.tokenUsage.total}`,
-      "",
-      "## Failure Classification",
-      "",
-      document.classification.summary,
-      "",
-      "### Evidence Logs",
-      "",
-      document.classification.evidenceLogIds.length > 0
-        ? document.classification.evidenceLogIds.map((id) => `- #${id}`).join("\n")
-        : "No failing log ids were identified.",
-      "",
-      "### Suggested Next Actions",
-      "",
-      ...document.classification.hints.map((hint) => `- ${hint}`),
-      "",
-      "## Run Timeline",
-      "",
-      "| Time | Event | Severity | Evidence |",
-      "| --- | --- | --- | --- |",
-      ...document.timeline.map((event) => {
-        const evidence = event.logId === null ? "n/a" : `log ${event.logId}`;
-        return `| ${event.timestamp} | ${event.title} | ${event.severity} | ${evidence} |`;
-      }),
-      "",
-      "## Latest Logs",
-      "",
-    );
-
-    if (session.latestLogs.length === 0) {
-      lines.push("No compact logs were available.", "");
-    } else {
-      lines.push(
-        "| ID | Status | Model | Latency | Stream | Path | Error |",
-        "| --- | --- | --- | --- | --- | --- | --- |",
-      );
-      for (const log of session.latestLogs) {
-        const streamTiming = log.isStreaming
-          ? `first=${log.firstChunkMs ?? "n/a"}ms total=${log.totalStreamMs ?? "n/a"}ms tps=${
-              log.tokensPerSecond ?? "n/a"
-            }`
-          : "n/a";
-        lines.push(
-          `| ${log.id} | ${log.status ?? "n/a"} | ${log.model ?? "n/a"} | ${
-            log.latencyMs ?? "n/a"
-          } | ${streamTiming} | ${log.path} | ${log.hasError ? "yes" : "no"} |`,
-        );
-      }
-      lines.push("");
-    }
-  }
-
-  lines.push("## Jenkins Report", "", document.jenkinsReport.markdown, "");
-
-  return `${lines.join("\n")}\n`;
-}
-
-function buildHtml(markdown: string, title: string): string {
-  return `<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <title>${escapeHtml(title)}</title>
-  <style>
-    body { font-family: system-ui, sans-serif; max-width: 960px; margin: 40px auto; line-height: 1.5; }
-    pre { white-space: pre-wrap; background: #f6f8fa; padding: 16px; border-radius: 8px; }
-  </style>
-</head>
-<body>
-  <pre>${escapeHtml(markdown)}</pre>
-</body>
-</html>
-`;
-}
-
-export async function exportRunEvidence(
-  run: InspectorRun,
-  options: EvidenceExportOptions,
-  baseUrl: string,
-): Promise<EvidenceExportResult> {
-  const session = await getSessionInfo(run.sessionId, {
-    baseUrl,
-    includeHistory: options?.includeHistory,
-    latestLogLimit: options?.latestLogLimit,
-  });
-  const exportedAt = new Date().toISOString();
-  const evidence: InspectorRunEvidence = {
-    jsonPath: jsonPath(run.id),
-    markdownPath: markdownPath(run.id),
-    htmlPath: htmlPath(run.id),
-    exportedAt,
-  };
-  const documentRun: InspectorRun = {
-    ...run,
-    evidence,
-    updatedAt: exportedAt,
-  };
-  const analysis = analyzeEvidence({
-    run: documentRun,
-    session,
-    exportedAt,
-    evidencePaths: {
-      jsonPath: evidence.jsonPath,
-      markdownPath: evidence.markdownPath,
-      htmlPath: evidence.htmlPath,
-    },
-  });
-  const document: EvidenceDocument = {
-    run: documentRun,
-    evidence,
-    session,
-    timeline: analysis.timeline,
-    classification: analysis.classification,
-    jenkinsReport: analysis.jenkinsReport,
-  };
-  const markdown = buildMarkdown(document);
-
-  assert(ensurePrivateDirectorySync(evidenceDir(run.id)), "Could not secure evidence directory");
-  writeFileSync(evidence.jsonPath, `${JSON.stringify({ ...document, evidence }, null, 2)}\n`, {
-    encoding: "utf8",
-    mode: PRIVATE_FILE_MODE,
-  });
-  writeFileSync(evidence.markdownPath, markdown, {
-    encoding: "utf8",
-    mode: PRIVATE_FILE_MODE,
-  });
-  writeFileSync(evidence.htmlPath, buildHtml(markdown, run.title), {
-    encoding: "utf8",
-    mode: PRIVATE_FILE_MODE,
-  });
-  for (const path of [evidence.jsonPath, evidence.markdownPath, evidence.htmlPath]) {
-    assert(securePrivateFileSync(path), `Could not secure evidence file ${path}`);
-  }
-
-  const updatedRun = updateRunEvidence(run.id, evidence) ?? documentRun;
-  return { ...document, run: updatedRun };
-}
-
-export function readEvidenceMarkdown(run: InspectorRun): string | null {
-  const path = run.evidence?.markdownPath;
-  if (path === undefined || !existsSync(path)) return null;
-  try {
-    return readFileSync(path, "utf8");
-  } catch {
-    return null;
-  }
-}

package/src/proxy/formats/anthropic/anthropicProvider.ts

@@ -1,75 +0,0 @@
-import type { CapturedLog } from "../../schemas";
-import type { ProviderAdapter } from "../providerAdapter";
-import { registry } from "../providers";
-import { extractAnthropicStream } from "./stream";
-
-const DEFAULT_UPSTREAM = "https://api.anthropic.com";
-
-// Default routes - MiniMax is hardcoded here
-const DEFAULT_ROUTES: Record<string, string> = {
-  MiniMax: "https://api.minimaxi.com/anthropic",
-};
-
-function getUpstreamForModel(model: string): string {
-  let bestPrefix = "";
-  let bestUrl = DEFAULT_UPSTREAM;
-
-  for (const [prefix, url] of Object.entries(DEFAULT_ROUTES)) {
-    if (model.startsWith(prefix) && prefix.length > bestPrefix.length) {
-      bestPrefix = prefix;
-      bestUrl = url;
-    }
-  }
-
-  return bestUrl;
-}
-
-/**
- * Anthropic Provider Implementation
- */
-export const anthropicProvider: ProviderAdapter = {
-  name: "anthropic",
-
-  matches(model: string): boolean {
-    const modelLower = model.toLowerCase();
-
-    // Don't match OpenAI models
-    if (modelLower.startsWith("openai-")) {
-      return false;
-    }
-
-    // Match Anthropic models
-    if (modelLower.includes("claude") || modelLower.includes("anthropic")) {
-      return true;
-    }
-
-    // Match known route prefixes (e.g., MiniMax)
-    for (const prefix of Object.keys(DEFAULT_ROUTES)) {
-      if (modelLower.startsWith(prefix.toLowerCase())) {
-        return true;
-      }
-    }
-
-    // Default to Anthropic for unknown models (legacy behavior)
-    return true;
-  },
-
-  getUpstreamBase(_isChatCompletions: boolean, providerConfig?: { baseUrl?: string }): string {
-    if (providerConfig?.baseUrl !== undefined) {
-      return providerConfig.baseUrl;
-    }
-    return DEFAULT_UPSTREAM;
-  },
-
-  extractStream(
-    raw: string,
-    log: CapturedLog,
-    fallbackModel?: string,
-    collectChunks?: boolean,
-  ): string {
-    return extractAnthropicStream(raw, log, fallbackModel, collectChunks);
-  },
-};
-
-// Register the provider
-registry.register(anthropicProvider);

package/src/proxy/formats/anthropic/handler.ts

@@ -1,75 +0,0 @@
-import type { FormatHandler, ParsedRequest } from "../handler";
-import type { CapturedLog, TokenUsage } from "../../schemas";
-import { AnthropicRequestSchema, AnthropicResponseSchema } from "./schemas";
-import { extractAnthropicStream } from "./stream";
-
-export const AnthropicFormatHandler: FormatHandler = {
-  format: "anthropic",
-
-  parseRequest(rawBody: string, headers?: Headers): ParsedRequest | null {
-    try {
-      const json: unknown = JSON.parse(rawBody);
-      const result = AnthropicRequestSchema.safeParse(json);
-      if (result.success) {
-        return {
-          model: result.data.model,
-          sessionId:
-            result.data.metadata?.user_id ??
-            headers?.get("x-agent-inspector-session-id") ??
-            headers?.get("x-session-affinity") ??
-            null,
-        };
-      }
-      return null;
-    } catch {
-      return null;
-    }
-  },
-
-  extractTokens(responseBody: string): TokenUsage {
-    try {
-      const json: unknown = JSON.parse(responseBody);
-      const result = AnthropicResponseSchema.safeParse(json);
-      if (result.success) {
-        return {
-          inputTokens: result.data.usage.input_tokens ?? null,
-          outputTokens: result.data.usage.output_tokens ?? null,
-          cacheCreationInputTokens: result.data.usage.cache_creation_input_tokens ?? null,
-          cacheReadInputTokens: result.data.usage.cache_read_input_tokens ?? null,
-        };
-      }
-    } catch {
-      // Fall through
-    }
-    return {
-      inputTokens: null,
-      outputTokens: null,
-      cacheCreationInputTokens: null,
-      cacheReadInputTokens: null,
-    };
-  },
-
-  extractStream(
-    raw: string,
-    log: CapturedLog,
-    fallbackModel?: string,
-    collectChunks?: boolean,
-  ): string {
-    return extractAnthropicStream(raw, log, fallbackModel, collectChunks);
-  },
-
-  detectFormat(rawBody: string | null): boolean {
-    if (rawBody === null) return false;
-    try {
-      const json: unknown = JSON.parse(rawBody);
-      if (typeof json === "object" && json !== null && !Array.isArray(json)) {
-        const keys = Object.keys(json);
-        // Anthropic puts `system` as a top-level key alongside `model` and `messages`
-        return keys.includes("model") && keys.includes("messages") && keys.includes("system");
-      }
-      return false;
-    } catch {
-      return false;
-    }
-  },
-};

package/src/proxy/formats/anthropic/index.ts

@@ -1,13 +0,0 @@
-// Register format handler
-import "./register";
-
-export { AnthropicFormatHandler } from "./handler";
-export {
-  AnthropicRequestSchema,
-  AnthropicResponseSchema,
-  SseEventSchema,
-  type AnthropicResponse,
-  type ResponseContentBlockType,
-} from "./schemas";
-export { extractAnthropicStream } from "./stream";
-export { anthropicProvider } from "./anthropicProvider";

package/src/proxy/formats/anthropic/register.ts

@@ -1,4 +0,0 @@
-import { formatRegistry } from "../registry";
-import { AnthropicFormatHandler } from "./handler";
-
-formatRegistry.register(AnthropicFormatHandler);

package/src/proxy/formats/anthropic/schemas.ts

@@ -1,6 +0,0 @@
-export {
-  AnthropicRequestSchema,
-  AnthropicResponseSchema,
-  SseEventSchema,
-} from "../../../contracts/anthropic";
-export type { AnthropicResponse, ResponseContentBlockType } from "../../../contracts/anthropic";

package/src/proxy/formats/anthropic/stream.ts

@@ -1,205 +0,0 @@
-import type { CapturedLog, JsonValue } from "../../schemas";
-import { trustAsJsonValue } from "../jsonSchema";
-import { SseEventSchema } from "./schemas";
-
-type StreamTextBlock = { type: "text"; text: string };
-type StreamThinkingBlock = { type: "thinking"; thinking: string; signature: string };
-type StreamThinkBlock = { type: "think"; thinking: string; signature: string };
-type StreamToolUseBlock = { type: "tool_use"; id: string; name: string; inputJson: string };
-type StreamBlock = StreamTextBlock | StreamThinkingBlock | StreamThinkBlock | StreamToolUseBlock;
-
-function parseInputJson(json: string): Record<string, unknown> {
-  if (json === "") return {};
-  try {
-    const parsed: unknown = JSON.parse(json);
-    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
-      return { ...parsed };
-    }
-    return {};
-  } catch {
-    return {};
-  }
-}
-
-function finalizeBlock(block: StreamBlock): Record<string, unknown> {
-  switch (block.type) {
-    case "text":
-      return { type: "text", text: block.text };
-    case "thinking": {
-      const out: Record<string, unknown> = { type: "thinking", thinking: block.thinking };
-      if (block.signature !== "") out.signature = block.signature;
-      return out;
-    }
-    case "think": {
-      const out: Record<string, unknown> = { type: "think", thinking: block.thinking };
-      if (block.signature !== "") out.signature = block.signature;
-      return out;
-    }
-    case "tool_use":
-      return {
-        type: "tool_use",
-        id: block.id,
-        name: block.name,
-        input: parseInputJson(block.inputJson),
-      };
-  }
-}
-
-/**
- * Extract Anthropic streaming response and return normalized JSON.
- * Optionally collects SSE chunks into log.streamingChunks for debugging/display.
- */
-export function extractAnthropicStream(
-  raw: string,
-  log: CapturedLog,
-  fallbackModel?: string,
-  collectChunks?: boolean,
-): string {
-  const blocks = new Map<number, StreamBlock>();
-  let id = "";
-  let model = "";
-  let stopReason: string | null = null;
-  let stopSequence: string | null = null;
-  let inputTokens = 0;
-  let outputTokens = 0;
-
-  const MAX_CHUNKS = 1000;
-  let chunkIndex = 0;
-  let streamStartMs = 0;
-  const chunks: Array<{ index: number; timestamp: number; type: string; data: JsonValue }> = [];
-
-  for (const line of raw.split("\n")) {
-    const trimmedLine = line.trim();
-    if (!trimmedLine.startsWith("data: ")) continue;
-    try {
-      const json: unknown = JSON.parse(trimmedLine.slice(6));
-      const parsed = SseEventSchema.safeParse(json);
-      if (!parsed.success) continue;
-      const data = parsed.data;
-
-      if (chunkIndex === 0) streamStartMs = Date.now();
-
-      if (collectChunks === true && chunks.length < MAX_CHUNKS) {
-        chunks.push({
-          index: chunkIndex,
-          timestamp: Date.now() - streamStartMs,
-          type: data.type,
-          // `data` has already been validated by SseEventSchema above; the
-          // recursive JsonValue walk is a redundant full-tree zod parse on
-          // every SSE event. See trustAsJsonValue for the rationale.
-          data: trustAsJsonValue(data),
-        });
-      }
-      chunkIndex++;
-
-      switch (data.type) {
-        case "message_start":
-          id = data.message.id;
-          model = data.message.model;
-          inputTokens = data.message.usage.input_tokens;
-          log.inputTokens = inputTokens;
-          log.cacheCreationInputTokens = data.message.usage.cache_creation_input_tokens ?? null;
-          log.cacheReadInputTokens = data.message.usage.cache_read_input_tokens ?? null;
-          if (log.model === null) log.model = model;
-          break;
-        case "content_block_start": {
-          const cb = data.content_block;
-          switch (cb.type) {
-            case "text":
-              blocks.set(data.index, { type: "text", text: cb.text ?? "" });
-              break;
-            case "thinking":
-              blocks.set(data.index, {
-                type: "thinking",
-                thinking: cb.thinking ?? "",
-                signature: cb.signature ?? "",
-              });
-              break;
-            case "think":
-              blocks.set(data.index, {
-                type: "think",
-                thinking: cb.thinking ?? "",
-                signature: cb.signature ?? "",
-              });
-              break;
-            case "tool_use":
-              blocks.set(data.index, {
-                type: "tool_use",
-                id: cb.id,
-                name: cb.name,
-                inputJson: "",
-              });
-              break;
-          }
-          break;
-        }
-        case "content_block_delta": {
-          const block = blocks.get(data.index);
-          if (block === undefined) break;
-          const delta = data.delta;
-          if (delta.type === "text_delta" && block.type === "text") {
-            block.text += delta.text;
-          } else if (
-            delta.type === "thinking_delta" &&
-            (block.type === "thinking" || block.type === "think")
-          ) {
-            block.thinking += delta.thinking;
-          } else if (
-            delta.type === "signature_delta" &&
-            (block.type === "thinking" || block.type === "think")
-          ) {
-            block.signature += delta.signature;
-          } else if (delta.type === "input_json_delta" && block.type === "tool_use") {
-            block.inputJson += delta.partial_json;
-          }
-          break;
-        }
-        case "message_delta":
-          stopReason = data.delta.stop_reason;
-          stopSequence = data.delta.stop_sequence ?? null;
-          outputTokens = data.usage.output_tokens;
-          log.outputTokens = outputTokens;
-          // Cache tokens may also be present in message_delta usage
-          if (data.usage.cache_creation_input_tokens !== undefined) {
-            log.cacheCreationInputTokens = data.usage.cache_creation_input_tokens;
-          }
-          if (data.usage.cache_read_input_tokens !== undefined) {
-            log.cacheReadInputTokens = data.usage.cache_read_input_tokens;
-          }
-          break;
-        case "error":
-          // Store error info on the log for display
-          log.error = data.error.message;
-          break;
-        case "content_block_stop":
-        case "message_stop":
-        case "ping":
-          break;
-      }
-    } catch {
-      // non-JSON SSE line, skip
-    }
-  }
-
-  if (collectChunks === true) {
-    log.streamingChunks = {
-      chunks,
-      truncated: chunkIndex > MAX_CHUNKS,
-    };
-  }
-
-  const orderedContent = [...blocks.entries()]
-    .sort(([a], [b]) => a - b)
-    .map(([, block]) => finalizeBlock(block));
-
-  return JSON.stringify({
-    id,
-    type: "message",
-    model: model !== "" ? model : (fallbackModel ?? ""),
-    role: "assistant",
-    content: orderedContent,
-    stop_reason: stopReason,
-    stop_sequence: stopSequence,
-    usage: { input_tokens: inputTokens, output_tokens: outputTokens },
-  });
-}

package/src/proxy/formats/handler.ts

@@ -1,46 +0,0 @@
-import type { ApiFormat, CapturedLog, TokenUsage } from "../schemas";
-
-/**
- * Structured result of parsing a raw request body.
- */
-export type ParsedRequest = {
-  model: string | null;
-  sessionId: string | null;
-};
-
-/**
- * FormatHandler defines the contract for all API format implementations.
- *
- * Each API format (Anthropic, OpenAI) provides its own handler that encapsulates
- * request parsing, response parsing, SSE stream extraction, and token extraction.
- * This replaces the scattered if/else format branching previously in handler.ts.
- */
-export type FormatHandler = {
-  /** The format identifier */
-  readonly format: ApiFormat;
-
-  /**
-   * Parse a raw request body to extract model name and metadata.
-   */
-  parseRequest(rawBody: string, headers?: Headers): ParsedRequest | null;
-
-  /**
-   * Extract token usage from a non-streaming response body.
-   */
-  extractTokens(responseBody: string): TokenUsage;
-
-  /**
-   * Extract structured content from a streaming SSE response.
-   */
-  extractStream(
-    raw: string,
-    log: CapturedLog,
-    fallbackModel?: string,
-    collectChunks?: boolean,
-  ): string;
-
-  /**
-   * Detect if a raw request body uses this format.
-   */
-  detectFormat(rawBody: string | null): boolean;
-};

package/src/proxy/formats/index.ts

@@ -1,13 +0,0 @@
-// Import submodules to trigger handler registration
-import "./anthropic/index";
-import "./openai/index";
-
-// Import providers to trigger self-registration
-import "./anthropic/anthropicProvider";
-import "./openai/provider";
-import "./openai/zhipuProvider";
-import "./openai/alibabaProvider";
-
-export type { FormatHandler, ParsedRequest } from "./handler";
-export { apiFormatForPath, formatRegistry, formatForPath } from "./registry";
-export { registry } from "./providers";

package/src/proxy/formats/jsonSchema.ts

@@ -1,2 +0,0 @@
-export { JsonValueSchema, trustAsJsonValue } from "../../contracts/json";
-export type { JsonValue } from "../../contracts/json";