@tonyclaw/agent-inspector 2.0.36 → 2.0.38

package/src/proxy/formats/registry.ts

@@ -1,26 +1,26 @@
 import type { FormatHandler } from "./handler";
-import type { RequestFormat } from "../schemas";
+import type { ApiFormat } from "../schemas";
 import { PATH_V1_CHAT_COMPLETIONS, PATH_CHAT_COMPLETIONS, PATH_V1_MESSAGES } from "../constants";
 
 /**
- * Format registry — maps request paths and formats to their FormatHandler.
+ * API format registry maps request paths and API formats to their FormatHandler.
  *
  * Registered at module load time by each format's init module.
  */
 class FormatRegistryImpl {
-  private handlers = new Map<RequestFormat, FormatHandler>();
-  private pathMap = new Map<string, RequestFormat>();
+  private handlers = new Map<ApiFormat, FormatHandler>();
+  private pathMap = new Map<string, ApiFormat>();
 
   register(handler: FormatHandler): void {
     this.handlers.set(handler.format, handler);
   }
 
-  registerPath(path: string, format: RequestFormat): void {
+  registerPath(path: string, format: ApiFormat): void {
     this.pathMap.set(path, format);
   }
 
   /** Get handler by format identifier */
-  get(format: RequestFormat): FormatHandler | undefined {
+  get(format: ApiFormat): FormatHandler | undefined {
     return this.handlers.get(format);
   }
 
@@ -31,8 +31,14 @@ class FormatRegistryImpl {
     return format === undefined ? undefined : this.handlers.get(format);
   }
 
-  /** Detect format from request body content */
-  detectFormat(rawBody: string | null): RequestFormat {
+  /** Get the API format matching a request path without requiring handlers. */
+  getApiFormatByPath(path: string): ApiFormat | undefined {
+    const messagesPath = path.split("?")[0] ?? "";
+    return this.pathMap.get(messagesPath);
+  }
+
+  /** Detect API format from request body content */
+  detectFormat(rawBody: string | null): ApiFormat {
     if (rawBody === null) return "unknown";
     for (const handler of this.handlers.values()) {
       if (handler.detectFormat(rawBody)) return handler.format;
@@ -52,14 +58,17 @@ export function formatForPath(path: string): FormatHandler | null {
 }
 
 /**
- * Resolve the wire format from the request endpoint. The endpoint is
+ * Resolve the API format from the request endpoint. The endpoint is
  * authoritative because Anthropic and OpenAI request bodies overlap for
  * simple message-only calls.
  */
-export function requestFormatForPath(path: string): RequestFormat {
-  return formatForPath(path)?.format ?? "unknown";
+export function apiFormatForPath(path: string): ApiFormat {
+  return formatRegistry.getApiFormatByPath(path) ?? "unknown";
 }
 
+/** Backward-compatible alias for older internal imports. */
+export const requestFormatForPath = apiFormatForPath;
+
 // Register known paths
 formatRegistry.registerPath(PATH_V1_MESSAGES, "anthropic");
 formatRegistry.registerPath(PATH_V1_CHAT_COMPLETIONS, "openai");

package/src/proxy/handler.ts

@@ -247,7 +247,7 @@ export async function handleProxy(req: Request): Promise<Response> {
     }
   }
 
-  // Always-on protocol guard: OpenAI Chat Completions requires every
+  // Always-on OpenAI Chat Completions format guard: every
   // `role: "tool"` message to reference a `tool_call_id` present in a
   // preceding assistant message's `tool_calls`. Buggy clients sometimes
   // record a tool result without the matching assistant tool_call, which

package/src/proxy/openaiOrphanToolStrip.ts

@@ -1,5 +1,5 @@
 /**
- * OpenAI Chat Completions protocol guard: orphan `tool` messages.
+ * OpenAI Chat Completions format guard: orphan `tool` messages.
  *
  * The OpenAI Chat Completions spec requires every message with
  * `role: "tool"` to reference a `tool_call_id` that appears in a preceding

package/src/proxy/providers.ts

@@ -232,7 +232,7 @@ migrateFromLegacyConfLocation(store);
  * Expands the old `{ format, baseUrl }` representation into the matching
  * format-specific URL. Once either format-specific field exists, the record is
  * already on the current schema and must be preserved exactly: an empty or
- * missing counterpart means that protocol was intentionally not configured.
+ * missing counterpart means that API format was intentionally not configured.
  */
 export function migrateProvider(p: ProviderConfig): ProviderConfig {
   if (p.anthropicBaseUrl !== undefined || p.openaiBaseUrl !== undefined) {

package/src/proxy/schemas.ts

@@ -1,94 +1,32 @@
 import { z } from "zod";
 
-// Import JsonValueSchema from shared location to avoid circular dependency
-import { JsonValueSchema, type JsonValue } from "./formats/jsonSchema";
-
-export { JsonValueSchema };
-export type { JsonValue };
-
-export type RequestFormat = "anthropic" | "openai" | "unknown";
-
-/**
- * A single SSE event from a streaming response.
- */
-export const StreamingChunkSchema = z.object({
-  index: z.number(),
-  timestamp: z.number(),
-  type: z.string(),
-  data: JsonValueSchema,
-});
-
-export type StreamingChunk = z.infer<typeof StreamingChunkSchema>;
-
-const StreamingChunksArraySchema = z.object({
-  chunks: z.array(StreamingChunkSchema),
-  truncated: z.boolean().optional().default(false),
-});
-
-export const CapturedLogSchema = z.object({
-  id: z.number(),
-  timestamp: z.string(),
-  method: z.string(),
-  path: z.string(),
-  model: z.string().nullable(),
-  sessionId: z.string().nullable(),
-  rawRequestBody: z.string().nullable(),
-  responseStatus: z.number().nullable(),
-  responseText: z.string().nullable(),
-  inputTokens: z.number().nullable(),
-  outputTokens: z.number().nullable(),
-  cacheCreationInputTokens: z.number().nullable(),
-  cacheReadInputTokens: z.number().nullable(),
-  elapsedMs: z.number().nullable(),
-  firstChunkMs: z.number().nullable().optional(),
-  totalStreamMs: z.number().nullable().optional(),
-  tokensPerSecond: z.number().nullable().optional(),
-  streaming: z.boolean(),
-  userAgent: z.string().nullable(),
-  origin: z.string().nullable(),
-  rawHeaders: z.record(z.string(), z.string()).optional(),
-  /** Headers sent to the upstream LLM */
-  headers: z.record(z.string(), z.string()).optional(),
-  apiFormat: z.enum(["anthropic", "openai", "unknown"]).default("unknown"),
-  isTest: z.boolean().optional().default(false),
-  replayOfLogId: z.number().nullable().optional(),
-  providerName: z.string().nullable().optional(),
-  clientPort: z.number().nullable().optional(),
-  clientPid: z.number().nullable().optional(),
-  clientCwd: z.string().nullable().optional(),
-  clientProjectFolder: z.string().nullable().optional(),
-  streamingChunks: StreamingChunksArraySchema.optional(),
-  streamingChunksPath: z.string().nullable().optional(),
-  rawRequestBodyBytes: z.number().int().nonnegative().nullable().optional(),
-  responseTextBytes: z.number().int().nonnegative().nullable().optional(),
-  bodyContentMode: z.enum(["full", "compact", "truncated"]).optional(),
-  /** Error message from streaming response (e.g., SSE error event) */
-  error: z.string().nullable().optional(),
-});
-
-export type CapturedLog = z.infer<typeof CapturedLogSchema>;
-
-export type TokenUsage = {
-  inputTokens: number | null;
-  outputTokens: number | null;
-  cacheCreationInputTokens: number | null;
-  cacheReadInputTokens: number | null;
-};
+export { CapturedLogSchema, JsonValueSchema, StreamingChunkSchema } from "../contracts";
+export type {
+  CapturedLog,
+  ApiFormat,
+  JsonValue,
+  RequestFormat,
+  StreamingChunk,
+  TokenUsage,
+} from "../contracts";
 
 // ============================================================
-// Import types and schemas from formats
+// Import types and schemas from shared contracts
 // ============================================================
 
-// Re-export types and schemas from formats for backward compatibility
+// Re-export types and schemas from shared contracts for backward compatibility
 export {
+  AnthropicRequestSchema,
+  AnthropicResponseSchema,
   InspectorRequestSchema,
   InspectorResponseSchema,
   SseEventSchema,
-} from "./formats/anthropic/schemas";
+} from "../contracts/anthropic";
 export type {
+  AnthropicResponse,
   InspectorResponse,
   ResponseContentBlockType,
-} from "./formats/anthropic/schemas";
+} from "../contracts/anthropic";
 
 export {
   OpenAIRequestSchema,
@@ -97,7 +35,7 @@ export {
   type OpenAIResponse,
   type OpenAIToolCall,
   parseOpenAIResponse,
-} from "./formats/openai/schemas";
+} from "../contracts/openai";
 
 // Schema for model name in request body (used for routing)
 const RequestModelSchema = z.object({
@@ -141,7 +79,7 @@ function extractSessionIdFromHeaders(headers: Headers): string | null {
  * for routing + log creation: the model (used for provider selection) and the
  * session id (from `metadata.user_id` or the `x-session-affinity` header).
  *
- * Returning `null` for either field is a valid outcome — callers must handle
+ * Returning `null` for either field is a valid outcome; callers must handle
  * "unknown" gracefully. Callers that already have the body string should use
  * this instead of re-parsing with `extractModelFromBody` and a second pass
  * for the session id.

package/src/proxy/store.ts

@@ -34,6 +34,7 @@ import type { SessionInfo, SessionLogSummary } from "../lib/sessionInfoContract"
 import { buildSessionInfo, buildSessionLogSummary } from "./sessionInfo";
 import type { CapturedLog } from "./schemas";
 import { CapturedLogSchema } from "./schemas";
+import { apiFormatForPath } from "./formats/registry";
 import {
   clearSessionRegistry,
   getLogSessionId,
@@ -109,14 +110,16 @@ function evictOldestIfNeeded(): void {
   }
 }
 
-function normalizeLogSession(log: CapturedLog): CapturedLog {
+function normalizeLog(log: CapturedLog): CapturedLog {
   const sessionId = getLogSessionId(log);
-  if (sessionId === log.sessionId) return log;
-  return { ...log, sessionId };
+  const pathFormat = apiFormatForPath(log.path);
+  const apiFormat = pathFormat === "unknown" ? log.apiFormat : pathFormat;
+  if (sessionId === log.sessionId && apiFormat === log.apiFormat) return log;
+  return { ...log, sessionId, apiFormat };
 }
 
 function addToCache(log: CapturedLog): void {
-  const cachedLog = normalizeLogSession(log);
+  const cachedLog = normalizeLog(log);
   // If updating an existing entry, remove first to reset insertion order
   if (memoryCache.has(cachedLog.id)) {
     memoryCache.delete(cachedLog.id);
@@ -174,12 +177,12 @@ export async function addTestLogEntry(entry: Omit<CapturedLog, "id">): Promise<C
     isTest: entry.isTest,
   });
 
-  const log: CapturedLog = {
+  const log: CapturedLog = normalizeLog({
     id,
     ...entry,
     sessionId: session.id,
     streamingChunksPath,
-  };
+  });
 
   await runWithLogWriteLock(async () => {
     const logFile = getCurrentLogFile();
@@ -218,7 +221,7 @@ export async function createLog(
     clientInfo,
   });
 
-  const log: CapturedLog = {
+  const log: CapturedLog = normalizeLog({
     id,
     timestamp: new Date().toISOString(),
     method,
@@ -249,7 +252,7 @@ export async function createLog(
     clientCwd: clientInfo?.cwd ?? null,
     clientProjectFolder: clientInfo?.projectFolder ?? null,
     streamingChunksPath: null,
-  };
+  });
 
   // Write to disk and update index
   await runWithLogWriteLock(async () => {
@@ -308,7 +311,7 @@ export async function getLogById(id: number): Promise<CapturedLog | null> {
         const parsed: unknown = JSON.parse(line);
         const result = CapturedLogSchema.safeParse(parsed);
         if (result.success) {
-          const log = normalizeLogSession(result.data);
+          const log = normalizeLog(result.data);
           addToCache(log);
           observeSessionLog(log);
           return log;
@@ -348,7 +351,7 @@ async function scanLogFileForId(filePath: string, id: number): Promise<CapturedL
         if (desc !== undefined && typeof desc.value === "number" && desc.value === id) {
           const result = CapturedLogSchema.safeParse(parsed);
           if (result.success) {
-            lastMatch = normalizeLogSession(result.data);
+            lastMatch = normalizeLog(result.data);
             if (result.data.responseStatus !== null) {
               return lastMatch;
             }
@@ -412,7 +415,7 @@ async function visitPersistedLogFile(
         const parsed: unknown = JSON.parse(line);
         const result = CapturedLogSchema.safeParse(parsed);
         if (result.success) {
-          const log = normalizeLogSession(result.data);
+          const log = normalizeLog(result.data);
           visitor(log);
         }
       } catch {

package/src/proxy/upstream.ts

@@ -18,7 +18,7 @@ export type ApiRoute = {
 };
 
 /**
- * Describes the protocol implied by the client-facing path.
+ * Describes the API route implied by the client-facing path.
  *
  * The path is the source of truth for request/response format. ProviderConfig.format
  * is only a fallback for old provider records that do not have a format-specific URL.

package/src/routes/api/logs.stream.ts

@@ -1,6 +1,6 @@
 import { createFileRoute } from "@tanstack/react-router";
 import { compactLogForList, onLogUpdate, getLogSessionId, listLogsPage } from "../../proxy/store";
-import { type CapturedLog } from "../../proxy/schemas";
+import { type CapturedLog } from "../../contracts";
 
 const INITIAL_STREAM_LOG_LIMIT = 100;
 

package/.output/public/assets/_sessionId-DurHDwM1.js

@@ -1 +0,0 @@
-import{R as s,j as e}from"./main-BVKRHBUl.js";import{P as i}from"./ProxyViewerContainer-C_Lq5T5V.js";function t(){const{sessionId:o}=s.useParams();return e.jsx(i,{initialSessionId:o},o)}export{t as component};

package/.output/public/assets/index-sGphugFR.js

@@ -1 +0,0 @@
-import{P as o}from"./ProxyViewerContainer-C_Lq5T5V.js";import"./main-BVKRHBUl.js";const r=o;export{r as component};