@springbrand/agent-runtime 0.3.0-alpha.2 → 0.3.0-alpha.21

package/src/models/index.ts

@@ -2,6 +2,7 @@ import type { StreamFn } from "@earendil-works/pi-agent-core";
 import {
   createModels,
   createProvider,
+  getCurrentSystemPrompt,
   isRetryableAssistantError,
   lazyStream,
   type Api,
@@ -11,6 +12,8 @@ import {
   type Model,
   type MutableModels,
   type ProviderStreams,
+  type SimpleStreamOptions,
+  type TranscriptContext,
 } from "@earendil-works/pi-ai";
 import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
 import {
@@ -38,23 +41,32 @@ import {
   openaiCodexProvider,
 } from "@earendil-works/pi-ai/providers/openai-codex";
 import {
-  cloudflareStreams,
+  resolveCloudflareModel,
 } from "@earendil-works/pi-ai/providers/cloudflare-stream";
 import {
   ChatStreamStalledError,
 } from "agents/chat";
 import type {
   RuntimeModelEndpoint,
+  RuntimeModelMetadata,
   RuntimeModelInputModality,
   RuntimeModelProtocol,
   RuntimeProviderPort,
 } from "../config/ports";
 import { modelInputMessages } from "../conversation/message/model-input";
 import { openRouterMessagesApi } from "./openrouter/messages";
+import { openRouterChatApi, openRouterResponsesApi } from "./openrouter/openai";
+import { withModelProtocolResponse } from "./openrouter/protocol-response";
+import {
+  overlayProviderStreams,
+  remapProviderStreamModels,
+} from "./provider-streams";
 
 const CATALOGS = {
   "openai-chat": openaiProvider().getModels(),
   "openrouter-messages": openrouterProvider().getModels(),
+  "openrouter-chat": openrouterProvider().getModels(),
+  "openrouter-responses": openrouterProvider().getModels(),
   "anthropic-messages": anthropicProvider().getModels(),
   "google-generative-ai": googleProvider().getModels(),
   "openai-codex-responses": openaiCodexProvider().getModels(),
@@ -66,7 +78,7 @@ const NO_HOSTED_INPUT_MODALITIES: readonly RuntimeModelInputModality[] = [];
 function adapterHostedInputModalities(
   protocol: RuntimeModelProtocol,
 ): readonly RuntimeModelInputModality[] {
-  return protocol === "openrouter-messages" || protocol === "anthropic-messages"
+  return protocol.startsWith("openrouter-") || protocol === "anthropic-messages"
     ? MESSAGES_HOSTED_INPUT_MODALITIES
     : NO_HOSTED_INPUT_MODALITIES;
 }
@@ -130,15 +142,24 @@ export type PiGenerationLifecycleObserver = (
   event: PiGenerationLifecycleEvent,
 ) => void;
 
+type ProviderBoundStream = (
+  model: Model<Api>,
+  context: Context | TranscriptContext,
+  options?: SimpleStreamOptions,
+) => ReturnType<StreamFn>;
+
 export function structuredOutputStream(
   streamFn: StreamFn,
   model: Model<Api>,
   schema: Record<string, unknown>,
 ): StreamFn | undefined {
-  if (
-    model.api !== "anthropic-messages" ||
-    !model.provider.startsWith("model-api-openrouter-messages-")
-  ) return undefined;
+  const messages = model.api === "anthropic-messages" &&
+    model.provider.startsWith("model-api-openrouter-messages-");
+  const chat = model.api === "openai-completions" &&
+    model.provider.startsWith("model-api-openrouter-chat-");
+  const responses = model.api === "openai-responses" &&
+    model.provider.startsWith("model-api-openrouter-responses-");
+  if (!messages && !chat && !responses) return undefined;
 
   return (activeModel, context, options) =>
     streamFn(activeModel, context, {
@@ -148,14 +169,36 @@ export function structuredOutputStream(
         if (!value || typeof value !== "object" || Array.isArray(value)) {
           throw new Error("Structured model payload must be an object");
         }
-        const current = (value as Record<string, unknown>).output_config;
+        const body = value as Record<string, unknown>;
+        if (messages) {
+          const current = body.output_config;
+          return {
+            ...body,
+            output_config: {
+              ...(current && typeof current === "object" && !Array.isArray(current)
+                ? current
+                : {}),
+              format: { type: "json_schema", schema },
+            },
+          };
+        }
+        if (chat) {
+          return {
+            ...body,
+            response_format: {
+              type: "json_schema",
+              json_schema: { name: "agent_output", strict: true, schema },
+            },
+          };
+        }
+        const current = body.text;
         return {
-          ...value,
-          output_config: {
+          ...body,
+          text: {
             ...(current && typeof current === "object" && !Array.isArray(current)
               ? current
               : {}),
-            format: { type: "json_schema", schema },
+            format: { type: "json_schema", name: "agent_output", strict: true, schema },
           },
         };
       },
@@ -251,7 +294,8 @@ function pdfPayload(payload: unknown, api: Api): unknown {
       };
     }
   }
-  if (api === "openai-codex-responses" && value.type === "input_image") {
+  if ((api === "openai-codex-responses" || api === "openai-responses") &&
+    value.type === "input_image") {
     if (
       typeof value.image_url === "string" &&
       value.image_url.startsWith("data:application/pdf;base64,")
@@ -470,6 +514,8 @@ export function modelRequestUrl(model: Model<Api>): string {
       return `${base}/v1/messages`;
     case "google-generative-ai":
       return `${base}/models/${model.id}:streamGenerateContent`;
+    case "openai-responses":
+      return `${base}/responses`;
     case "openai-codex-responses":
       return base.endsWith("/codex/responses") || base.endsWith("/responses")
         ? base
@@ -490,16 +536,20 @@ export function modelRequestUrl(model: Model<Api>): string {
  * observer 的异常被隔离，不能改变模型执行结果。
  */
 export function withProviderBoundary(
-  streamFn: StreamFn,
-  defaultSessionId?: string,
+  streamFn: ProviderBoundStream,
+  /** Host-owned provider Session; it overrides the durable Harness's per-conversation identity. */
+  hostSessionId?: string | (() => string),
   onGeneration?: PiGenerationLifecycleObserver,
-): StreamFn {
+): ProviderBoundStream {
   return (model, context, options) =>
     lazyStream(model, async () => {
       const requestId = crypto.randomUUID();
       const startedAt = Date.now();
-      const sessionId = options?.sessionId ?? defaultSessionId;
+      const sessionId = (typeof hostSessionId === "function" ? hostSessionId() : hostSessionId) ?? options?.sessionId;
       const url = modelRequestUrl(model);
+      const systemPrompt = "systemPrompt" in context && typeof context.systemPrompt === "string"
+        ? context.systemPrompt
+        : getCurrentSystemPrompt(context.messages);
       const notify = (event: PiGenerationLifecycleEvent) => {
         try {
           onGeneration?.(event);
@@ -516,7 +566,7 @@ export function withProviderBoundary(
         model: model.id,
         url,
         input: {
-          ...(context.systemPrompt ? { systemPrompt: context.systemPrompt } : {}),
+          ...(systemPrompt ? { systemPrompt } : {}),
           messages: context.messages,
         },
       });
@@ -681,7 +731,10 @@ function providerId(endpoint: RuntimeModelEndpoint, index: number): string {
 function apiFor(protocol: RuntimeModelProtocol): Api {
   switch (protocol) {
     case "openai-chat":
+    case "openrouter-chat":
       return "openai-completions";
+    case "openrouter-responses":
+      return "openai-responses";
     case "openrouter-messages":
     case "anthropic-messages":
       return "anthropic-messages";
@@ -694,12 +747,16 @@ function apiFor(protocol: RuntimeModelProtocol): Api {
 
 function piApiFor(endpoint: RuntimeModelEndpoint): ProviderStreams {
   const protocol = endpoint.protocol;
-  const api = (() => {
+  const implementation = (() => {
     switch (protocol) {
       case "openai-chat":
         return openAICompletionsApi();
       case "openrouter-messages":
         return openRouterMessagesApi();
+      case "openrouter-chat":
+        return openRouterChatApi();
+      case "openrouter-responses":
+        return openRouterResponsesApi();
       case "anthropic-messages":
         return anthropicMessagesApi();
       case "google-generative-ai":
@@ -708,7 +765,13 @@ function piApiFor(endpoint: RuntimeModelEndpoint): ProviderStreams {
         return openAICodexResponsesApi();
     }
   })();
-  const contextFor = (model: Model<Api>, context: Context): Context => ({
+  const api = protocol.startsWith("openrouter-")
+    ? withModelProtocolResponse(implementation, protocol as "openrouter-messages" | "openrouter-chat" | "openrouter-responses")
+    : implementation;
+  const contextFor = (
+    model: Model<Api>,
+    context: TranscriptContext,
+  ): TranscriptContext => ({
     ...context,
     messages: modelInputMessages(
       context.messages,
@@ -716,12 +779,12 @@ function piApiFor(endpoint: RuntimeModelEndpoint): ProviderStreams {
       adapterHostedInputModalities(protocol),
     ),
   });
-  return {
+  return overlayProviderStreams(api, {
     stream: (model, context, options) =>
       api.stream(model, contextFor(model, context), options),
     streamSimple: (model, context, options) =>
       api.streamSimple(model, contextFor(model, context), options),
-  };
+  });
 }
 
 function anthropicMessagesModelForOpenRouter(
@@ -741,6 +804,28 @@ function anthropicMessagesModelForOpenRouter(
 // 把部署声明的模型改造成可由对应自定义端点执行的 Pi 模型。
 // resolvePiModel 为单个运行快照调用它，configurePiModels 则在注册端点时为端点中的每个 modelId 调用它。
 // Pi 的内置 OpenAI、Anthropic provider 提供上下文窗口、费用和推理能力等元数据；这里保留这些元数据，但以部署协议、provider 标识和 baseURL 覆盖内置路由，未知模型会在初始化阶段直接报错，而不是拖到请求阶段。
+function assertModelMetadata(
+  metadata: RuntimeModelMetadata,
+  modelId: string,
+): void {
+  if (
+    typeof metadata.name !== "string" || !metadata.name.trim() ||
+    typeof metadata.reasoning !== "boolean" ||
+    !Number.isSafeInteger(metadata.contextWindow) || metadata.contextWindow <= 0 ||
+    !Number.isSafeInteger(metadata.maxTokens) || metadata.maxTokens <= 0 ||
+    metadata.maxTokens > metadata.contextWindow ||
+    !metadata.cost ||
+    [metadata.cost.input, metadata.cost.output, metadata.cost.cacheRead, metadata.cost.cacheWrite]
+      .some((rate) => !Number.isFinite(rate) || rate < 0) ||
+    Object.entries(metadata.thinkingLevelMap ?? {}).some(([level, value]) =>
+      !["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(level) ||
+      (value !== null && (typeof value !== "string" || !value.trim()))
+    )
+  ) {
+    throw new Error(`Invalid deployment model metadata: ${modelId}`);
+  }
+}
+
 function configuredModel(
   endpoint: RuntimeModelEndpoint,
   index: number,
@@ -749,11 +834,28 @@ function configuredModel(
   const catalogModel = CATALOGS[endpoint.protocol].find(
     (model) => model.id === modelId,
   );
-  if (!catalogModel) {
+  const explicitMetadata = endpoint.modelMetadata?.[modelId];
+  if (!catalogModel && !explicitMetadata) {
     throw new Error(
-      `Model is not in SpringBrand's built-in catalog for ${endpoint.protocol}: ${modelId}`,
+      `Model is not in SpringBrand's built-in catalog and has no deployment metadata for ${endpoint.protocol}: ${modelId}`,
     );
   }
+  if (explicitMetadata) assertModelMetadata(explicitMetadata, modelId);
+  if (!catalogModel && !endpoint.modelInputModalities?.[modelId]?.includes("text")) {
+    throw new Error(`Deployment model requires explicit text input capability: ${modelId}`);
+  }
+  const sourceModel: Model<Api> = catalogModel ?? {
+    id: modelId,
+    name: explicitMetadata!.name,
+    api: apiFor(endpoint.protocol),
+    provider: "openrouter",
+    baseUrl: endpoint.baseURL,
+    reasoning: explicitMetadata!.reasoning,
+    input: ["text"],
+    cost: explicitMetadata!.cost,
+    contextWindow: explicitMetadata!.contextWindow,
+    maxTokens: explicitMetadata!.maxTokens,
+  };
   const {
     api: catalogApi,
     provider: _provider,
@@ -762,7 +864,7 @@ function configuredModel(
     headers: catalogHeaders,
     input: catalogInput,
     ...metadata
-  } = catalogModel;
+  } = sourceModel;
   const headers = {
     ...catalogHeaders,
     ...endpoint.headers,
@@ -775,28 +877,82 @@ function configuredModel(
     (modality): modality is "text" | "image" =>
       modality === "text" || modality === "image",
   );
-  // OpenRouter uses dotted versions and optional transport suffixes while the
-  // Anthropic catalog uses dashed base model ids.
+  const isOpenRouter = endpoint.protocol.startsWith("openrouter-");
   const anthropicMessagesCompat = endpoint.protocol === "openrouter-messages"
     ? anthropicMessagesModelForOpenRouter(modelId)?.compat
     : undefined;
+  const openAIResponsesCompat = endpoint.protocol === "openrouter-responses" &&
+      modelId.startsWith("openai/")
+    ? CATALOGS["openai-chat"].find((model) =>
+      model.id === modelId.slice("openai/".length) && model.api === "openai-responses"
+    )?.compat
+    : undefined;
   return {
     ...metadata,
+    ...(explicitMetadata
+      ? {
+          name: explicitMetadata.name,
+          reasoning: explicitMetadata.reasoning,
+          contextWindow: explicitMetadata.contextWindow,
+          maxTokens: explicitMetadata.maxTokens,
+          cost: { ...explicitMetadata.cost },
+          ...(explicitMetadata.thinkingLevelMap
+            ? { thinkingLevelMap: { ...explicitMetadata.thinkingLevelMap } }
+            : {}),
+        }
+      : {}),
     input,
     api: configuredApi,
     provider: providerId(endpoint, index),
     baseUrl: endpoint.baseURL,
-    ...(endpoint.protocol === "openrouter-messages"
+    ...(isOpenRouter
       ? {
           compat: {
-            ...anthropicMessagesCompat,
-            supportsMidConvoEffort: false,
-            supportsEagerToolInputStreaming: false,
-            supportsStrictTools:
-              anthropicMessagesCompat?.supportsStrictTools ?? false,
-            supportsToolReferences: true,
+            ...(endpoint.protocol === "openrouter-messages"
+              ? {
+                  ...anthropicMessagesCompat,
+                  // The direct Anthropic catalog enables positional system and Tool updates, but
+                  // OpenRouter Messages rejects `tool_addition` definitions. Fold them into the
+                  // leading system and top-level tools so deferred Tool decoration still applies.
+                  supportsMidConvoSystemMessages: false,
+                  supportsMidConvoToolChanges: false,
+                  supportsMidConvoEffort: false,
+                  supportsEagerToolInputStreaming: false,
+                  supportsStrictTools:
+                    anthropicMessagesCompat?.supportsStrictTools ?? false,
+                  ...(modelId === "anthropic/claude-sonnet-5.5" ||
+                      modelId === "anthropic/claude-opus-5.5"
+                    ? { forceAdaptiveThinking: true }
+                    : {}),
+                }
+              : endpoint.protocol === "openrouter-chat"
+                ? {
+                    ...catalogCompat,
+                    // OpenRouter Chat has no verified positional system or Tool update support.
+                    supportsMidConvoSystemMessages: false,
+                    supportsMidConvoToolChanges: false,
+                    thinkingFormat: "openrouter" as const,
+                    maxTokensField: "max_tokens" as const,
+                    supportsStore: false,
+                    sessionAffinityFormat: "openrouter" as const,
+                    sendSessionAffinityHeaders: true,
+                    ...(modelId.startsWith("anthropic/")
+                      ? { cacheControlFormat: "anthropic" as const }
+                      : {}),
+                  }
+                : {
+                    sessionAffinityFormat: "openrouter" as const,
+                    supportsDeveloperRole: modelId.startsWith("openai/") ||
+                      modelId.startsWith("anthropic/"),
+                    supportsStrictMode: openAIResponsesCompat?.supportsStrictMode ?? false,
+                    supportsOpenAIGrammarTools:
+                      openAIResponsesCompat?.supportsOpenAIGrammarTools ?? false,
+                  }),
             openRouterRouting: {
               require_parameters: true,
+              ...(endpoint.openRouterProviderSort
+                ? { sort: endpoint.openRouterProviderSort }
+                : {}),
               ...(openRouterProviderPin
                 ? {
                     order: [openRouterProviderPin],
@@ -848,6 +1004,13 @@ export function configurePiModels(
   models: MutableModels,
   provider: RuntimeProviderPort,
 ): MutableModels {
+  for (const endpoint of provider.endpoints) {
+    for (const modelId of Object.keys(endpoint.modelMetadata ?? {})) {
+      if (!endpoint.models.includes(modelId)) {
+        throw new Error(`Deployment metadata is not configured for this endpoint: ${modelId}`);
+      }
+    }
+  }
   const configuredProviders = provider.endpoints.map((endpoint, index) =>
     createProvider({
       id: providerId(endpoint, index),
@@ -865,9 +1028,11 @@ export function configurePiModels(
       models: endpoint.models.map((modelId) =>
         configuredModel(endpoint, index, modelId),
       ),
-      // cloudflareStreams 在运行时把 baseURL 里的 {CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID}
-      // 占位符替换成真实值；如果 baseURL 不含占位符则直接透传，不影响现有端点。
-      api: cloudflareStreams(piApiFor(endpoint)),
+      // remapProviderStreamModels 在运行时把 baseURL 里的
+      // {CLOUDFLARE_ACCOUNT_ID}/{CLOUDFLARE_GATEWAY_ID} 占位符替换成真实值；
+      // 如果 baseURL 不含占位符则直接透传。Pi 自带的 cloudflareStreams 只保留
+      // stream / streamSimple，这里 spread 其余方法以免丢掉 deferred 入口。
+      api: remapProviderStreamModels(piApiFor(endpoint), resolveCloudflareModel),
     })
   );
   models.clearProviders();

package/src/models/openrouter/messages.ts

@@ -1,12 +1,14 @@
 import type {
-  Context,
   Model,
   ProviderStreams,
   StreamOptions,
+  TranscriptContext,
 } from "@earendil-works/pi-ai";
+import { getCurrentTools } from "@earendil-works/pi-ai";
 import {
   anthropicMessagesApi,
 } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
+import { overlayProviderStreams } from "../provider-streams";
 
 type Payload = Record<string, unknown>;
 
@@ -21,14 +23,16 @@ function record(value: unknown): Payload | undefined {
 function decoratePayload(
   payload: unknown,
   model: Model<"anthropic-messages">,
-  context: Context,
+  context: TranscriptContext,
   sessionId?: string,
 ): unknown {
   const body = record(payload);
   if (!body) throw new Error("OpenRouter Messages payload must be an object");
 
   const deferredNames = new Set(
-    context.tools?.filter((tool) => tool.deferLoading).map((tool) => tool.name),
+    getCurrentTools(context.messages)
+      .filter((tool) => tool.deferLoading)
+      .map((tool) => tool.name),
   );
   const tools = Array.isArray(body.tools) ? body.tools : [];
   const immediate: unknown[] = [];
@@ -80,7 +84,7 @@ function decoratePayload(
 
 function openRouterOptions(
   model: Model<"anthropic-messages">,
-  context: Context,
+  context: TranscriptContext,
   options: StreamOptions | undefined,
 ): StreamOptions {
   const apiKey = options?.apiKey;
@@ -107,9 +111,10 @@ function openRouterOptions(
   };
 }
 
-export function openRouterMessagesApi(): ProviderStreams {
-  const anthropic = anthropicMessagesApi();
-  return {
+export function openRouterMessagesApi(
+  anthropic: ProviderStreams = anthropicMessagesApi(),
+): ProviderStreams {
+  return overlayProviderStreams(anthropic, {
     stream: (model, context, options) =>
       anthropic.stream(
         model,
@@ -130,5 +135,5 @@ export function openRouterMessagesApi(): ProviderStreams {
           options,
         ),
       ),
-  };
+  });
 }

package/src/models/openrouter/openai.ts

@@ -0,0 +1,200 @@
+import type {
+  Context,
+  Model,
+  ProviderStreams,
+  StreamOptions,
+  TranscriptContext,
+} from "@earendil-works/pi-ai";
+import { getCurrentTools } from "@earendil-works/pi-ai";
+import {
+  openAICompletionsApi,
+} from "@earendil-works/pi-ai/api/openai-completions.lazy";
+import {
+  openAIResponsesApi,
+} from "@earendil-works/pi-ai/api/openai-responses.lazy";
+import { overlayProviderStreams } from "../provider-streams";
+
+function record(value: unknown): Record<string, unknown> | undefined {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+function openRouterOptions(
+  model: Model<"openai-completions" | "openai-responses">,
+  context: TranscriptContext,
+  options?: StreamOptions,
+): StreamOptions {
+  return {
+    ...options,
+    onPayload: async (payload, activeModel) => {
+      const callerPayload = await options?.onPayload?.(payload, activeModel) ?? payload;
+      const body = record(callerPayload);
+      if (!body) throw new Error("OpenRouter payload must be an object");
+      const replayed = model.api === "openai-responses"
+        ? responsesToolSearch(replayResponsesMessages(body, model, context), context)
+        : body;
+      if (model.api === "openai-responses") {
+        if (replayed.store !== false || replayed.previous_response_id != null) {
+          throw new Error("OpenRouter Responses requires store: false and full input history");
+        }
+        if (replayed.background === true) {
+          throw new Error("Background Responses cannot run in a streaming Agent turn");
+        }
+      }
+      const compat = model.compat as {
+        openRouterRouting?: Readonly<Record<string, unknown>>;
+      } | undefined;
+      const reasoning = record(replayed.reasoning);
+      const include = Array.isArray(replayed.include) ? replayed.include : [];
+      return {
+        ...replayed,
+        ...(model.api === "openai-responses" && reasoning?.effort !== undefined &&
+          reasoning.effort !== null && reasoning.effort !== "none" &&
+          !include.includes("reasoning.encrypted_content")
+          ? { include: [...include, "reasoning.encrypted_content"] }
+          : {}),
+        ...(options?.sessionId ? { session_id: options.sessionId } : {}),
+        provider: {
+          ...record(replayed.provider),
+          ...compat?.openRouterRouting,
+          require_parameters: true,
+        },
+      };
+    },
+  };
+}
+
+function responsesToolSearch(
+  body: Record<string, unknown>,
+  context: TranscriptContext,
+): Record<string, unknown> {
+  const deferredNames = new Set(
+    getCurrentTools(context.messages)
+      .filter((tool) => tool.deferLoading).map((tool) => tool.name),
+  );
+  if (deferredNames.size === 0) return body;
+  const tools = Array.isArray(body.tools) ? body.tools : [];
+  const toolName = (tool: unknown) => {
+    const name = record(tool)?.name;
+    return typeof name === "string" ? name : "";
+  };
+  const deferred = tools.filter((tool) => deferredNames.has(toolName(tool)));
+  if (deferred.length !== deferredNames.size) {
+    throw new Error("Deferred Runtime tools are missing from the Responses payload");
+  }
+  const choice = record(body.tool_choice);
+  if (body.tool_choice !== undefined && body.tool_choice !== "auto" &&
+    choice?.type !== "allowed_tools") {
+    throw new Error("tool_choice conflicts with openrouter:tool_search");
+  }
+  const hasSearch = tools.some((tool) =>
+    ["openrouter:tool_search", "tool_search"].includes(record(tool)?.type as string)
+  );
+  return {
+    ...body,
+    tools: [
+      ...(hasSearch ? [] : [{ type: "openrouter:tool_search", parameters: { max_results: 5 } }]),
+      ...tools.map((tool) => deferredNames.has(toolName(tool))
+        ? { ...record(tool), defer_loading: true }
+        : tool),
+    ],
+  };
+}
+
+function responsesOutput(message: Context["messages"][number]): Record<string, unknown>[] {
+  if (message.role !== "assistant") return [];
+  if (!message.protocolResponse?.output) return [];
+  return message.protocolResponse.output.map((item) => ({ ...item }));
+}
+
+function sameResponseItem(
+  generated: Record<string, unknown> | undefined,
+  original: Record<string, unknown>,
+): boolean {
+  if (!generated || generated.type !== original.type ||
+    generated.id !== original.id) return false;
+  if (original.type === "message") {
+    const text = (content: unknown) => Array.isArray(content)
+      ? content.map((block) => {
+          const part = record(block);
+          return part?.type === "output_text" ? part.text : part?.refusal;
+        }).join("")
+      : content;
+    return text(generated.content) === text(original.content);
+  }
+  if (original.type === "function_call" || original.type === "custom_tool_call") {
+    return generated.call_id === original.call_id &&
+      generated.name === original.name;
+  }
+  return original.type === "reasoning";
+}
+
+function replayResponsesMessages(
+  body: Record<string, unknown>,
+  model: Model<"openai-completions" | "openai-responses">,
+  context: TranscriptContext,
+): Record<string, unknown> {
+  if (!Array.isArray(body.input)) return body;
+  const input = [...body.input];
+  for (const message of context.messages) {
+    if (
+      message.role !== "assistant" ||
+      message.provider !== model.provider ||
+      message.model !== model.id ||
+      message.api !== "openai-responses" ||
+      !message.protocolResponse?.output
+    ) continue;
+    const output = responsesOutput(message);
+    const anchors = output.filter((item) => [
+      "message", "reasoning", "function_call", "custom_tool_call",
+    ].includes(item.type as string));
+    if (anchors.length === 0) continue;
+    const start = input.findIndex((item) =>
+      sameResponseItem(record(item), anchors[0]!)
+    );
+    if (start < 0 || !anchors.every((item, index) =>
+      sameResponseItem(record(input[start + index]), item)
+    )) {
+      for (const item of output) {
+        if (item.type !== "message") continue;
+        const index = input.findIndex((value) => sameResponseItem(record(value), item));
+        if (index >= 0) input[index] = item;
+      }
+      continue;
+    }
+    input.splice(start, anchors.length, ...output.map((item) => {
+      if (item.type !== "reasoning" || item.encrypted_content) return item;
+      const original = record(input[start + anchors.indexOf(item)]);
+      return original?.encrypted_content
+        ? { ...item, encrypted_content: original.encrypted_content }
+        : item;
+    }));
+  }
+  return { ...body, input };
+}
+
+function routedApi(api: ProviderStreams): ProviderStreams {
+  return overlayProviderStreams(api, {
+    stream: (model, context, options) =>
+      api.stream(model, context, openRouterOptions(
+        model as Model<"openai-completions" | "openai-responses">,
+        context,
+        options,
+      )),
+    streamSimple: (model, context, options) =>
+      api.streamSimple(model, context, openRouterOptions(
+        model as Model<"openai-completions" | "openai-responses">,
+        context,
+        options,
+      )),
+  });
+}
+
+export function openRouterChatApi(): ProviderStreams {
+  return routedApi(openAICompletionsApi());
+}
+
+export function openRouterResponsesApi(): ProviderStreams {
+  return routedApi(openAIResponsesApi());
+}