@tonyclaw/agent-inspector 2.0.37 → 2.0.38

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

@@ -1,187 +1,14 @@
-import { z } from "zod";
-import { JsonValueSchema } from "../jsonSchema";
-
-// OpenAI Chat Completions Schemas
-
-export const OpenAIMessageContent = z.union([
-  z.string(),
-  z.array(
-    z.discriminatedUnion("type", [
-      z.object({ type: z.literal("text"), text: z.string() }),
-      z.object({
-        type: z.literal("image_url"),
-        image_url: z.object({ url: z.string(), detail: z.string().optional() }),
-      }),
-    ]),
-  ),
-]);
-
-export const OpenAIMessage = z.object({
-  role: z.enum(["system", "user", "assistant", "tool"]),
-  content: OpenAIMessageContent,
-  name: z.string().optional(),
-  reasoning_content: z.string().optional(),
-  thinking: z.string().optional(), // Some providers use 'thinking' field
-  think: z.string().optional(), // MiniMax uses 'think' field
-});
-
-export const OpenAIFunctionCall = z.object({
-  name: z.string(),
-  arguments: z.string(),
-});
-
-/** A single OpenAI tool_call (the modern multi-tool form, returned by most
- *  providers in `choices[].message.tool_calls`). `function.arguments` is
- *  a JSON-encoded string per the OpenAI spec — we keep it as a string at
- *  parse time and let the renderer decide whether to JSON-parse it for
- *  display. */
-export const OpenAIToolCallSchema = z.object({
-  index: z.number().optional(),
-  id: z.string().optional(),
-  type: z.literal("function").optional(),
-  function: z.object({
-    name: z.string().optional(),
-    arguments: z.string().optional(),
-  }),
-});
-
-export type OpenAIToolCall = z.infer<typeof OpenAIToolCallSchema>;
-
-const OpenAIMessageWithFunctionCall = OpenAIMessage.extend({
-  content: z
-    .union([z.string(), z.array(z.object({ type: z.literal("text"), text: z.string() }))])
-    .optional(),
-  function_call: OpenAIFunctionCall.optional(),
-  tool_calls: z.array(OpenAIToolCallSchema).optional(),
-});
-
-export const OpenAIToolDefinition = z.object({
-  type: z.literal("function"),
-  function: z.object({
-    name: z.string(),
-    description: z.string().optional(),
-    parameters: z.record(z.string(), JsonValueSchema),
-  }),
-});
-
-export const OpenAIRequestSchema = z.object({
-  model: z.string(),
-  messages: z.array(OpenAIMessage),
-  temperature: z.number().optional(),
-  max_tokens: z.number().optional(),
-  stream: z.boolean().optional(),
-  tools: z.array(OpenAIToolDefinition).optional(),
-  tool_choice: z
-    .union([
-      z.enum(["auto", "none", "required"]),
-      z.object({ type: z.literal("auto") }),
-      z.object({ type: z.literal("none") }),
-      z.object({ type: z.literal("function"), function: z.object({ name: z.string() }) }),
-    ])
-    .optional(),
-  user: z.string().optional(),
-});
-
-export const OpenAIChoiceDelta = z.object({
-  role: z.enum(["assistant"]).optional(),
-  content: z.string().nullable().optional(),
-  reasoning_content: z.string().nullable().optional(),
-  thinking: z.string().nullable().optional(), // Some providers use 'thinking' field
-  think: z.string().nullable().optional(), // MiniMax uses 'think' field
-  function_call: z
-    .object({ name: z.string().optional(), arguments: z.string().optional() })
-    .nullable()
-    .optional(),
-  tool_calls: z
-    .array(
-      z.object({
-        index: z.number(),
-        id: z.string().optional(),
-        type: z.literal("function").optional(),
-        function: z.object({
-          name: z.string().optional(),
-          arguments: z.string().optional(),
-        }),
-      }),
-    )
-    .nullable()
-    .optional(),
-});
-
-export const OpenAIChoice = z.object({
-  index: z.number(),
-  message: z
-    .object({
-      role: z.enum(["assistant"]),
-      content: z.string().nullable(),
-      reasoning_content: z.string().optional(),
-      thinking: z.string().optional(), // Some providers use 'thinking' field in message
-      think: z.string().optional(), // MiniMax uses 'think' field in message
-      function_call: z.object({ name: z.string(), arguments: z.string() }).nullable().optional(),
-      tool_calls: z.array(OpenAIToolCallSchema).optional(),
-    })
-    .optional(),
-  delta: OpenAIChoiceDelta.optional(),
-  finish_reason: z.string().nullable(),
-});
-
-export const OpenAIResponseSchema = z
-  .object({
-    id: z.string(),
-    object: z.literal("chat.completion"),
-    created: z.number(),
-    model: z.string(),
-    choices: z.array(OpenAIChoice),
-    usage: z
-      .object({
-        prompt_tokens: z.number().nullable().optional(),
-        completion_tokens: z.number().nullable().optional(),
-        total_tokens: z.number().nullable().optional(),
-      })
-      .passthrough(), // Allow extra fields like prompt_tokens_details, completion_tokens_details
-    service_tier: z.string().nullable().optional(),
-    system_fingerprint: z.string().nullable().optional(),
-  })
-  .passthrough(); // Allow extra fields like refusal, annotations, audio
-
-// Schema for actual OpenAI SSE chunk format (not wrapped in event/data)
-export const OpenAISSERawChunkSchema = z
-  .object({
-    id: z.string(),
-    object: z.literal("chat.completion.chunk"),
-    created: z.number(),
-    model: z.string(),
-    choices: z.array(
-      z.object({
-        index: z.number(),
-        delta: OpenAIChoiceDelta,
-        finish_reason: z.string().nullable().optional(),
-      }),
-    ),
-    usage: z
-      .object({
-        prompt_tokens: z.number().nullable().optional(),
-        completion_tokens: z.number().nullable().optional(),
-        total_tokens: z.number().nullable().optional(),
-      })
-      .passthrough()
-      .nullable()
-      .optional(),
-  })
-  .passthrough(); // Allow extra fields in chunks
-
-export type OpenAIResponse = z.infer<typeof OpenAIResponseSchema>;
-
-/**
- * Parse an OpenAI response body.
- */
-export function parseOpenAIResponse(rawBody: string): OpenAIResponse | null {
-  try {
-    const json: unknown = JSON.parse(rawBody);
-    const result = OpenAIResponseSchema.safeParse(json);
-    if (result.success) return result.data;
-    return null;
-  } catch {
-    return null;
-  }
-}
+export {
+  OpenAIChoice,
+  OpenAIChoiceDelta,
+  OpenAIFunctionCall,
+  OpenAIMessage,
+  OpenAIMessageContent,
+  OpenAIRequestSchema,
+  OpenAIResponseSchema,
+  OpenAISSERawChunkSchema,
+  OpenAIToolCallSchema,
+  OpenAIToolDefinition,
+  parseOpenAIResponse,
+} from "../../../contracts/openai";
+export type { OpenAIResponse, OpenAIToolCall } from "../../../contracts/openai";

