@tonyclaw/agent-inspector 2.0.37 → 2.0.38

package/src/components/proxy-viewer/TurnGroup.tsx

@@ -3,7 +3,7 @@ import { AlertTriangle, ChevronRight, Clock, Zap } from "lucide-react";
 import { isTurnBoundary } from "../../lib/stopReason";
 import type { TimeDisplayFormat } from "../../lib/runtimeConfig";
 import { cn, formatTokens } from "../../lib/utils";
-import type { CapturedLog } from "../../proxy/schemas";
+import type { CapturedLog } from "../../contracts";
 import { getCrabVariant } from "../ui/crab-variants";
 import { ProviderLogo, detectProvider, type Provider } from "../providers/ProviderLogo";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "../ui/tooltip";

package/src/components/proxy-viewer/anatomy/sessionContextSummary.ts

@@ -1,5 +1,5 @@
 import type { ProviderConfig } from "../../../lib/providerContract";
-import type { CapturedLog } from "../../../proxy/schemas";
+import type { CapturedLog } from "../../../contracts";
 import { getLogFormatAdapter, resolveLogFormat } from "../log-formats";
 import {
   analyzeContextIntelligence,

package/src/components/proxy-viewer/formats/anthropic/ContentBlocks.tsx

@@ -1,6 +1,6 @@
 import { Brain, ChevronDown, ChevronRight, Terminal } from "lucide-react";
 import { type JSX, memo, useState } from "react";
-import type { ResponseContentBlockType } from "../../../../proxy/schemas";
+import type { ResponseContentBlockType } from "../../../../contracts/anthropic";
 import { AnswerMarkdown } from "../../AnswerMarkdown";
 import { Badge } from "../../../ui/badge";
 import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "../../../ui/collapsible";

package/src/components/proxy-viewer/formats/anthropic/ResponseView.tsx

@@ -1,6 +1,6 @@
 import { StopCircle, Zap } from "lucide-react";
 import { memo, type JSX } from "react";
-import type { InspectorResponse } from "../../../../proxy/schemas";
+import type { AnthropicResponse } from "../../../../contracts/anthropic";
 import { formatTokens } from "../../../../lib/utils";
 import { Badge } from "../../../ui/badge";
 import { Separator } from "../../../ui/separator";
@@ -9,7 +9,7 @@ import { ResponseContentBlockRenderer } from "./ContentBlocks";
 export const StructuredResponseViewAnthropic = memo(function StructuredResponseViewAnthropic({
   response,
 }: {
-  response: InspectorResponse;
+  response: AnthropicResponse;
 }): JSX.Element {
   return (
     <div className="space-y-3">

package/src/components/proxy-viewer/formats/index.tsx

@@ -1,5 +1,7 @@
 import type { JSX } from "react";
-import type { InspectorResponse, OpenAIResponse, RequestFormat } from "../../../proxy/schemas";
+import type { ApiFormat } from "../../../contracts";
+import type { AnthropicResponse } from "../../../contracts/anthropic";
+import type { OpenAIResponse } from "../../../contracts/openai";
 import { StructuredResponseViewAnthropic } from "./anthropic/ResponseView";
 import { OpenAIResponseView } from "./openai/ResponseView";
 
@@ -15,12 +17,12 @@ function isOpenAIResponse(response: unknown): response is OpenAIResponse {
   return isRecord(response) && response.object === "chat.completion";
 }
 
-function isAnthropicResponse(response: unknown): response is InspectorResponse {
+function isAnthropicResponse(response: unknown): response is AnthropicResponse {
   return isRecord(response) && response.type === "message" && Array.isArray(response.content);
 }
 
 export function formatViewFor(
-  apiFormat: RequestFormat | undefined,
+  apiFormat: ApiFormat | undefined,
   response: unknown,
 ): JSX.Element | null {
   if (apiFormat === "openai" && isOpenAIResponse(response)) {

package/src/components/proxy-viewer/formats/openai/ResponseView.tsx

@@ -1,6 +1,6 @@
 import { StopCircle, Terminal, Zap } from "lucide-react";
 import { memo, useState, type JSX } from "react";
-import type { OpenAIResponse, OpenAIToolCall } from "../../../../proxy/schemas";
+import type { OpenAIResponse, OpenAIToolCall } from "../../../../contracts/openai";
 import { formatTokens } from "../../../../lib/utils";
 import { AnswerMarkdown } from "../../AnswerMarkdown";
 import { Badge } from "../../../ui/badge";

package/src/components/proxy-viewer/log-formats/anthropic.ts

@@ -1,7 +1,4 @@
-import {
-  AnthropicRequestSchema,
-  AnthropicResponseSchema,
-} from "../../../proxy/formats/anthropic/schemas";
+import { AnthropicRequestSchema, AnthropicResponseSchema } from "../../../contracts/anthropic";
 import type { AnatomySegment } from "../anatomy/types";
 import { countCharacters, estimateTokens } from "../anatomy/tokenEstimate";
 import type { LogFormatAdapter } from "./types";

package/src/components/proxy-viewer/log-formats/index.ts

@@ -1,22 +1,22 @@
-import { requestFormatForPath } from "../../../proxy/formats";
-import type { CapturedLog, RequestFormat } from "../../../proxy/schemas";
+import { apiFormatForPath } from "../../../proxy/formats";
+import type { ApiFormat, CapturedLog } from "../../../contracts";
 import { anthropicLogFormatAdapter } from "./anthropic";
 import { openAILogFormatAdapter } from "./openai";
 import type { LogFormatAdapter } from "./types";
 import { unknownLogFormatAdapter } from "./unknown";
 
-const ADAPTERS: Record<RequestFormat, LogFormatAdapter> = {
+const ADAPTERS: Record<ApiFormat, LogFormatAdapter> = {
   anthropic: anthropicLogFormatAdapter,
   openai: openAILogFormatAdapter,
   unknown: unknownLogFormatAdapter,
 };
 
-export function getLogFormatAdapter(format: RequestFormat): LogFormatAdapter {
+export function getLogFormatAdapter(format: ApiFormat): LogFormatAdapter {
   return ADAPTERS[format];
 }
 
-export function resolveLogFormat(log: Pick<CapturedLog, "path" | "apiFormat">): RequestFormat {
-  const pathFormat = requestFormatForPath(log.path);
+export function resolveLogFormat(log: Pick<CapturedLog, "path" | "apiFormat">): ApiFormat {
+  const pathFormat = apiFormatForPath(log.path);
   return pathFormat === "unknown" ? log.apiFormat : pathFormat;
 }
 

package/src/components/proxy-viewer/log-formats/openai.ts

@@ -1,4 +1,4 @@
-import { OpenAIRequestSchema, parseOpenAIResponse } from "../../../proxy/formats/openai/schemas";
+import { OpenAIRequestSchema, parseOpenAIResponse } from "../../../contracts/openai";
 import type { AnatomySegment } from "../anatomy/types";
 import { countCharacters, estimateTokens } from "../anatomy/tokenEstimate";
 import type { LogFormatAdapter } from "./types";

package/src/components/proxy-viewer/log-formats/types.ts

@@ -1,4 +1,4 @@
-import type { RequestFormat } from "../../../proxy/schemas";
+import type { ApiFormat } from "../../../contracts";
 import type { AnatomySegment } from "../anatomy/types";
 
 export type RequestAnalysis = {
@@ -14,7 +14,7 @@ export type ResponseAnalysis = {
 };
 
 export type LogFormatAdapter = {
-  readonly format: RequestFormat;
+  readonly format: ApiFormat;
   analyzeRequest(rawBody: string | null): RequestAnalysis;
   analyzeResponse(responseText: string | null): ResponseAnalysis;
   /**

package/src/components/proxy-viewer/viewerState.ts

@@ -1,6 +1,6 @@
 import { extractStopReason, isTurnBoundary, type StopReason } from "../../lib/stopReason";
 import { safeGetOwnProperty } from "../../lib/objectUtils";
-import type { CapturedLog } from "../../proxy/schemas";
+import type { CapturedLog } from "../../contracts";
 import { resolveLogFormat } from "./log-formats";
 
 export type TurnEntry = {

package/src/contracts/anthropic.ts

@@ -0,0 +1,235 @@
+import { z } from "zod";
+import { JsonValueSchema } from "./json";
+
+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();
+
+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();
+
+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;

package/src/contracts/index.ts

@@ -0,0 +1,27 @@
+export { JsonValueSchema, trustAsJsonValue } from "./json";
+export type { JsonValue } from "./json";
+
+export { CapturedLogSchema, StreamingChunkSchema } from "./log";
+export type { ApiFormat, CapturedLog, RequestFormat, StreamingChunk, TokenUsage } from "./log";
+
+export {
+  AnthropicRequestSchema,
+  AnthropicResponseSchema,
+  SseEventSchema,
+} from "./anthropic";
+export type { AnthropicResponse, ResponseContentBlockType } from "./anthropic";
+
+export {
+  OpenAIChoice,
+  OpenAIChoiceDelta,
+  OpenAIFunctionCall,
+  OpenAIMessage,
+  OpenAIMessageContent,
+  OpenAIRequestSchema,
+  OpenAIResponseSchema,
+  OpenAISSERawChunkSchema,
+  OpenAIToolCallSchema,
+  OpenAIToolDefinition,
+  parseOpenAIResponse,
+} from "./openai";
+export type { OpenAIResponse, OpenAIToolCall } from "./openai";

package/src/contracts/json.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+
+/**
+ * Shared JSON value type for API payload fragments and streaming chunks.
+ */
+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 and originated from `JSON.parse`.
+ */
+export function trustAsJsonValue<T>(value: T): JsonValue {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  return value as unknown as JsonValue;
+}

package/src/contracts/log.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { JsonValueSchema } from "./json";
+
+export type ApiFormat = "anthropic" | "openai" | "unknown";
+export type RequestFormat = ApiFormat;
+
+/**
+ * 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;
+};