@tonyclaw/agent-inspector 2.1.13 → 2.1.15

package/src/components/ui/json-viewer.tsx

@@ -1,6 +1,5 @@
 import { Check, ChevronDown, ChevronRight, ChevronsDown, Copy } from "lucide-react";
 import { type JSX, memo, useEffect, useMemo, useState } from "react";
-import ReactMarkdown from "react-markdown";
 import { copyTextToClipboard } from "../../lib/clipboard";
 import { cn } from "../../lib/utils";
 import { Button } from "./button";
@@ -46,6 +45,10 @@ function getEntries(value: JsonValue): ReadonlyArray<readonly [string, JsonValue
 
 const STRING_TRUNCATE_LIMIT = 120;
 
+function JsonStringText({ text }: { text: string }): JSX.Element {
+  return <span className="whitespace-pre-wrap break-words">{text}</span>;
+}
+
 function StringValue({ text }: { text: string }): JSX.Element {
   const [expanded, setExpanded] = useState(false);
   const isLong = text.length > STRING_TRUNCATE_LIMIT;
@@ -54,9 +57,7 @@ function StringValue({ text }: { text: string }): JSX.Element {
     return (
       <span className="text-emerald-400 break-all">
         &quot;
-        <span className="prose prose-sm dark:prose-invert inline max-w-none [&_p]:inline [&_p]:my-0 [&_code]:text-emerald-300 [&_a]:text-emerald-300">
-          <ReactMarkdown>{text}</ReactMarkdown>
-        </span>
+        <JsonStringText text={text} />
         &quot;
       </span>
     );
@@ -67,7 +68,7 @@ function StringValue({ text }: { text: string }): JSX.Element {
       &quot;
       {expanded ? (
         <span
-          className="cursor-pointer prose prose-sm dark:prose-invert inline max-w-none [&_p]:inline [&_p]:my-0 [&_code]:text-emerald-300 [&_a]:text-emerald-300"
+          className="cursor-pointer"
           onClick={(e) => {
             e.stopPropagation();
             setExpanded(false);
@@ -81,7 +82,7 @@ function StringValue({ text }: { text: string }): JSX.Element {
           role="button"
           tabIndex={0}
         >
-          <ReactMarkdown>{text}</ReactMarkdown>
+          <JsonStringText text={text} />
         </span>
       ) : (
         <Tooltip delayDuration={300}>
@@ -93,14 +94,14 @@ function StringValue({ text }: { text: string }): JSX.Element {
             className="text-left cursor-pointer"
           >
             <span>{text.slice(0, STRING_TRUNCATE_LIMIT)}</span>
-            <span className="text-emerald-400/50">…</span>
+            <span className="text-emerald-400/50">...</span>
           </TooltipTrigger>
           <TooltipContent
             side="bottom"
             className="max-w-md text-xs p-2 break-words whitespace-pre-wrap"
           >
             {text.slice(0, 500)}
-            {text.length > 500 ? "…" : ""}
+            {text.length > 500 ? "..." : ""}
           </TooltipContent>
         </Tooltip>
       )}

package/src/contracts/index.ts

@@ -31,10 +31,24 @@ export {
   OpenAIMessage,
   OpenAIMessageContent,
   OpenAIRequestSchema,
+  OpenAIResponsesRequestSchema,
+  OpenAIResponsesResponseSchema,
+  OpenAIResponsesSSEventSchema,
+  OpenAIResponsesToolDefinition,
+  OpenAIResponsesUsageSchema,
+  OpenAIResponsesOutputItemSchema,
   OpenAIResponseSchema,
   OpenAISSERawChunkSchema,
   OpenAIToolCallSchema,
   OpenAIToolDefinition,
+  parseOpenAIResponsesResponse,
   parseOpenAIResponse,
 } from "./openai";
-export type { OpenAIResponse, OpenAIToolCall } from "./openai";
+export type {
+  OpenAIResponse,
+  OpenAIResponsesRequest,
+  OpenAIResponsesResponse,
+  OpenAIResponsesSSEvent,
+  OpenAIResponsesOutputItem,
+  OpenAIToolCall,
+} from "./openai";

package/src/contracts/openai.ts

@@ -75,6 +75,37 @@ export const OpenAIRequestSchema = z.object({
   user: z.string().optional(),
 });
 
+export const OpenAIResponsesToolDefinition = z
+  .object({
+    type: z.string(),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    parameters: JsonValueSchema.optional(),
+    function: z
+      .object({
+        name: z.string().optional(),
+        description: z.string().optional(),
+        parameters: JsonValueSchema.optional(),
+      })
+      .optional(),
+  })
+  .passthrough();
+
+export const OpenAIResponsesRequestSchema = z
+  .object({
+    model: z.string(),
+    input: z.unknown().optional(),
+    instructions: z.union([z.string(), z.null()]).optional(),
+    stream: z.boolean().optional(),
+    tools: z.array(OpenAIResponsesToolDefinition).optional(),
+    tool_choice: z.unknown().optional(),
+    max_output_tokens: z.number().optional(),
+    temperature: z.number().optional(),
+    user: z.string().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+  })
+  .passthrough();
+
 export const OpenAIChoiceDelta = z.object({
   role: z.enum(["assistant"]).optional(),
   content: z.string().nullable().optional(),
@@ -162,7 +193,59 @@ export const OpenAISSERawChunkSchema = z
   })
   .passthrough();
 
+export const OpenAIResponsesUsageSchema = z
+  .object({
+    input_tokens: z.number().nullable().optional(),
+    output_tokens: z.number().nullable().optional(),
+    total_tokens: z.number().nullable().optional(),
+    input_tokens_details: z
+      .object({
+        cached_tokens: z.number().nullable().optional(),
+      })
+      .passthrough()
+      .nullable()
+      .optional(),
+    output_tokens_details: z
+      .object({
+        reasoning_tokens: z.number().nullable().optional(),
+      })
+      .passthrough()
+      .nullable()
+      .optional(),
+  })
+  .passthrough();
+
+export const OpenAIResponsesOutputItemSchema = z
+  .object({
+    type: z.string(),
+  })
+  .passthrough();
+
+export const OpenAIResponsesResponseSchema = z
+  .object({
+    id: z.string(),
+    object: z.literal("response").optional(),
+    created_at: z.number().optional(),
+    status: z.string().nullable().optional(),
+    model: z.string().optional(),
+    output: z.array(OpenAIResponsesOutputItemSchema).optional(),
+    output_text: z.string().optional(),
+    usage: OpenAIResponsesUsageSchema.nullable().optional(),
+    error: z.unknown().optional(),
+  })
+  .passthrough();
+
+export const OpenAIResponsesSSEventSchema = z
+  .object({
+    type: z.string(),
+  })
+  .passthrough();
+
 export type OpenAIResponse = z.infer<typeof OpenAIResponseSchema>;
+export type OpenAIResponsesRequest = z.infer<typeof OpenAIResponsesRequestSchema>;
+export type OpenAIResponsesResponse = z.infer<typeof OpenAIResponsesResponseSchema>;
+export type OpenAIResponsesSSEvent = z.infer<typeof OpenAIResponsesSSEventSchema>;
+export type OpenAIResponsesOutputItem = z.infer<typeof OpenAIResponsesOutputItemSchema>;
 
 export function parseOpenAIResponse(rawBody: string): OpenAIResponse | null {
   try {
@@ -174,3 +257,14 @@ export function parseOpenAIResponse(rawBody: string): OpenAIResponse | null {
     return null;
   }
 }
+
+export function parseOpenAIResponsesResponse(rawBody: string): OpenAIResponsesResponse | null {
+  try {
+    const json: unknown = JSON.parse(rawBody);
+    const result = OpenAIResponsesResponseSchema.safeParse(json);
+    if (result.success) return result.data;
+    return null;
+  } catch {
+    return null;
+  }
+}

package/src/lib/providerContract.ts

@@ -25,6 +25,7 @@ export const ProviderConfigSchema = z.object({
   baseUrl: z.string().optional(),
   anthropicBaseUrl: z.string().optional(),
   openaiBaseUrl: z.string().optional(),
+  openaiResponsesBaseUrl: z.string().optional(),
   authHeader: z.enum(["bearer", "x-api-key"]).optional().default("bearer"),
   apiDocsUrl: z.string().optional(),
   modelMetadataUrl: z.string().optional(),

package/src/lib/providerModelMetadata.ts

@@ -81,7 +81,7 @@ export const BUILTIN_PROVIDER_MODEL_REGISTRY: ProviderModelRegistry = {
     {
       name: "MiniMax",
       aliases: ["minimax"],
-      baseUrls: ["https://api.minimaxi.com/anthropic"],
+      baseUrls: ["https://api.minimaxi.com/anthropic", "https://api.minimaxi.com"],
       models: [
         {
           id: "MiniMax M3",
@@ -245,6 +245,12 @@ function providerBaseUrls(provider: ProviderConfig): string[] {
   if (provider.openaiBaseUrl !== undefined && provider.openaiBaseUrl.trim() !== "") {
     urls.push(provider.openaiBaseUrl);
   }
+  if (
+    provider.openaiResponsesBaseUrl !== undefined &&
+    provider.openaiResponsesBaseUrl.trim() !== ""
+  ) {
+    urls.push(provider.openaiResponsesBaseUrl);
+  }
   if (provider.baseUrl !== undefined && provider.baseUrl.trim() !== "") {
     urls.push(provider.baseUrl);
   }

package/src/lib/sessionInfoContract.ts

@@ -10,6 +10,7 @@ export const SessionTokenUsageSchema = z.object({
 
 export const SessionLogSummarySchema = z.object({
   id: z.number().int().positive(),
+  sessionLogNumber: z.number().int().positive().optional(),
   timestamp: z.string(),
   provider: z.string().nullable(),
   model: z.string().nullable(),

package/src/lib/stopReason.ts

@@ -1,11 +1,41 @@
 import type { CapturedLog } from "../contracts";
 
-export type StopReason = "end_turn" | "tool_use" | "stop" | null;
+export type StopReason = "end_turn" | "tool_use" | "stop" | "length" | null;
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+function normalizeAnthropicStopReason(value: string): StopReason {
+  switch (value) {
+    case "end_turn":
+    case "tool_use":
+      return value;
+    default:
+      return null;
+  }
+}
+
+function normalizeOpenAIFinishReason(value: string): StopReason {
+  switch (value) {
+    case "stop":
+    case "length":
+      return value;
+    default:
+      return null;
+  }
+}
+
+function isResponsesLengthLimitReason(value: string): boolean {
+  switch (value) {
+    case "max_output_tokens":
+    case "max_tokens":
+      return true;
+    default:
+      return false;
+  }
+}
+
 /**
  * Extracts the stop/finish reason from a captured log's response text.
  * Detects the response body shape (Anthropic or OpenAI) independently of
@@ -26,21 +56,35 @@ export function extractStopReason(log: CapturedLog): StopReason {
 
     // Anthropic shape: { stop_reason: "end_turn" | "tool_use" | ... }
     if (typeof json.stop_reason === "string") {
-      if (json.stop_reason === "end_turn" || json.stop_reason === "tool_use") {
-        return json.stop_reason;
+      return normalizeAnthropicStopReason(json.stop_reason);
+    }
+
+    // OpenAI Chat shape: { choices: [{ finish_reason: "stop" | "length" | ... }] }
+    if (Array.isArray(json.choices)) {
+      for (const choice of json.choices) {
+        if (!isRecord(choice) || typeof choice.finish_reason !== "string") continue;
+        const reason = normalizeOpenAIFinishReason(choice.finish_reason);
+        if (reason !== null) return reason;
       }
-      return null;
     }
 
-    // OpenAI shape: { choices: [{ finish_reason: "stop" | ... }] }
-    if (
-      Array.isArray(json.choices) &&
-      json.choices.length > 0 &&
-      isRecord(json.choices[0]) &&
-      typeof json.choices[0].finish_reason === "string" &&
-      json.choices[0].finish_reason === "stop"
-    ) {
-      return "stop";
+    // OpenAI Responses shape: { status: "completed", output: [...] }
+    if (Array.isArray(json.output)) {
+      for (const item of json.output) {
+        if (isRecord(item) && item.type === "function_call") {
+          return "tool_use";
+        }
+      }
+      if (json.status === "completed") {
+        return "stop";
+      }
+    }
+
+    if (json.status === "incomplete" && isRecord(json.incomplete_details)) {
+      const reason = json.incomplete_details.reason;
+      if (typeof reason === "string" && isResponsesLengthLimitReason(reason)) {
+        return "length";
+      }
     }
 
     return null;
@@ -51,8 +95,8 @@ export function extractStopReason(log: CapturedLog): StopReason {
 
 /**
  * Returns true when the stop reason indicates the assistant completed its
- * turn naturally (Anthropic end_turn or OpenAI stop).
+ * turn, including responses truncated by output length limits.
  */
 export function isTurnBoundary(stopReason: StopReason): boolean {
-  return stopReason === "end_turn" || stopReason === "stop";
+  return stopReason === "end_turn" || stopReason === "stop" || stopReason === "length";
 }

package/src/lib/upstreamUrl.ts

@@ -0,0 +1,46 @@
+export const PATH_V1_CHAT_COMPLETIONS = "/v1/chat/completions";
+export const PATH_V1_RESPONSES = "/v1/responses";
+
+export function buildUpstreamUrl(upstreamBase: string, normalizedPath: string): string {
+  const base = upstreamBase.endsWith("/") ? upstreamBase.slice(0, -1) : upstreamBase;
+  const endpointPath = normalizedPath.split("?")[0] ?? normalizedPath;
+  const queryIndex = normalizedPath.indexOf("?");
+  const search = queryIndex >= 0 ? normalizedPath.slice(queryIndex) : "";
+
+  // Some providers expose a format-specific URL as the exact endpoint rather
+  // than a base URL. Keep existing configs with exact endpoints compatible.
+  if (endpointPath !== "" && base.endsWith(endpointPath)) {
+    return base + search;
+  }
+
+  if (isZhipuVersionedOpenAIBase(base) && isVersionedChatCompletionsPath(normalizedPath)) {
+    return base + normalizedPath.slice(3);
+  }
+
+  // Many OpenAI-compatible base URLs already include /v1. Avoid producing /v1/v1.
+  if (base.endsWith("/v1") && normalizedPath.startsWith("/v1/")) {
+    return base + normalizedPath.slice(3);
+  }
+  return base + normalizedPath;
+}
+
+function isVersionedChatCompletionsPath(normalizedPath: string): boolean {
+  return (
+    normalizedPath === PATH_V1_CHAT_COMPLETIONS ||
+    normalizedPath.startsWith(`${PATH_V1_CHAT_COMPLETIONS}?`) ||
+    normalizedPath.startsWith(`${PATH_V1_CHAT_COMPLETIONS}/`)
+  );
+}
+
+function isZhipuVersionedOpenAIBase(base: string): boolean {
+  try {
+    const parsed = new URL(base);
+    const path = parsed.pathname.replace(/\/+$/, "");
+    return (
+      parsed.hostname === "open.bigmodel.cn" &&
+      (path === "/api/paas/v4" || path === "/api/coding/paas/v4")
+    );
+  } catch {
+    return false;
+  }
+}

package/src/mcp/previewExtractor.ts

@@ -19,12 +19,20 @@
  *   - the relevant content is non-text (e.g., image-only multimodal block)
  */
 
+import { z } from "zod";
 import type { CapturedLog } from "../contracts";
 import { AnthropicRequestSchema, AnthropicResponseSchema } from "../contracts/anthropic";
-import { OpenAIRequestSchema, OpenAIResponseSchema } from "../contracts/openai";
+import {
+  OpenAIRequestSchema,
+  OpenAIResponseSchema,
+  OpenAIResponsesRequestSchema,
+  OpenAIResponsesResponseSchema,
+} from "../contracts/openai";
+import { safeGetOwnProperty } from "../lib/objectUtils";
 
 /** Preview length cap, per design D5. */
 const PREVIEW_MAX_CHARS = 500;
+const UnknownArraySchema = z.array(z.unknown());
 
 function truncate(text: string): string {
   return text.length <= PREVIEW_MAX_CHARS ? text : text.slice(0, PREVIEW_MAX_CHARS);
@@ -68,6 +76,58 @@ function firstOpenAIText(
   return null;
 }
 
+function firstResponsesInputText(input: unknown): string | null {
+  if (typeof input === "string") return input.length > 0 ? input : null;
+  const parsedInput = UnknownArraySchema.safeParse(input);
+  if (!parsedInput.success) return null;
+  for (let i = parsedInput.data.length - 1; i >= 0; i--) {
+    const item = parsedInput.data[i];
+    const role = safeGetOwnProperty(item, "role");
+    if (role !== "user" && role !== undefined) continue;
+    const directText = safeGetOwnProperty(item, "text");
+    if (typeof directText === "string" && directText.length > 0) return directText;
+    const content = safeGetOwnProperty(item, "content");
+    if (typeof content === "string" && content.length > 0) return content;
+    if (Array.isArray(content)) {
+      for (const part of content) {
+        const type = safeGetOwnProperty(part, "type");
+        const text = safeGetOwnProperty(part, "text");
+        if (
+          (type === "input_text" || type === "text") &&
+          typeof text === "string" &&
+          text.length > 0
+        ) {
+          return text;
+        }
+      }
+    }
+  }
+  return null;
+}
+
+function firstResponsesOutputText(response: unknown): string | null {
+  const outputText = safeGetOwnProperty(response, "output_text");
+  if (typeof outputText === "string" && outputText.length > 0) return outputText;
+  const output = safeGetOwnProperty(response, "output");
+  if (!Array.isArray(output)) return null;
+  for (const item of output) {
+    const content = safeGetOwnProperty(item, "content");
+    if (!Array.isArray(content)) continue;
+    for (const part of content) {
+      const type = safeGetOwnProperty(part, "type");
+      const text = safeGetOwnProperty(part, "text");
+      if (
+        (type === "output_text" || type === "text") &&
+        typeof text === "string" &&
+        text.length > 0
+      ) {
+        return text;
+      }
+    }
+  }
+  return null;
+}
+
 /**
  * Extract a 500-char preview of the last `role: "user"` message's first text
  * block. Returns `null` for unknown format, parse failures, or non-text
@@ -100,7 +160,12 @@ export function extractLastUserMessagePreview(log: CapturedLog): string | null {
 
   if (log.apiFormat === "openai") {
     const parsed = OpenAIRequestSchema.safeParse(json);
-    if (!parsed.success) return null;
+    if (!parsed.success) {
+      const responsesParsed = OpenAIResponsesRequestSchema.safeParse(json);
+      if (!responsesParsed.success) return null;
+      const text = firstResponsesInputText(responsesParsed.data.input);
+      return text === null ? null : truncate(text);
+    }
     for (let i = parsed.data.messages.length - 1; i >= 0; i--) {
       const msg = parsed.data.messages[i];
       if (msg && msg.role === "user") {
@@ -143,7 +208,12 @@ export function extractResponsePreview(log: CapturedLog): string | null {
 
   if (log.apiFormat === "openai") {
     const parsed = OpenAIResponseSchema.safeParse(json);
-    if (!parsed.success) return null;
+    if (!parsed.success) {
+      const responsesParsed = OpenAIResponsesResponseSchema.safeParse(json);
+      if (!responsesParsed.success) return null;
+      const text = firstResponsesOutputText(responsesParsed.data);
+      return text === null ? null : truncate(text);
+    }
     // Pick the first choice that actually carries a text-like content.
     for (const choice of parsed.data.choices) {
       const msg = choice.message;

package/src/mcp/server.ts

@@ -1057,6 +1057,7 @@ function registerTools(server: McpServer): void {
         model: z.string().min(1),
         anthropicBaseUrl: z.string().optional(),
         openaiBaseUrl: z.string().optional(),
+        openaiResponsesBaseUrl: z.string().optional(),
         authHeader: z.enum(["bearer", "x-api-key"]).optional(),
         apiDocsUrl: z.string().optional(),
       }),
@@ -1081,6 +1082,7 @@ PATCH-style update: only the fields you supply are changed. Returns the updated
         authHeader: z.enum(["bearer", "x-api-key"]).optional(),
         anthropicBaseUrl: z.string().optional(),
         openaiBaseUrl: z.string().optional(),
+        openaiResponsesBaseUrl: z.string().optional(),
         apiDocsUrl: z.string().optional(),
       }),
     },

package/src/mcp/toolHandlers.ts

@@ -719,6 +719,7 @@ export type AddProviderInput = {
   model: string;
   anthropicBaseUrl?: string;
   openaiBaseUrl?: string;
+  openaiResponsesBaseUrl?: string;
   authHeader?: "bearer" | "x-api-key";
   apiDocsUrl?: string;
 };
@@ -746,6 +747,7 @@ export type UpdateProviderInput = {
   authHeader?: "bearer" | "x-api-key";
   anthropicBaseUrl?: string;
   openaiBaseUrl?: string;
+  openaiResponsesBaseUrl?: string;
   apiDocsUrl?: string;
 };
 

package/src/proxy/constants.ts

@@ -9,6 +9,8 @@ export const PROXY_IDENTITY = process.env["PROXY_IDENTITY"] ?? "inspector9527@To
 // API paths
 export const PATH_V1_CHAT_COMPLETIONS = "/v1/chat/completions";
 export const PATH_CHAT_COMPLETIONS = "/chat/completions";
+export const PATH_V1_RESPONSES = "/v1/responses";
+export const PATH_RESPONSES = "/responses";
 export const PATH_V1_MESSAGES = "/v1/messages";
 
 // Header names

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

@@ -1,8 +1,22 @@
 import type { FormatHandler, ParsedRequest } from "../handler";
 import type { CapturedLog, TokenUsage } from "../../schemas";
-import { OpenAIRequestSchema, OpenAIResponseSchema, parseOpenAIResponse } from "./schemas";
+import {
+  OpenAIRequestSchema,
+  OpenAIResponsesRequestSchema,
+  parseOpenAIResponsesResponse,
+  parseOpenAIResponse,
+} from "./schemas";
 import { extractOpenAIStream } from "./stream";
 
+function emptyTokens(): TokenUsage {
+  return {
+    inputTokens: null,
+    outputTokens: null,
+    cacheCreationInputTokens: null,
+    cacheReadInputTokens: null,
+  };
+}
+
 export const OpenAIFormatHandler: FormatHandler = {
   format: "openai",
 
@@ -16,6 +30,13 @@ export const OpenAIFormatHandler: FormatHandler = {
           sessionId: headers?.get("x-session-affinity") ?? null,
         };
       }
+      const responsesResult = OpenAIResponsesRequestSchema.safeParse(json);
+      if (responsesResult.success) {
+        return {
+          model: responsesResult.data.model,
+          sessionId: headers?.get("x-session-affinity") ?? null,
+        };
+      }
       return null;
     } catch {
       return null;
@@ -62,12 +83,17 @@ export const OpenAIFormatHandler: FormatHandler = {
         cacheReadInputTokens,
       };
     }
-    return {
-      inputTokens: null,
-      outputTokens: null,
-      cacheCreationInputTokens: null,
-      cacheReadInputTokens: null,
-    };
+    const responsesParsed = parseOpenAIResponsesResponse(responseBody);
+    if (responsesParsed !== null) {
+      const usage = responsesParsed.usage;
+      return {
+        inputTokens: usage?.input_tokens ?? null,
+        outputTokens: usage?.output_tokens ?? null,
+        cacheCreationInputTokens: null,
+        cacheReadInputTokens: usage?.input_tokens_details?.cached_tokens ?? null,
+      };
+    }
+    return emptyTokens();
   },
 
   extractStream(
@@ -85,8 +111,13 @@ export const OpenAIFormatHandler: FormatHandler = {
       const json: unknown = JSON.parse(rawBody);
       if (typeof json === "object" && json !== null && !Array.isArray(json)) {
         const keys = Object.keys(json);
-        // OpenAI has `model` and `messages` at the top level, but NOT `system`
-        return keys.includes("model") && keys.includes("messages") && !keys.includes("system");
+        // OpenAI has `model` and either Chat `messages` or Responses `input`,
+        // but not Anthropic's top-level `system`.
+        return (
+          keys.includes("model") &&
+          (keys.includes("messages") || keys.includes("input")) &&
+          !keys.includes("system")
+        );
       }
       return false;
     } catch {

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

@@ -9,8 +9,15 @@ export {
   OpenAIMessage,
   OpenAIMessageContent,
   OpenAIToolDefinition,
+  OpenAIResponsesRequestSchema,
+  OpenAIResponsesResponseSchema,
+  OpenAIResponsesSSEventSchema,
+  OpenAIResponsesToolDefinition,
+  OpenAIResponsesUsageSchema,
+  OpenAIResponsesOutputItemSchema,
   OpenAIChoice,
   OpenAIChoiceDelta,
+  parseOpenAIResponsesResponse,
   parseOpenAIResponse,
 } from "./schemas";
 

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

@@ -5,10 +5,24 @@ export {
   OpenAIMessage,
   OpenAIMessageContent,
   OpenAIRequestSchema,
+  OpenAIResponsesRequestSchema,
+  OpenAIResponsesResponseSchema,
+  OpenAIResponsesSSEventSchema,
+  OpenAIResponsesToolDefinition,
+  OpenAIResponsesUsageSchema,
+  OpenAIResponsesOutputItemSchema,
   OpenAIResponseSchema,
   OpenAISSERawChunkSchema,
   OpenAIToolCallSchema,
   OpenAIToolDefinition,
+  parseOpenAIResponsesResponse,
   parseOpenAIResponse,
 } from "../../../contracts/openai";
-export type { OpenAIResponse, OpenAIToolCall } from "../../../contracts/openai";
+export type {
+  OpenAIResponse,
+  OpenAIResponsesRequest,
+  OpenAIResponsesResponse,
+  OpenAIResponsesSSEvent,
+  OpenAIResponsesOutputItem,
+  OpenAIToolCall,
+} from "../../../contracts/openai";