@opencode/ai 0.0.0-dev-19444 → 0.0.0-dev-19446

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

@@ -1,5 +1,6 @@
 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;
@@ -7,6 +8,7 @@ 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,7 +10,6 @@ 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");
@@ -28,7 +27,7 @@ const driver = (options, body) => {
             return { message: body, mode: "full" };
         }),
         observe: (_create, frame) => Effect.gen(function* () {
-            const event = yield* decodeEvent(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame, cause)));
+            const event = yield* OpenResponses.decodeChannelEvent(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") {
@@ -97,6 +96,7 @@ export const transport = (options) => {
                             request: create.request,
                             message: create.message,
                             base,
+                            continuation: options.continuation,
                         }),
                     };
                 })

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

@@ -1,12 +1,16 @@
 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 declare const OpenResponsesContinuation: {
-    readonly driver: (input: DriverInput) => WebSocketChannelDriver;
-};
+export * as OpenResponsesContinuation from "./open-responses-continuation.js";

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

@@ -4,7 +4,6 @@ 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;
@@ -104,21 +103,24 @@ 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);
-            const delta = previous ? incremental(request, previous) : undefined;
-            if (!previous || !delta)
+            // 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)
                 return { message: ProviderShared.encodeJson(request), mode: "full" };
             return {
-                message: ProviderShared.encodeJson({ ...request, input: delta, previous_response_id: previous.responseID }),
+                message: ProviderShared.encodeJson({ ...fields, input: delta, previous_response_id: previous.responseID }),
                 mode: "incremental",
             };
         }),
         observe: (create, frame) => Effect.gen(function* () {
-            const event = yield* decodeEvent(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame, cause)));
+            const event = yield* OpenResponses.decodeChannelEvent(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);
@@ -165,4 +167,4 @@ export const driver = (input) => {
         }),
     };
 };
-export const OpenResponsesContinuation = { driver };
+export * as OpenResponsesContinuation from "./open-responses-continuation.js";

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

@@ -653,6 +653,78 @@ export type Event = Schema.Schema.Type<typeof Event>;
 export type NormalizedEvent = Event & {
     readonly item?: OutputItem | null;
 };
+/**
+ * Decodes one WebSocket frame. xAI answers a rejected `response.create` with `{ "error": { "message", "type" } }` and no
+ * event type; that envelope reads as an error event so the failure classifies instead of failing decoding.
+ */
+export declare const decodeChannelEvent: (frame: string) => Effect.Effect<{
+    readonly [x: string]: unknown;
+    readonly type: string;
+    readonly status?: unknown;
+    readonly code?: string | null | undefined;
+    readonly message?: string | undefined;
+    readonly headers?: unknown;
+    readonly text?: string | undefined;
+    readonly error?: {
+        readonly type?: string | null | undefined;
+        readonly code?: string | null | undefined;
+        readonly message?: string | null | undefined;
+        readonly param?: string | null | undefined;
+    } | null | undefined;
+    readonly item?: {
+        readonly [x: string]: unknown;
+        readonly type: string;
+        readonly id?: string | undefined;
+        readonly name?: string | undefined;
+        readonly namespace?: string | undefined;
+        readonly arguments?: string | undefined;
+        readonly encrypted_content?: string | null | undefined;
+        readonly call_id?: string | undefined;
+    } | null | undefined;
+    readonly delta?: string | undefined;
+    readonly response?: {
+        readonly [x: string]: unknown;
+        readonly id?: string | undefined;
+        readonly output?: readonly {
+            readonly [x: string]: unknown;
+            readonly type: string;
+            readonly id?: string | undefined;
+            readonly name?: string | undefined;
+            readonly namespace?: string | undefined;
+            readonly arguments?: string | undefined;
+            readonly encrypted_content?: string | null | undefined;
+            readonly call_id?: string | undefined;
+        }[] | undefined;
+        readonly error?: {
+            readonly type?: string | null | undefined;
+            readonly code?: string | null | undefined;
+            readonly message?: string | null | undefined;
+            readonly param?: string | null | undefined;
+        } | null | undefined;
+        readonly usage?: {
+            readonly input_tokens?: number | undefined;
+            readonly output_tokens?: number | undefined;
+            readonly output_tokens_details?: {
+                readonly reasoning_tokens?: number | undefined;
+            } | null | undefined;
+            readonly total_tokens?: number | undefined;
+            readonly input_tokens_details?: {
+                readonly cached_tokens?: number | undefined;
+                readonly cache_write_tokens?: number | undefined;
+            } | null | undefined;
+        } | null | undefined;
+        readonly service_tier?: string | null | undefined;
+        readonly incomplete_details?: {
+            readonly reason?: string | undefined;
+        } | null | undefined;
+    } | undefined;
+    readonly arguments?: string | undefined;
+    readonly param?: string | null | undefined;
+    readonly status_code?: unknown;
+    readonly item_id?: string | undefined;
+    readonly output_index?: number | undefined;
+    readonly summary_index?: number | undefined;
+}, Schema.SchemaError, never>;
 export interface ProviderAdapter {
     readonly id: string;
     readonly name: string;

package/dist/protocols/open-responses.js

@@ -288,6 +288,15 @@ export const Event = Schema.StructWithRest(Schema.Struct({
     status_code: Schema.optional(Schema.Unknown),
     headers: Schema.optional(Schema.Unknown),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
+const decodeEventValue = Schema.decodeUnknownEffect(Event);
+const decodeFrame = Schema.decodeUnknownEffect(ProviderShared.Json);
+/**
+ * Decodes one WebSocket frame. xAI answers a rejected `response.create` with `{ "error": { "message", "type" } }` and no
+ * event type; that envelope reads as an error event so the failure classifies instead of failing decoding.
+ */
+export const decodeChannelEvent = (frame) => decodeFrame(frame).pipe(Effect.flatMap((value) => decodeEventValue(ProviderShared.isRecord(value) && value.type === undefined && ProviderShared.isRecord(value.error)
+    ? { ...value, type: "error" }
+    : value)));
 const BASE_ADAPTER = { id: ADAPTER, name: NAME };
 // =============================================================================
 // Request Lowering

package/dist/providers/xai.js

@@ -20,6 +20,10 @@ const responsesRoute = Route.make({
         id: "openai-responses",
         name: "xAI Responses",
         rotateAfterMs: RESPONSES_WEBSOCKET_ROTATE_AFTER_MS,
+        // xAI continues a chain only from stored responses: with `store: false` (the route default) `previous_response_id`
+        // fails with "Response with id=… not found", so those steps are sent in full over the reused connection. It also
+        // rejects `instructions` next to `previous_response_id` and keeps the instructions of the response it continues.
+        continuation: ({ instructions: _instructions, ...request }) => (request.store === false ? undefined : request),
     }),
     defaults: { providerOptions: { store: false, include: ["reasoning.encrypted_content"] } },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-19444",
+  "version": "0.0.0-dev-19446",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "0.0.0-dev-19444",
+    "@opencode/http-recorder": "0.0.0-dev-19446",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -40,7 +40,7 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "0.0.0-dev-19444",
+    "@opencode/schema": "0.0.0-dev-19446",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"