@tonyclaw/agent-inspector 2.0.37 → 2.0.39

package/src/components/ProxyViewer.tsx

@@ -11,7 +11,7 @@ import {
   Trash2,
 } from "lucide-react";
 
-import type { CapturedLog } from "../proxy/schemas";
+import type { CapturedLog } from "../contracts";
 import { exportLogsAsZip, type ExportMode } from "../lib/export-logs";
 import type { CaptureMode, TimeDisplayFormat } from "../lib/runtimeConfig";
 import { formatTimestampRange } from "../lib/timeDisplay";

package/src/components/ProxyViewerContainer.tsx

@@ -1,6 +1,6 @@
 import { useState, useEffect, useCallback, useRef, useMemo, type JSX } from "react";
 import { z } from "zod";
-import { CapturedLogSchema, type CapturedLog } from "../proxy/schemas";
+import { CapturedLogSchema, type CapturedLog } from "../contracts";
 import { useStripConfig } from "../lib/useStripConfig";
 import { OnboardingBanner } from "./OnboardingBanner";
 import { ProxyViewer } from "./ProxyViewer";

package/src/components/providers/ProviderForm.tsx

@@ -845,7 +845,7 @@ export function ProviderForm({ provider, onSubmit, onCancel }: ProviderFormProps
                   Anthropic Format
                 </button>
               </TooltipTrigger>
-              <TooltipContent>Anthropic Messages API protocol</TooltipContent>
+              <TooltipContent>Anthropic Messages API format</TooltipContent>
             </Tooltip>
           </TooltipProvider>
           <TooltipProvider>
@@ -863,7 +863,7 @@ export function ProviderForm({ provider, onSubmit, onCancel }: ProviderFormProps
                   OpenAI Format
                 </button>
               </TooltipTrigger>
-              <TooltipContent>OpenAI Chat Completions API protocol</TooltipContent>
+              <TooltipContent>OpenAI Chat Completions API format</TooltipContent>
             </Tooltip>
           </TooltipProvider>
         </div>

package/src/components/providers/SettingsDialog.tsx

@@ -293,6 +293,18 @@ function OnboardingSettingsTab(): JSX.Element {
         label: "Codex prompt",
         value: "Use the agent-inspector-onboard skill",
       },
+      {
+        id: "opencode-config",
+        label: "OpenCode config",
+        value: "agent-inspector onboard --opencode-only",
+      },
+      {
+        id: "opencode-status",
+        label: "OpenCode status",
+        value: "agent-inspector onboard --status --opencode-only",
+      },
+      { id: "opencode-verify", label: "OpenCode verify", value: "opencode mcp list" },
+      { id: "opencode-proxy", label: "OpenCode proxy", value: `LLM_BASE_URL=${origin}/proxy` },
       { id: "mcp", label: "MCP URL", value: `${origin}/api/mcp` },
       { id: "proxy", label: "Proxy URL", value: `${origin}/proxy` },
       { id: "anthropic", label: "Anthropic base", value: `ANTHROPIC_BASE_URL=${origin}/proxy` },
@@ -345,6 +357,24 @@ function OnboardingSettingsTab(): JSX.Element {
             instead. Configure only one entry for the same Inspector.
           </span>
         </div>
+        <div className="flex items-start gap-2">
+          <Check className="mt-0.5 size-3.5 text-emerald-500" />
+          <span>
+            OpenCode onboarding safely merges{" "}
+            <code className="rounded bg-muted px-1 py-0.5 font-mono text-[11px] text-foreground">
+              mcp.agent-inspector
+            </code>{" "}
+            into{" "}
+            <code className="rounded bg-muted px-1 py-0.5 font-mono text-[11px] text-foreground">
+              opencode.json
+            </code>
+            , then verify with{" "}
+            <code className="rounded bg-muted px-1 py-0.5 font-mono text-[11px] text-foreground">
+              opencode mcp list
+            </code>
+            .
+          </span>
+        </div>
         <div className="flex items-start gap-2">
           <Check className="mt-0.5 size-3.5 text-emerald-500" />
           <span>

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

@@ -29,7 +29,7 @@ import {
   type KnowledgeCandidate,
   type KnowledgeCandidateStatus,
 } from "../../knowledge/types";
-import type { CapturedLog } from "../../proxy/schemas";
+import type { CapturedLog } from "../../contracts";
 import { Badge } from "../ui/badge";
 import { Button } from "../ui/button";
 import { buildTraceSummary, extractToolTraceEvents, type TraceSummary } from "./viewerState";

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

@@ -13,7 +13,7 @@ import {
   X,
 } from "lucide-react";
 import { cn, formatTokens } from "../../lib/utils";
-import type { CapturedLog } from "../../proxy/schemas";
+import type { CapturedLog } from "../../contracts";
 import {
   type DiffOp,
   type JsonNode,

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

@@ -1,7 +1,7 @@
 import { useState, memo, useCallback, useEffect, useMemo } from "react";
 import type { JSX } from "react";
 import type { TimeDisplayFormat } from "../../lib/runtimeConfig";
-import type { CapturedLog } from "../../proxy/schemas";
+import type { CapturedLog } from "../../contracts";
 import {
   ConversationHeader,
   getGroupApiFormat,

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

@@ -1,6 +1,6 @@
 import { type JSX, useCallback, useEffect, useMemo, useState } from "react";
 import { useWindowVirtualizer } from "@tanstack/react-virtual";
-import type { CapturedLog } from "../../proxy/schemas";
+import type { CapturedLog } from "../../contracts";
 import { ConversationGroup, type ConversationGroupProps } from "./ConversationGroup";
 import type { ConversationGroupData } from "./ConversationHeader";
 import { LOG_FOCUS_REQUEST_EVENT, readLogFocusRequest } from "./logFocus";

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

@@ -15,7 +15,7 @@ import { getSessionPath } from "../../lib/sessionUrl";
 import type { TimeDisplayFormat } from "../../lib/runtimeConfig";
 import { formatTimestampRange } from "../../lib/timeDisplay";
 import { cn, formatTokens } from "../../lib/utils";
-import type { CapturedLog } from "../../proxy/schemas";
+import type { CapturedLog } from "../../contracts";
 import { Badge } from "../ui/badge";
 import { ConfirmDialog } from "../ui/confirm-dialog";
 import { resolveLogFormat } from "./log-formats";

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

@@ -1,7 +1,7 @@
 import { GitCompareArrows } from "lucide-react";
 import { Suspense, type JSX } from "react";
 import { useEffect, useMemo, useRef, useState, memo } from "react";
-import type { CapturedLog } from "../../proxy/schemas";
+import type { CapturedLog } from "../../contracts";
 import type { TimeDisplayFormat } from "../../lib/runtimeConfig";
 import { stripClaudeCodeBillingHeader } from "../../proxy/claudeCodeStrip";
 import { Button } from "../ui/button";

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

@@ -27,7 +27,7 @@ import { memo } from "react";
 import type { TimeDisplayFormat } from "../../lib/runtimeConfig";
 import { formatTimestamp } from "../../lib/timeDisplay";
 import { cn, formatTokens, getStatusCategory, type StatusCategory } from "../../lib/utils";
-import type { CapturedLog } from "../../proxy/schemas";
+import type { CapturedLog } from "../../contracts";
 import { Badge } from "../ui/badge";
 import { Button } from "../ui/button";
 import { ProviderLogo, detectProvider } from "../providers/ProviderLogo";

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

@@ -8,7 +8,7 @@ import { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider } from "../ui/
 import { Dialog, DialogContent, DialogHeader, DialogTitle } from "../ui/dialog";
 import { Tabs, TabsContent, TabsList, TabsTrigger } from "../ui/tabs";
 import { ResponseView } from "./ResponseView";
-import { CapturedLogSchema, type CapturedLog } from "../../proxy/schemas";
+import { CapturedLogSchema, type CapturedLog } from "../../contracts";
 import { dispatchLogFocusRequest } from "./logFocus";
 import {
   buildReplayComparisons,

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

@@ -3,7 +3,7 @@ import type { JSX } from "react";
 import { memo } from "react";
 import { useMemo } from "react";
 import { cn, formatTokens, getStatusCategory, type StatusCategory } from "../../lib/utils";
-import type { RequestFormat } from "../../proxy/schemas";
+import type { ApiFormat } from "../../contracts";
 import { AnswerMarkdown } from "./AnswerMarkdown";
 import { formatViewFor } from "./formats";
 import { getLogFormatAdapter } from "./log-formats";
@@ -16,7 +16,7 @@ export type ResponseViewProps = {
   outputTokens: number | null;
   cacheCreationInputTokens?: number | null;
   cacheReadInputTokens?: number | null;
-  apiFormat?: RequestFormat;
+  apiFormat?: ApiFormat;
   /** SSE error message from streaming response */
   error?: string | null;
 };

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

@@ -3,7 +3,7 @@ import { ChevronDown, ChevronRight, Loader2 } from "lucide-react";
 import { Badge } from "../ui/badge";
 import { JsonViewer } from "../ui/json-viewer";
 import { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider } from "../ui/tooltip";
-import type { StreamingChunk } from "../../proxy/schemas";
+import type { StreamingChunk } from "../../contracts";
 
 export type StreamingChunkSequenceProps = {
   logId: number;

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;
+}