@tonyclaw/agent-inspector 2.0.36 → 2.0.38

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

@@ -1,235 +1,12 @@
-import { z } from "zod";
-import { JsonValueSchema } from "../jsonSchema";
-
-const CacheControl = z.object({
-  type: z.string(),
-  ttl: z.string().optional(),
-  scope: z.string().optional(),
-});
-
-const TextContentBlock = z.object({
-  type: z.literal("text"),
-  text: z.string(),
-  cache_control: CacheControl.optional(),
-});
-
-const ThinkingContentBlock = z.object({
-  type: z.literal("thinking"),
-  thinking: z.string(),
-  signature: z.string().optional(),
-});
-
-const ThinkContentBlock = z.object({
-  type: z.literal("think"),
-  thinking: z.string(),
-  signature: z.string().optional(),
-});
-
-const ImageSourceBlock = z.object({
-  type: z.literal("base64"),
-  media_type: z.string(),
-  data: z.string(),
-});
-
-const ImageContentBlock = z.object({
-  type: z.literal("image"),
-  source: ImageSourceBlock,
-});
-
-const ToolUseContentBlock = z.object({
-  type: z.literal("tool_use"),
-  id: z.string(),
-  name: z.string(),
-  input: z.record(z.string(), JsonValueSchema),
-});
-
-const ToolResultContentItem = z.discriminatedUnion("type", [TextContentBlock, ImageContentBlock]);
-
-const ToolResultContentBlock = z.object({
-  type: z.literal("tool_result"),
-  tool_use_id: z.string().optional(),
-  content: z.union([z.string(), z.array(ToolResultContentItem)]),
-  is_error: z.boolean().optional(),
-});
-
-const ContentBlock = z.discriminatedUnion("type", [
-  TextContentBlock,
-  ThinkingContentBlock,
-  ImageContentBlock,
-  ToolUseContentBlock,
-  ToolResultContentBlock,
-]);
-
-const MessageContent = z.union([z.string(), z.array(ContentBlock)]);
-
-const Message = z.object({
-  role: z.enum(["user", "assistant"]),
-  content: MessageContent,
-});
-
-const SystemBlock = z.object({
-  type: z.literal("text"),
-  text: z.string(),
-  cache_control: CacheControl.optional(),
-});
-
-const InputSchema = z.object({
-  type: z.string(),
-  properties: z.record(z.string(), z.record(z.string(), JsonValueSchema)).optional(),
-  required: z.array(z.string()).optional(),
-  additionalProperties: z.boolean().optional(),
-  $schema: z.string().optional(),
-});
-
-const ToolDefinition = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  input_schema: InputSchema.optional(),
-  cache_control: CacheControl.optional(),
-});
-
-const ThinkingConfig = z.discriminatedUnion("type", [
-  z.object({ type: z.literal("enabled"), budget_tokens: z.number() }),
-  z.object({ type: z.literal("disabled") }),
-  z.object({ type: z.literal("adaptive") }),
-]);
-
-export const AnthropicRequestSchema = z.object({
-  model: z.string(),
-  messages: z.array(Message),
-  system: z.array(SystemBlock).optional(),
-  tools: z.array(ToolDefinition).optional(),
-  max_tokens: z.number().optional(),
-  temperature: z.number().optional(),
-  stream: z.boolean().optional(),
-  thinking: ThinkingConfig.optional(),
-  metadata: z
-    .object({
-      user_id: z.string().optional(),
-    })
-    .optional(),
-});
-
-const ResponseContentBlock = z.discriminatedUnion("type", [
-  TextContentBlock,
-  ThinkingContentBlock,
-  ThinkContentBlock,
-  ToolUseContentBlock,
-]);
-
-const ResponseUsageSchema = z
-  .object({
-    input_tokens: z.number().nullable().optional(),
-    output_tokens: z.number().nullable().optional(),
-    cache_creation_input_tokens: z.number().nullable().optional(),
-    cache_read_input_tokens: z.number().nullable().optional(),
-  })
-  .passthrough(); // Allow extra fields from different providers
-
-export const AnthropicResponseSchema = z
-  .object({
-    id: z.string(),
-    type: z.literal("message"),
-    model: z.string(),
-    role: z.literal("assistant"),
-    content: z.array(ResponseContentBlock),
-    stop_reason: z.string().nullable(),
-    stop_sequence: z.string().nullable().optional(),
-    usage: ResponseUsageSchema,
-  })
-  .passthrough(); // Allow extra unknown fields
-
-const SseMessageStartEvent = z.object({
-  type: z.literal("message_start"),
-  message: z.object({
-    id: z.string(),
-    type: z.literal("message"),
-    model: z.string(),
-    role: z.literal("assistant"),
-    content: z.array(ResponseContentBlock),
-    stop_reason: z.null(),
-    stop_sequence: z.null(),
-    usage: z
-      .object({
-        input_tokens: z.number(),
-        cache_creation_input_tokens: z.number().optional(),
-        cache_read_input_tokens: z.number().optional(),
-      })
-      .passthrough(),
-  }),
-});
-
-const SseContentBlockStartEvent = z.object({
-  type: z.literal("content_block_start"),
-  index: z.number(),
-  content_block: ResponseContentBlock,
-});
-
-const SseDeltaBlock = z.discriminatedUnion("type", [
-  z.object({ type: z.literal("text_delta"), text: z.string() }),
-  z.object({ type: z.literal("input_json_delta"), partial_json: z.string() }),
-  z.object({ type: z.literal("thinking_delta"), thinking: z.string() }),
-  z.object({ type: z.literal("signature_delta"), signature: z.string() }),
-]);
-
-const SseContentBlockDeltaEvent = z.object({
-  type: z.literal("content_block_delta"),
-  index: z.number(),
-  delta: SseDeltaBlock,
-});
-
-const SseContentBlockStopEvent = z.object({
-  type: z.literal("content_block_stop"),
-  index: z.number(),
-});
-
-const SseMessageDeltaEvent = z.object({
-  type: z.literal("message_delta"),
-  delta: z.object({
-    stop_reason: z.string().nullable(),
-    stop_sequence: z.string().nullable().optional(),
-  }),
-  usage: z
-    .object({
-      output_tokens: z.number(),
-      input_tokens: z.number().optional(),
-      cache_creation_input_tokens: z.number().optional(),
-      cache_read_input_tokens: z.number().optional(),
-    })
-    .passthrough(),
-});
-
-const SseMessageStopEvent = z.object({
-  type: z.literal("message_stop"),
-});
-
-const SsePingEvent = z.object({
-  type: z.literal("ping"),
-});
-
-const SseErrorEvent = z.object({
-  type: z.literal("error"),
-  error: z.object({
-    type: z.string(),
-    message: z.string(),
-  }),
-});
-
-export const SseEventSchema = z.discriminatedUnion("type", [
-  SseMessageStartEvent,
-  SseContentBlockStartEvent,
-  SseContentBlockDeltaEvent,
-  SseContentBlockStopEvent,
-  SseMessageDeltaEvent,
-  SseMessageStopEvent,
-  SsePingEvent,
-  SseErrorEvent,
-]);
-
-export type AnthropicResponse = z.infer<typeof AnthropicResponseSchema>;
-export type ResponseContentBlockType = z.infer<typeof ResponseContentBlock>;
-
-// Backward-compatible aliases (originally named Inspector*)
-export const InspectorRequestSchema = AnthropicRequestSchema;
-export const InspectorResponseSchema = AnthropicResponseSchema;
-export type InspectorResponse = AnthropicResponse;
+export {
+  AnthropicRequestSchema,
+  AnthropicResponseSchema,
+  InspectorRequestSchema,
+  InspectorResponseSchema,
+  SseEventSchema,
+} from "../../../contracts/anthropic";
+export type {
+  AnthropicResponse,
+  InspectorResponse,
+  ResponseContentBlockType,
+} from "../../../contracts/anthropic";