package/src/proxy/formats/openai/zhipuProvider.ts

@@ -1,12 +1,12 @@
 import type { CapturedLog } from "../../schemas";
-import type { ProviderProtocol } from "../protocol";
+import type { ProviderAdapter } from "../providerAdapter";
 import { registry } from "../providers";
 import { extractOpenAIStream } from "./stream";
 
 const DEFAULT_ZHIPU_UPSTREAM = "https://open.bigmodel.cn/api/paas/v4";
 const ZHIPU_MODEL_PREFIXES = ["glm-", "charglm-", "cogview-", "embedding-", "rerank-"];
 
-export const zhipuProvider: ProviderProtocol = {
+export const zhipuProvider: ProviderAdapter = {
   name: "zhipu",
 
   matches(model: string): boolean {

package/src/proxy/formats/{protocol.ts → providerAdapter.ts}

@@ -1,12 +1,12 @@
-import type { CapturedLog, RequestFormat } from "../schemas";
+import type { ApiFormat, CapturedLog } from "../../contracts";
 
 /**
- * Provider Protocol Interface
+ * Provider Adapter Interface
  *
- * Defines the contract that all providers must implement to support
+ * Defines the contract that all provider adapters must implement to support
  * different LLM APIs (Anthropic, OpenAI, etc.).
  */
-export type ProviderProtocol = {
+export type ProviderAdapter = {
   /** Provider identifier (e.g., "anthropic", "openai") */
   name: string;
 
@@ -46,5 +46,5 @@ export type ProviderProtocol = {
    * @param apiFormat - Request format (anthropic/openai/unknown)
    * @returns Transformed body or null to use original
    */
-  transformRequest?(body: string, apiFormat: RequestFormat): string | null;
+  transformRequest?(body: string, apiFormat: ApiFormat): string | null;
 };

package/src/proxy/formats/providerRegistry.ts

@@ -1,4 +1,4 @@
-import type { ProviderProtocol } from "./protocol";
+import type { ProviderAdapter } from "./providerAdapter";
 
 /**
  * Provider Registry
@@ -7,13 +7,13 @@ import type { ProviderProtocol } from "./protocol";
  * Providers register themselves at module load time.
  */
 class ProviderRegistryImpl {
-  private providers: ProviderProtocol[] = [];
+  private providers: ProviderAdapter[] = [];
 
   /**
    * Register a provider with the registry.
    * @param provider - Provider implementation to register
    */
-  register(provider: ProviderProtocol): void {
+  register(provider: ProviderAdapter): void {
     this.providers.push(provider);
   }
 
@@ -22,8 +22,8 @@ class ProviderRegistryImpl {
    * @param model - Model name to match
    * @returns Matching provider or null if none found
    */
-  findProvider(model: string): ProviderProtocol | null {
-    let fallback: ProviderProtocol | null = null;
+  findProvider(model: string): ProviderAdapter | null {
+    let fallback: ProviderAdapter | null = null;
 
     for (const provider of this.providers) {
       if (provider.matches(model)) {
@@ -31,7 +31,7 @@ class ProviderRegistryImpl {
         if (provider.name !== "anthropic") {
           return provider;
         }
-        // Anthropic is the fallback — only use if nothing else matches
+        // Anthropic is the fallback; only use if nothing else matches
         fallback = provider;
       }
     }
@@ -42,7 +42,7 @@ class ProviderRegistryImpl {
    * Get all registered providers.
    * @returns Array of all registered providers
    */
-  getAll(): ProviderProtocol[] {
+  getAll(): ProviderAdapter[] {
     return [...this.providers];
   }
 }

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

@@ -1,3 +1,3 @@
 // Provider types and registry
-export type { ProviderProtocol } from "../protocol";
+export type { ProviderAdapter } from "../providerAdapter";
 export { registry } from "../providerRegistry";

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,14 +31,14 @@ class FormatRegistryImpl {
     return format === undefined ? undefined : this.handlers.get(format);
   }
 
-  /** Get the wire format matching a request path without requiring handlers. */
-  getFormatByPath(path: string): RequestFormat | undefined {
+  /** 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 format from request body content */
-  detectFormat(rawBody: string | null): RequestFormat {
+  /** 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;
@@ -58,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 formatRegistry.getFormatByPath(path) ?? "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,7 +34,7 @@ import type { SessionInfo, SessionLogSummary } from "../lib/sessionInfoContract"
 import { buildSessionInfo, buildSessionLogSummary } from "./sessionInfo";
 import type { CapturedLog } from "./schemas";
 import { CapturedLogSchema } from "./schemas";
-import { requestFormatForPath } from "./formats/registry";
+import { apiFormatForPath } from "./formats/registry";
 import {
   clearSessionRegistry,
   getLogSessionId,
@@ -112,7 +112,7 @@ function evictOldestIfNeeded(): void {
 
 function normalizeLog(log: CapturedLog): CapturedLog {
   const sessionId = getLogSessionId(log);
-  const pathFormat = requestFormatForPath(log.path);
+  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 };

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-7c9bsOFT.js

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

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

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