@opencode/ai 0.0.0-beta-19507 → 0.0.0-dev-19276

package/README.md

@@ -29,206 +29,6 @@ await Effect.runPromise(program.pipe(Effect.provide(llmLayer)))
 
 Run `LLMClient.stream(request)` instead of `generate` when you want incremental `LLMEvent`s. The event stream is provider-neutral — same shape across OpenAI Chat, OpenAI Responses, Anthropic Messages, Gemini, Bedrock Converse, and any OpenAI-compatible deployment.
 
-## Alibaba Cloud Model Studio
-
-`Alibaba` provides standard Model Studio inference. Configure a region explicitly, then select
-Chat Completions (`.model` or `.chat`), Anthropic-compatible Messages (`.messages`), or OpenAI-compatible
-Responses (`.responses`). These routes use HTTP/SSE.
-
-```ts
-import { LLM } from "@opencode/ai"
-import { Alibaba } from "@opencode/ai/providers"
-
-const alibaba = Alibaba.configure({
-  region: "ap-southeast-1", // Singapore
-  apiKey: process.env.DASHSCOPE_API_KEY,
-  // workspaceID: "llm-your-workspace", // use a workspace-dedicated endpoint
-})
-
-const request = LLM.request({
-  model: alibaba.model("qwen3.8-max"),
-  prompt: "Explain this design.",
-  providerOptions: { reasoningEffort: "medium" },
-})
-```
-
-### Regions and credentials
-
-| Region              | `region`         | Shared host when `workspaceID` is omitted |
-| ------------------- | ---------------- | ----------------------------------------- |
-| Singapore           | `ap-southeast-1` | `dashscope-intl.aliyuncs.com`             |
-| China (Beijing)     | `cn-beijing`     | `dashscope.aliyuncs.com`                  |
-| China (Hong Kong)   | `cn-hongkong`    | `cn-hongkong.dashscope.aliyuncs.com`      |
-| US (Virginia)       | `us-east-1`      | `dashscope-us.aliyuncs.com`               |
-| Germany (Frankfurt) | `eu-central-1`   | Supply `workspaceID` or `baseURL`         |
-| Japan (Tokyo)       | `ap-northeast-1` | Supply `workspaceID` or `baseURL`         |
-
-With `workspaceID`, the host is `{workspaceID}.{region}.maas.aliyuncs.com`. A complete `baseURL`
-overrides regional setup, including the API prefix: `/compatible-mode/v1` for Chat/Responses,
-or `/apps/anthropic/v1` for Messages. The selector appends its operation path.
-
-Keys and model availability are region-specific. Auth resolves from explicit `auth` or `apiKey`,
-then `DASHSCOPE_API_KEY`, then `ALIBABA_API_KEY`.
-
-The access region and inference scope differ: Virginia's `-us` model IDs request US-only inference;
-some regions select scope through their workspace. Model IDs pass through unchanged.
-Alibaba's [regional guide](https://www.alibabacloud.com/help/en/model-studio/regions) and
-[base URL table](https://www.alibabacloud.com/help/en/model-studio/base-url) disagree about Virginia's
-shared host; the entry above follows the base URL table. Dedicated hosts can be copied from the console.
-
-### Native options
-
-- **Chat:** `reasoningEffort` → `reasoning_effort`, `enableThinking` → `enable_thinking`,
-  `thinkingBudget` → `thinking_budget`, and `preserveThinking` → `preserve_thinking`.
-  Replay complete `response.message` values to retain `reasoning_content` separately from answer text.
-  Qwen 3.8 defaults to preserving thinking; older models have different defaults.
-  Additional options include `toolStream`, `parallelToolCalls`, `repetitionPenalty`, `responseFormat`,
-  `enableSearch`, and native `searchOptions`. `generation.topK` lowers to `top_k`.
-  `clearThinking` is a hosted GLM control, and `thinking.type` is available for hosted MiniMax models.
-- **Messages:** `effort` → `output_config.effort`. `thinking.type` accepts enabled/disabled with an
-  optional `budgetTokens` (or native `budget_tokens`). `outputConfig.format` accepts a JSON schema.
-  Model Studio's empty thinking signatures are accepted; supplied signatures are replayed unchanged.
-- **Responses:** `reasoningEffort` → `reasoning.effort`, plus `enableThinking`, `store`,
-  `previousResponseId`, and `conversation`. Omitted `store` retains the API's default (`true`);
-  set it to `false` for client-managed history. `previousResponseId` requires a stored response.
-  Hosted tools are `Alibaba.webSearch()`, `Alibaba.webExtractor()`, and `Alibaba.codeInterpreter()`.
-  Web extraction is used together with web search. Hosted calls/results carry `providerExecuted: true`.
-
-Omitted options preserve provider defaults. Effort values pass through unchanged and accept future
-strings. Qwen 3.8 Chat rejects requests combining a thinking budget with effort.
-
-Package entrypoints are `@opencode/ai/providers/alibaba`, `alibaba/chat`, `alibaba/messages`,
-and `alibaba/responses`. Live recordings cover all three APIs in Singapore; regional URL construction
-is unit-tested for all six regions.
-
-## Z.AI
-
-`ZAI` uses the standard API. Chat Completions is the default language-model API;
-the existing `.image(...)` selector provides image generation.
-
-```ts
-import { LLM } from "@opencode/ai"
-import { ZAI, ZAICodingPlan } from "@opencode/ai/providers"
-
-const zai = ZAI.configure({ apiKey: process.env.ZAI_API_KEY })
-const request = LLM.request({
-  model: zai.model("glm-5.3"), // also zai.chat("glm-5.3")
-  prompt: "Explain this design.",
-  providerOptions: {
-    reasoningEffort: "high",
-    thinking: { type: "enabled", clear_thinking: false },
-  },
-})
-
-const coding = ZAICodingPlan.configure({ apiKey: process.env.ZAI_API_KEY })
-const messages = LLM.request({
-  model: coding.messages("glm-5.3"),
-  prompt: "Explain this design.",
-  providerOptions: { effort: "high" },
-})
-```
-
-The products have distinct provider identities and endpoints:
-
-| Provider                            | Selector                    | Default base URL                      |
-| ----------------------------------- | --------------------------- | ------------------------------------- |
-| `ZAI` (`zai`)                       | `.model`, `.chat`, `.image` | `https://api.z.ai/api/paas/v4`        |
-| `ZAICodingPlan` (`zai-coding-plan`) | `.model`, `.chat`           | `https://api.z.ai/api/coding/paas/v4` |
-| `ZAICodingPlan`                     | `.messages`                 | `https://api.z.ai/api/anthropic/v1`   |
-| `ZAICodingPlan`                     | `.responses`                | `https://api.z.ai/api/v1`             |
-
-Both read `ZAI_API_KEY` when `apiKey` is omitted and support an explicit `auth` override.
-Coding Plan requires an active subscription. `baseURL` overrides the selected API's
-complete base, including its version prefix. Language-model routes use HTTP/SSE.
-
-Options retain the selected API's native semantics:
-
-- Chat `reasoningEffort` lowers to `reasoning_effort`; Responses lowers it to `reasoning.effort`.
-  Messages `effort` lowers to `output_config.effort`. Omission preserves provider defaults.
-- Chat `thinking` passes `type` and `clear_thinking` through unchanged. Set
-  `clear_thinking: false` and replay complete `response.message` values to preserve reasoning
-  across user messages and tool loops. The standard API defaults to clearing historical thinking;
-  Coding Plan documents preservation by default.
-- Messages accepts `thinking: { type: "enabled" | "adaptive" | "disabled" }` without requiring
-  an Anthropic token budget. Coding Plan documents a disabled toggle as low-effort thinking
-  for GLM-5.3, with explicit effort taking precedence.
-- Chat also offers `toolStream`, `doSample`, `responseFormat`, `requestID`, and `userID`.
-  Tool-argument streaming is enabled when tools are present on GLM-4.6/4.7/5.x;
-  `toolStream: false` explicitly disables it. Older model families omit the opt-in.
-- Effort and thinking values remain forward-compatible strings. Their meaning is model-specific:
-  GLM-5.3 accepts `low`, `high`, and `max` effort and rejects disabled thinking with HTTP 400;
-  the direct GLM-5.2 recordings returned reasoning even with `none` and `minimal` effort,
-  whereas explicit `thinking.type: "disabled"` disabled it on GLM-5.2 and GLM-4.7.
-
-Standard API recordings cover GLM-5.3 efforts and a full preserved-reasoning tool loop with
-a subsequent user follow-up, GLM-5.2 efforts, older-model thinking toggles, GLM-4.5 tool calls,
-GLM-5.3-Flash image input, and JSON output. Coding Plan has unit coverage for routing,
-request options, and reasoning replay; successful live recordings are pending.
-
-Package entrypoints are `@opencode/ai/providers/zai`, `zai/chat`, `zai-coding-plan`,
-`zai-coding-plan/chat`, `zai-coding-plan/messages`, and `zai-coding-plan/responses`.
-
-## Moonshot
-
-Moonshot defaults to Chat Completions, with Messages and Responses selectors for Kimi K3:
-
-```ts
-import { LLM } from "@opencode/ai"
-import { Moonshot } from "@opencode/ai/providers"
-
-const moonshot = Moonshot.configure({ apiKey: process.env.MOONSHOT_API_KEY })
-
-const request = LLM.request({
-  model: moonshot.model("kimi-k3"), // also moonshot.chat("kimi-k3")
-  prompt: "Explain the tradeoffs in this design.",
-  providerOptions: { reasoningEffort: "high" },
-})
-
-const messages = LLM.request({
-  model: moonshot.messages("kimi-k3"),
-  prompt: "Explain the tradeoffs in this design.",
-  providerOptions: { effort: "high" },
-})
-
-const responses = LLM.request({
-  model: moonshot.responses("kimi-k3"),
-  prompt: "Explain the tradeoffs in this design.",
-  providerOptions: { reasoningEffort: "high" },
-})
-```
-
-When `apiKey` is omitted, authentication reads `MOONSHOT_API_KEY`, then `MOONSHOTAI_API_KEY`.
-Chat and Responses use `https://api.moonshot.ai/v1`; Messages uses
-`https://api.moonshot.ai/anthropic/v1`. `baseURL` overrides the selected API's complete base,
-including the version prefix, for regional endpoints or gateways. Each endpoint requires its own valid credentials.
-All three routes use HTTP/SSE.
-
-Reasoning options stay native to the selected API and model:
-
-| Model/API                   | Provider options                                                                        |
-| --------------------------- | --------------------------------------------------------------------------------------- |
-| K3 Chat / Responses         | `reasoningEffort: "low" \| "high" \| "max"`; default is `max`                           |
-| K3 Messages                 | `effort: "low" \| "high" \| "max"`; default is `max`                                    |
-| K2.6 Chat                   | `thinking: { type: "enabled" \| "disabled", keep?: "all" \| null }`; default is enabled |
-| K2.7 Code / high-speed Chat | Omit `thinking` to use always-on, preserved reasoning                                   |
-
-Omitting options preserves the model's defaults. K3 uses effort rather than the K2.x `thinking`
-parameter. Known effort values have autocomplete while future strings remain accepted.
-For K2.6, `thinking.keep: "all"` enables preservation of reasoning across user messages.
-K3 and both K2.7 Code variants always preserve reasoning. Continue with the returned
-`response.message` and matching tool results so reasoning content and any Messages signatures are retained.
-Leave sampling options such as `temperature` unset to use these models' fixed defaults.
-
-The recorded suite covers all three K3 APIs, default and explicit efforts, K2.6 thinking modes,
-both K2.7 Code variants, generated tool loops with a subsequent user follow-up, required/disabled
-tool choice, image-byte input, and native structured output through `http.body` overlays.
-K3 Chat and Messages accept required and disabled tool choice. Responses supports automatic tool
-choice only; explicit `required` and `none` produce a provider `InvalidRequest` error, also covered by recordings.
-The provider targets the Moonshot Open Platform; Kimi Code is a separate product and endpoint.
-
-Package entrypoints are `@opencode/ai/providers/moonshot`, `moonshot/chat`, `moonshot/messages`,
-and `moonshot/responses`; each exports `model(modelID, settings)`.
-
 ## MiniMax
 
 MiniMax defaults to its Messages API and reads `MINIMAX_API_KEY` when `apiKey` is omitted:

package/dist/protocols/anthropic-messages.d.ts

@@ -10,19 +10,14 @@ export declare const DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
 export declare const PATH = "/messages";
 export declare const DEFAULT_MAX_TOKENS = 32000;
 export declare const framing: Framing.Definition<string>;
-export type ThinkingBlockBinding = {
-    readonly prefix_mismatch_behavior?: "error" | "drop_block" | (string & {});
-};
 export type ThinkingInput = {
     readonly type: "adaptive";
     readonly display?: "summarized" | "omitted";
-    readonly block_binding?: ThinkingBlockBinding;
 } | {
     readonly type: "disabled";
 } | ({
     readonly type: "enabled";
     readonly display?: "summarized" | "omitted";
-    readonly block_binding?: ThinkingBlockBinding;
 } & ({
     readonly budgetTokens: number;
     readonly budget_tokens?: number;
@@ -314,15 +309,9 @@ export declare const AnthropicMessagesBody: Schema.Struct<{
         readonly type: Schema.tag<"enabled">;
         readonly budget_tokens: Schema.Number;
         readonly display: Schema.optional<Schema.Literals<readonly ["summarized", "omitted"]>>;
-        readonly block_binding: Schema.optional<Schema.Struct<{
-            readonly prefix_mismatch_behavior: Schema.optional<Schema.String>;
-        }>>;
     }>, Schema.Struct<{
         readonly type: Schema.tag<"adaptive">;
         readonly display: Schema.optional<Schema.Literals<readonly ["summarized", "omitted"]>>;
-        readonly block_binding: Schema.optional<Schema.Struct<{
-            readonly prefix_mismatch_behavior: Schema.optional<Schema.String>;
-        }>>;
     }>, Schema.Struct<{
         readonly type: Schema.tag<"disabled">;
     }>]>>;
@@ -567,15 +556,9 @@ export declare const protocol: Protocol<{
         readonly type: "enabled";
         readonly budget_tokens: number;
         readonly display?: "summarized" | "omitted" | undefined;
-        readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
-        } | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;
-        readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
-        } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;
@@ -701,7 +684,7 @@ export declare const protocol: Protocol<{
     reasoningSignatures: {};
     lifecycle: Lifecycle.State;
 }>;
-export declare const transport: <Body extends Pick<AnthropicMessagesBody, "messages" | "context_management" | "thinking">>() => {
+export declare const transport: <Body extends Pick<AnthropicMessagesBody, "messages" | "context_management">>() => {
     prepare: (input: Parameters<(input: import("../route/transport/index.js").TransportPrepareInput<Body>) => Effect.Effect<HttpTransport.HttpPrepared<string>, AIError, never>>[0]) => Effect.Effect<HttpTransport.HttpPrepared<string>, AIError, never>;
     with: (patch: Partial<HttpTransport.HttpJsonInput<Body, string>>) => HttpTransport.HttpJsonTransport<Body, string>;
     id: string;
@@ -921,15 +904,9 @@ export declare const route: Route<{
         readonly type: "enabled";
         readonly budget_tokens: number;
         readonly display?: "summarized" | "omitted" | undefined;
-        readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
-        } | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;
-        readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
-        } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;

package/dist/protocols/anthropic-messages.js

@@ -202,20 +202,15 @@ const AnthropicToolChoice = Schema.Union([
         disable_parallel_tool_use: Schema.optional(Schema.Boolean),
     }),
 ]);
-const AnthropicThinkingBlockBinding = Schema.Struct({
-    prefix_mismatch_behavior: Schema.optional(Schema.String),
-});
 const AnthropicThinking = Schema.Union([
     Schema.Struct({
         type: Schema.tag("enabled"),
         budget_tokens: Schema.Number,
         display: Schema.optional(Schema.Literals(["summarized", "omitted"])),
-        block_binding: Schema.optional(AnthropicThinkingBlockBinding),
     }),
     Schema.Struct({
         type: Schema.tag("adaptive"),
         display: Schema.optional(Schema.Literals(["summarized", "omitted"])),
-        block_binding: Schema.optional(AnthropicThinkingBlockBinding),
     }),
     Schema.Struct({
         type: Schema.tag("disabled"),
@@ -848,9 +843,8 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
             ...(outputConfigEffort === undefined ? {} : { effort: outputConfigEffort }),
             ...(outputConfigFormat === undefined ? {} : { format: outputConfigFormat }),
         };
-    const thinking = yield* resolveThinking(input?.thinking);
     return {
-        thinking: applyThinkingBindingDefault(request.model, thinking),
+        thinking: yield* resolveThinking(input?.thinking),
         effort: outputConfigEffort,
         output_config,
         service_tier,
@@ -860,44 +854,18 @@ const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (
         cache_control,
     };
 });
-const supportsThinkingBlockBinding = (model) => {
-    const override = model.compatibility?.supportsThinkingBlockBinding;
-    if (override !== undefined)
-        return override;
-    // Accept gateway namespaces and Vertex suffixes without treating a snapshot date as a minor version.
-    const version = /(?:^|[./])claude-[a-z]+-(?<major>\d+)(?:[.-](?<minor>\d{1,2}))?(?:$|[-:@])/i.exec(model.id)?.groups;
-    if (!version)
-        return false;
-    const major = Number(version.major);
-    const minor = Number(version.minor ?? 0);
-    return major > 5 || (major === 5 && minor >= 1);
-};
-const applyThinkingBindingDefault = (model, thinking) => {
-    if (thinking?.type === "disabled")
-        return thinking;
-    if (!supportsThinkingBlockBinding(model))
-        return thinking;
-    return {
-        ...(thinking ?? { type: "adaptive" }),
-        block_binding: {
-            prefix_mismatch_behavior: "drop_block",
-            ...thinking?.block_binding,
-        },
-    };
-};
 const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function* (input) {
     if (!ProviderShared.isRecord(input))
         return undefined;
-    if (input.type === "disabled")
-        return { type: "disabled" };
-    if (input.type !== "adaptive" && input.type !== "enabled")
-        return undefined;
-    const block_binding = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Schema.UndefinedOr(AnthropicThinkingBlockBinding)))(input.block_binding);
     const display = input.display === "summarized" || input.display === "omitted"
         ? input.display
         : undefined;
     if (input.type === "adaptive")
-        return { type: "adaptive", display, block_binding };
+        return { type: "adaptive", ...(display === undefined ? {} : { display }) };
+    if (input.type === "disabled")
+        return { type: "disabled" };
+    if (input.type !== "enabled")
+        return undefined;
     const budget = typeof input.budgetTokens === "number"
         ? input.budgetTokens
         : typeof input.budget_tokens === "number"
@@ -905,7 +873,7 @@ const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function*
             : undefined;
     if (budget === undefined)
         return yield* ProviderShared.invalidRequest("Anthropic thinking provider option requires budgetTokens");
-    return { type: "enabled", budget_tokens: budget, display, block_binding };
+    return { type: "enabled", budget_tokens: budget, ...(display === undefined ? {} : { display }) };
 });
 const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (request) {
     const management = yield* ProviderShared.validateWith(Schema.decodeUnknownEffect(Schema.UndefinedOr(ContextManagement)))(request.providerOptions?.contextManagement);
@@ -1410,15 +1378,15 @@ export const transport = () => {
     return {
         ...http,
         prepare: (input) => {
-            const requiredBetas = requiredBetaHeaders(input.body);
-            if (requiredBetas.length === 0)
+            if (!input.body.context_management?.edits.length &&
+                !input.body.messages.some((message) => message.content.some((block) => block.type === "compaction")))
                 return http.prepare(input);
             const headers = Headers.fromInput(input.request.http?.headers);
-            const existingBetas = (headers["anthropic-beta"] ?? "")
+            const betas = new Set((headers["anthropic-beta"] ?? "")
                 .split(",")
                 .map((item) => item.trim())
-                .filter(Boolean);
-            const betas = new Set([...existingBetas, ...requiredBetas]);
+                .filter(Boolean));
+            betas.add("compact-2026-01-12");
             return http.prepare({
                 ...input,
                 request: LLMRequest.update(input.request, {
@@ -1431,20 +1399,6 @@ export const transport = () => {
         },
     };
 };
-function requiredBetaHeaders(body) {
-    // Always request interleaved thinking. The API accepts the header on any
-    // model and ignores it where unsupported, while manual-thinking models need
-    // it for thinking between tool calls.
-    const betas = ["interleaved-thinking-2025-05-14"];
-    const requestsCompaction = (body.context_management?.edits.length ?? 0) > 0;
-    const replaysCompaction = body.messages.some((message) => message.content.some((block) => block.type === "compaction"));
-    if (requestsCompaction || replaysCompaction)
-        betas.push("compact-2026-01-12");
-    const thinking = body.thinking;
-    if (thinking && thinking.type !== "disabled" && thinking.block_binding)
-        betas.push("thinking-binding-controls-2026-08-01");
-    return betas;
-}
 export const route = Route.make({
     id: ADAPTER,
     provider: "anthropic",

package/dist/protocols/meta-messages.d.ts

@@ -219,15 +219,9 @@ export declare const protocol: Protocol<{
         readonly type: "enabled";
         readonly budget_tokens: number;
         readonly display?: "summarized" | "omitted" | undefined;
-        readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
-        } | undefined;
     } | {
         readonly type: "adaptive";
         readonly display?: "summarized" | "omitted" | undefined;
-        readonly block_binding?: {
-            readonly prefix_mismatch_behavior?: string | undefined;
-        } | undefined;
     } | {
         readonly type: "disabled";
     } | undefined;

package/dist/protocols/open-responses-channel.d.ts

@@ -1,6 +1,5 @@
 import { Headers } from "effect/unstable/http";
 import { HttpTransport, type Transport, type WebSocketChannelDriver } from "../route/transport/index.js";
-import { OpenResponsesContinuation } from "./open-responses-continuation.js";
 export interface Options {
     readonly id: string;
     readonly name: string;
@@ -8,7 +7,6 @@ export interface Options {
     readonly enabled?: (url: string) => boolean;
     readonly url?: (url: string) => string;
     readonly headers?: (headers: Headers.Headers) => Headers.Headers;
-    readonly continuation?: OpenResponsesContinuation.Shape;
 }
 export interface Prepared {
     readonly http: HttpTransport.HttpPrepared<string>;

package/dist/protocols/open-responses-channel.js

@@ -10,6 +10,7 @@ const WebSocketResponseCreate = Schema.StructWithRest(Schema.Struct({ type: Sche
 ]);
 const decodeMessage = ProviderShared.validateWith(Schema.decodeUnknownEffect(WebSocketResponseCreate));
 const encodeMessage = Schema.encodeSync(Schema.fromJsonString(WebSocketResponseCreate));
+const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event);
 const message = (body) => Effect.gen(function* () {
     if (!ProviderShared.isRecord(body))
         return yield* ProviderShared.invalidRequest("Open Responses WebSocket body must be a JSON object");
@@ -27,7 +28,7 @@ const driver = (options, body) => {
             return { message: body, mode: "full" };
         }),
         observe: (_create, frame) => Effect.gen(function* () {
-            const event = yield* OpenResponses.decodeChannelEvent(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame, cause)));
+            const event = yield* decodeEvent(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame, cause)));
             if (terminal)
                 return yield* ProviderShared.eventError(options.id, `${options.name} emitted ${event.type} after a terminal event`, frame);
             if (event.type === "error") {
@@ -96,7 +97,6 @@ export const transport = (options) => {
                             request: create.request,
                             message: create.message,
                             base,
-                            continuation: options.continuation,
                         }),
                     };
                 })

package/dist/protocols/open-responses-continuation.d.ts

@@ -1,16 +1,12 @@
 import type { WebSocketChannelDriver } from "../route/transport/index.js";
-/**
- * Fields to send next to `previous_response_id` on an incremental step, or undefined to send the step in full.
- * Whether omitted fields carry over from the continued response is provider behavior the route must know.
- */
-export type Shape = (request: Readonly<Record<string, unknown>>) => Readonly<Record<string, unknown>> | undefined;
 export interface DriverInput {
     readonly id: string;
     readonly name: string;
     readonly request: Readonly<Record<string, unknown>>;
     readonly message: string;
     readonly base: WebSocketChannelDriver;
-    readonly continuation?: Shape;
 }
 export declare const driver: (input: DriverInput) => WebSocketChannelDriver;
-export * as OpenResponsesContinuation from "./open-responses-continuation.js";
+export declare const OpenResponsesContinuation: {
+    readonly driver: (input: DriverInput) => WebSocketChannelDriver;
+};

package/dist/protocols/open-responses-continuation.js

@@ -4,6 +4,7 @@ import * as ProviderShared from "./shared.js";
 import { OpenResponses } from "./open-responses.js";
 const PROTOCOL = "open-responses.websocket.v1";
 const VERSION = 1;
+const decodeEvent = Schema.decodeUnknownEffect(OpenResponses.protocol.stream.event);
 const checkpointValue = (checkpoint) => {
     if (checkpoint?.protocol !== PROTOCOL || !ProviderShared.isRecord(checkpoint.value))
         return undefined;
@@ -103,24 +104,21 @@ const rejected = (observation, recovery) => ({
 });
 export const driver = (input) => {
     const { previous_response_id: _previousResponseID, ...request } = input.request;
-    const shape = input.continuation ?? ((fields) => fields);
     let output = [];
     return {
         create: (checkpoint) => Effect.sync(() => {
             output = [];
             const previous = checkpointValue(checkpoint);
-            // Ask the route first: diffing the whole history is wasted when it declines the continuation.
-            const fields = previous ? shape(request) : undefined;
-            const delta = previous && fields ? incremental(request, previous) : undefined;
-            if (!previous || !fields || !delta)
+            const delta = previous ? incremental(request, previous) : undefined;
+            if (!previous || !delta)
                 return { message: ProviderShared.encodeJson(request), mode: "full" };
             return {
-                message: ProviderShared.encodeJson({ ...fields, input: delta, previous_response_id: previous.responseID }),
+                message: ProviderShared.encodeJson({ ...request, input: delta, previous_response_id: previous.responseID }),
                 mode: "incremental",
             };
         }),
         observe: (create, frame) => Effect.gen(function* () {
-            const event = yield* OpenResponses.decodeChannelEvent(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame, cause)));
+            const event = yield* decodeEvent(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame, cause)));
             const observation = yield* input.base.observe(create, frame);
             if (event.type === "response.output_item.done" && event.item)
                 output.push(event.item);
@@ -130,13 +128,6 @@ export const driver = (input) => {
                     return rejected(observation, "retry-full");
                 if (rejection === "websocket_connection_limit_reached")
                     return rejected(observation, "rotate-and-retry-full");
-                // Only the continuation distinguishes an incremental send from a full one, so an unclassified
-                // invalid request there is retried full; Codex reports a stale previous_response_id that way, with
-                // no code. Classified failures such as context overflow keep their runner-owned recovery.
-                if (create.mode === "incremental" &&
-                    observation.error.reason._tag === "InvalidRequest" &&
-                    observation.error.reason.classification === undefined)
-                    return rejected(observation, "retry-full");
             }
             if (observation.type !== "completed")
                 return observation;
@@ -156,7 +147,7 @@ export const driver = (input) => {
                         responseID,
                         request,
                         // Completion can re-encrypt reasoning. Callers replay the item already emitted by output_item.done.
-                        output: event.response?.output?.length
+                        output: event.response?.output
                             ? event.response.output.map((item) => item.type === "reasoning" && item.id !== undefined
                                 ? (output.find((done) => done.type === item.type && done.id === item.id) ?? item)
                                 : item)
@@ -167,4 +158,4 @@ export const driver = (input) => {
         }),
     };
 };
-export * as OpenResponsesContinuation from "./open-responses-continuation.js";
+export const OpenResponsesContinuation = { driver };