package/src/proxy/formats/handler.ts

@@ -1,4 +1,4 @@
-import type { CapturedLog, RequestFormat, TokenUsage } from "../schemas";
+import type { ApiFormat, CapturedLog, TokenUsage } from "../schemas";
 
 /**
  * Structured result of parsing a raw request body.
@@ -17,7 +17,7 @@ export type ParsedRequest = {
  */
 export type FormatHandler = {
   /** The format identifier */
-  readonly format: RequestFormat;
+  readonly format: ApiFormat;
 
   /**
    * Parse a raw request body to extract model name and metadata.

package/src/proxy/formats/index.ts

@@ -9,5 +9,5 @@ import "./openai/zhipuProvider";
 import "./openai/alibabaProvider";
 
 export type { FormatHandler, ParsedRequest } from "./handler";
-export { formatRegistry, formatForPath, requestFormatForPath } from "./registry";
+export { apiFormatForPath, formatRegistry, formatForPath, requestFormatForPath } from "./registry";
 export { registry } from "./providers";

package/src/proxy/formats/jsonSchema.ts

@@ -1,36 +1,2 @@
-import { z } from "zod";
-
-/**
- * Shared JSON value type for streaming chunks.
- * Defined in a separate file to avoid circular dependencies.
- */
-export type JsonValue =
-  | string
-  | number
-  | boolean
-  | null
-  | JsonValue[]
-  | { [key: string]: JsonValue };
-
-export const JsonValueSchema: z.ZodType<JsonValue> = z.lazy(() =>
-  z.union([
-    z.string(),
-    z.number(),
-    z.boolean(),
-    z.null(),
-    z.array(JsonValueSchema),
-    z.record(z.string(), JsonValueSchema),
-  ]),
-);
-
-/**
- * Re-types a value as `JsonValue` without re-walking it. Use this ONLY when
- * the value has already been validated (e.g., via `SseEventSchema.safeParse`)
- * AND originated from `JSON.parse`. Skipping the recursive `JsonValueSchema`
- * walk avoids a second full-tree zod parse on every event of every streaming
- * response. Centralized here so the eslint-disable is one site, not two.
- */
-export function trustAsJsonValue<T>(value: T): JsonValue {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-  return value as unknown as JsonValue;
-}
+export { JsonValueSchema, trustAsJsonValue } from "../../contracts/json";
+export type { JsonValue } from "../../contracts/json";

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

@@ -1,5 +1,5 @@
 import type { CapturedLog } from "../../schemas";
-import type { ProviderProtocol } from "../protocol";
+import type { ProviderAdapter } from "../providerAdapter";
 import { registry } from "../providers";
 import { extractOpenAIStream } from "./stream";
 
@@ -8,7 +8,7 @@ const DEFAULT_ALIBABA_UPSTREAM = "https://dashscope.aliyuncs.com/compatible-mode
 /**
  * Alibaba Provider Implementation (DashScope)
  */
-export const alibabaProvider: ProviderProtocol = {
+export const alibabaProvider: ProviderAdapter = {
   name: "alibaba",
 
   matches(model: string): boolean {

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

@@ -1,5 +1,5 @@
 import type { CapturedLog } from "../../schemas";
-import type { ProviderProtocol } from "../protocol";
+import type { ProviderAdapter } from "../providerAdapter";
 import { registry } from "../providers";
 import { extractOpenAIStream } from "./stream";
 
@@ -8,7 +8,7 @@ const DEFAULT_OPENAI_UPSTREAM = "https://api.openai.com/v1";
 /**
  * OpenAI Provider Implementation
  */
-export const openaiProvider: ProviderProtocol = {
+export const openaiProvider: ProviderAdapter = {
   name: "openai",
 
   matches(model: string): boolean {

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";