@opencode-ai/ai 0.0.0-beta-18387 → 0.0.0-beta-18593

package/README.md

@@ -214,22 +214,40 @@ the requests sent by code under test:
 import { Effect } from "effect"
 import { TestLLM } from "@opencode-ai/ai/testing"
 
-const testLLM = TestLLM.layer({
-  fallback: TestLLM.text("Hello from the test model", "text-1"),
-})
-
-// TestLLM.clientLayer provides LLMClient.Service and consumes TestLLM.Service.
 const programWithTestClient = Effect.gen(function* () {
+  const test = yield* TestLLM.Test
+  yield* test.push(TestLLM.text("Hello from the test model", "text-1"))
   const result = yield* program
-  const test = yield* TestLLM.Service
-  console.log(test.requests)
+  console.log(yield* test.requests())
   return result
-}).pipe(Effect.provide(TestLLM.clientLayer), Effect.provide(testLLM))
+}).pipe(Effect.provide(TestLLM.testLayer()))
 ```
 
-`TestLLM.push(...)` scripts one-shot responses, `TestLLM.always(...)` changes the fallback, and
-`TestLLM.wait(...)` lets concurrent tests wait until a request has arrived. Every received canonical request is
-available on the yielded `TestLLM.Service`.
+`testLayer()` provides the same object under `LLMClient.Service` and `TestLLM.Test`. Production consumes the
+normal client; tests use the additional controls. Each layer build has fresh state.
+
+- `test.push(...)` queues one-shot responses in execution order. Each argument is one response.
+- `test.always(response)` installs a repeatable fallback. The layer's `fallback` option sets its initial value.
+- `test.serve(request => response)` installs a request-dependent fallback. `always` and `serve` replace each
+  other without changing queued replies; queued replies take precedence.
+- `test.requests()` returns an array snapshot. `transformRequest` changes only the recorded observation;
+  `serve` receives the original canonical request.
+- `test.wait(count)` waits for request arrivals, not output or completion, and supports concurrent waiters.
+- `test.gate()` returns a scoped gate with countable `started` notifications and a `release` Effect. Release
+  unblocks all requests captured by that gate; closing its scope also releases it. Effect-aware test runners
+  already provide Scope.
+
+Constructing `stream()` or `generate()` does not record a request, invoke a responder, or consume a script.
+Each execution does. An exhausted queue without a fallback defects immediately rather than waiting for a
+future reply.
+
+Responses remain canonical event arrays or arbitrary `Stream<LLMEvent, AIError>` values. The client consumes
+supplied streams directly, preserving failure identity, finalizers, incomplete output, and post-finish tails;
+it does not repair or truncate them.
+
+The published legacy `Service`, `layer`, `clientLayer`, and module-level controls remain available as adapters
+over the same implementation, including the legacy live `requests` array. New tests should use `Test` and
+`testLayer`.
 
 ## Caching
 

package/dist/image.js

@@ -1,5 +1,5 @@
 import { Effect, Schema } from "effect";
-import { HttpOptions, InvalidRequestReason, AIError, ModelID, ProviderID, ProviderMetadata, Usage, } from "./schema/index.js";
+import { HttpOptions, InvalidRequestError, AIError, ModelID, ProviderID, ProviderMetadata, Usage, } from "./schema/index.js";
 import { ImageClient, Service } from "./image-client.js";
 export class ImageModel {
     id;
@@ -90,9 +90,10 @@ export function generate(input) {
     return Effect.try({
         try: () => (input instanceof ImageRequest ? input : request(input)),
         catch: (error) => new AIError({
-            module: "Image",
-            method: "generate",
-            reason: new InvalidRequestReason({ message: error instanceof Error ? error.message : String(error) }),
+            reason: new InvalidRequestError({
+                message: error instanceof Error ? error.message : String(error),
+                cause: error,
+            }),
         }),
     }).pipe(Effect.flatMap((request) => ImageClient.generate(request)));
 }

package/dist/llm.d.ts

@@ -45,6 +45,7 @@ export declare class GenerateObjectResponse<T> {
     } | {
         readonly id: string;
         readonly type: "text-end";
+        readonly text?: string | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;
@@ -70,6 +71,7 @@ export declare class GenerateObjectResponse<T> {
     } | {
         readonly id: string;
         readonly type: "reasoning-end";
+        readonly text?: string | undefined;
         readonly providerMetadata?: {
             readonly [x: string]: {
                 readonly [x: string]: unknown;

package/dist/llm.js

@@ -1,6 +1,6 @@
 import { Effect, JsonSchema, Schema } from "effect";
 import { LLMClient, Service } from "./route/client.js";
-import { GenerationOptions, HttpOptions, InvalidProviderOutputReason, AIError, LLMEvent, LLMRequest, LLMResponse, Message, LanguageModel, SystemPart, ToolChoice, ToolDefinition, } from "./schema/index.js";
+import { GenerationOptions, HttpOptions, InvalidProviderOutputError, AIError, LLMEvent, LLMRequest, LLMResponse, Message, LanguageModel, SystemPart, ToolChoice, ToolDefinition, } from "./schema/index.js";
 import { make as makeTool, toDefinitions } from "./tool.js";
 export const generate = LLMClient.generate;
 export const stream = LLMClient.stream;
@@ -43,17 +43,14 @@ const runGenerateObject = Effect.fn("LLM.generateObject")(function* (options, to
     const call = response.toolCalls.find((event) => LLMEvent.is.toolCall(event) && event.name === GENERATE_OBJECT_TOOL_NAME);
     if (!call || !LLMEvent.is.toolCall(call))
         return yield* new AIError({
-            module: "LLM",
-            method: "generateObject",
-            reason: new InvalidProviderOutputReason({
+            reason: new InvalidProviderOutputError({
                 message: `generateObject: model did not call the forced \`${GENERATE_OBJECT_TOOL_NAME}\` tool`,
             }),
         });
     const object = yield* tool._decode(call.input).pipe(Effect.mapError((error) => new AIError({
-        module: "LLM",
-        method: "generateObject",
-        reason: new InvalidProviderOutputReason({
+        reason: new InvalidProviderOutputError({
             message: `generateObject: tool input failed schema decode: ${error.message}`,
+            cause: error,
         }),
     })));
     return new GenerateObjectResponse(object, response);

package/dist/protocols/anthropic-messages.js

@@ -1167,11 +1167,13 @@ const providerErrorMessage = (event) => {
         return `${type}: ${message}`;
     return message || type || "Anthropic Messages stream error";
 };
-const onError = (event) => Effect.fail(new AIError({
-    module: ADAPTER,
-    method: "stream",
-    reason: classifyProviderFailure({ message: providerErrorMessage(event), code: event.error?.type }),
-}));
+const onError = (event) => {
+    const message = providerErrorMessage(event);
+    const body = ProviderShared.encodeJson(event);
+    return Effect.fail(new AIError({
+        reason: classifyProviderFailure({ message, rawBody: body }),
+    }));
+};
 const isKnownStreamBlockType = (type) => type === "text" ||
     type === "thinking" ||
     type === "redacted_thinking" ||

package/dist/protocols/bedrock-converse.d.ts

@@ -129,6 +129,7 @@ export type BedrockConverseBody = Schema.Schema.Type<typeof BedrockConverseBody>
 interface ParserState {
     readonly providerMetadataKey: string;
     readonly tools: ToolStream.State<number>;
+    readonly finishedTools: ReadonlySet<number>;
     readonly pendingFinish: {
         readonly reason: FinishReasonDetails;
         readonly usage?: Usage;

package/dist/protocols/bedrock-converse.js

@@ -285,6 +285,13 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (requ
                         content.push({ reasoningContent: { redactedContent: redactedData } });
                         continue;
                     }
+                    if (signature === undefined || signature.trim().length === 0) {
+                        // Interrupted streams and model switches can leave unsigned reasoning.
+                        // Preserve readable history as text rather than replay invalid reasoningContent.
+                        if (part.text.trim().length > 0)
+                            content.push(...textWithCache(breakpoints, part.text, part.cache));
+                        continue;
+                    }
                     content.push({ reasoningContent: { reasoningText: { text: part.text, signature } } });
                     continue;
                 }
@@ -293,7 +300,8 @@ const lowerMessages = Effect.fn("BedrockConverse.lowerMessages")(function* (requ
                     continue;
                 }
             }
-            messages.push({ role: "assistant", content });
+            if (content.length > 0)
+                messages.push({ role: "assistant", content });
             continue;
         }
         const content = [];
@@ -447,6 +455,8 @@ const step = (state, event) => Effect.gen(function* () {
     }
     if (event.contentBlockDelta?.delta?.toolUse) {
         const index = event.contentBlockDelta.contentBlockIndex;
+        if (state.finishedTools.has(index))
+            return [state, []];
         const result = ToolStream.appendExisting(ADAPTER, state.tools, index, event.contentBlockDelta.delta.toolUse.input, "Bedrock Converse tool delta is missing its tool call");
         if (ToolStream.isError(result))
             return yield* result;
@@ -473,6 +483,7 @@ const step = (state, event) => Effect.gen(function* () {
                     state.hasToolCalls,
                 lifecycle,
                 tools: result.tools,
+                finishedTools: resultEvents.length > 0 ? new Set([...state.finishedTools, index]) : state.finishedTools,
                 reasoningSignatures: Object.fromEntries(Object.entries(state.reasoningSignatures).filter(([key]) => key !== String(index))),
             },
             events,
@@ -507,14 +518,12 @@ const step = (state, event) => Effect.gen(function* () {
         ];
     }
     if (event.exception) {
+        const message = event.exception.details.message ?? event.exception.details.originalMessage ?? "Bedrock Converse stream error";
+        const body = ProviderShared.encodeJson(event);
         return yield* new AIError({
-            module: ADAPTER,
-            method: "stream",
             reason: classifyProviderFailure({
-                message: event.exception.details.message ??
-                    event.exception.details.originalMessage ??
-                    "Bedrock Converse stream error",
-                code: event.exception.type,
+                message,
+                rawBody: body,
             }),
         });
     }
@@ -554,6 +563,7 @@ export const protocol = Protocol.make({
         initial: (request) => ({
             providerMetadataKey: request.model.route.providerMetadataKey ?? String(request.model.provider),
             tools: ToolStream.empty(),
+            finishedTools: new Set(),
             pendingFinish: undefined,
             hasToolCalls: false,
             lifecycle: Lifecycle.initial(),

package/dist/protocols/bedrock-event-stream.js

@@ -1,6 +1,7 @@
 import { EventStreamCodec } from "@smithy/eventstream-codec";
 import { fromUtf8, toUtf8 } from "@smithy/util-utf8";
-import { Effect, Stream } from "effect";
+import { Effect, Encoding, Stream } from "effect";
+import { AIError, AIErrorReason } from "../schema/index.js";
 import { Framing } from "../route/framing.js";
 import { ProviderShared } from "./shared.js";
 // Bedrock streams responses using the AWS event stream binary protocol — each
@@ -30,15 +31,17 @@ const consumeFrames = (route) => (state, chunk) => Effect.gen(function* () {
             break;
         const decoded = yield* Effect.try({
             try: () => eventCodec.decode(view.subarray(0, totalLength)),
-            catch: (error) => ProviderShared.eventError(route, `Failed to decode Bedrock Converse event-stream frame: ${error instanceof Error ? error.message : String(error)}`),
+            catch: (error) => ProviderShared.eventError(route, `Failed to decode Bedrock Converse event-stream frame: ${error instanceof Error ? error.message : String(error)}`, Encoding.encodeBase64(view.subarray(0, totalLength)), error),
         });
         cursor = { buffer: cursor.buffer, offset: cursor.offset + totalLength };
+        const payload = utf8.decode(decoded.body);
+        const body = ProviderShared.encodeJson({ headers: decoded.headers, body: payload });
         const messageType = decoded.headers[":message-type"]?.value;
         if (messageType === "error") {
             const code = decoded.headers[":error-code"]?.value;
             const message = decoded.headers[":error-message"]?.value;
             return yield* ProviderShared.eventError(route, [code, message].filter((value) => typeof value === "string").join(": ") ||
-                "Bedrock Converse event-stream error");
+                "Bedrock Converse event-stream error", body);
         }
         const eventType = messageType === "event"
             ? decoded.headers[":event-type"]?.value
@@ -47,16 +50,22 @@ const consumeFrames = (route) => (state, chunk) => Effect.gen(function* () {
                 : undefined;
         if (typeof eventType !== "string")
             continue;
-        const payload = utf8.decode(decoded.body);
         if (!payload)
             continue;
         // The AWS event stream pads short payloads with a `p` field. Drop it
         // before handing the object to the chunk schema. JSON decode goes
         // through the shared Schema-driven codec to satisfy the package rule
         // against ad-hoc `JSON.parse` calls.
-        const parsed = (yield* ProviderShared.parseJson(route, payload, "Failed to parse Bedrock Converse event-stream payload"));
+        const parsed = (yield* ProviderShared.parseJson(route, payload, "Failed to parse Bedrock Converse event-stream payload").pipe(Effect.mapError((error) => new AIError({
+            reason: AIErrorReason.make({ ...error.reason, message: error.message, cause: error.reason.cause, body }),
+        }))));
         delete parsed.p;
-        out.push(messageType === "exception" ? { exception: { type: eventType, details: parsed } } : { [eventType]: parsed });
+        out.push({
+            ...(messageType === "exception"
+                ? { exception: { type: eventType, details: parsed } }
+                : { [eventType]: parsed }),
+            rawBody: body,
+        });
     }
     return [cursor, out];
 });
@@ -68,6 +77,7 @@ const consumeFrames = (route) => (state, chunk) => Effect.gen(function* () {
  */
 export const framing = (route) => ({
     id: "aws-event-stream",
+    body: (frame) => ("rawBody" in frame && typeof frame.rawBody === "string" ? frame.rawBody : undefined),
     frame: (bytes) => bytes.pipe(Stream.mapAccumEffect(() => initialFrameBuffer, consumeFrames(route))),
 });
 export * as BedrockEventStream from "./bedrock-event-stream.js";

package/dist/protocols/gemini.d.ts

@@ -175,6 +175,7 @@ export declare const protocol: Protocol<{
         readonly maxOutputTokens?: number | undefined;
     } | undefined;
 }, string, {
+    readonly error?: unknown;
     readonly candidates?: readonly {
         readonly content?: {
             readonly parts?: readonly unknown[] | null | undefined;

package/dist/protocols/gemini.js

@@ -5,7 +5,8 @@ import { Auth } from "../route/auth.js";
 import { Endpoint } from "../route/endpoint.js";
 import { Framing } from "../route/framing.js";
 import { Protocol } from "../route/protocol.js";
-import { LLMEvent, Usage, } from "../schema/index.js";
+import { AIError, LLMEvent, Usage, } from "../schema/index.js";
+import { classifyProviderFailure } from "../provider-error.js";
 import { JsonObject, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { GeminiToolSchema } from "./utils/gemini-tool-schema.js";
 import { Lifecycle } from "./utils/lifecycle.js";
@@ -151,6 +152,7 @@ const GeminiPromptFeedback = Schema.StructWithRest(Schema.Struct({
     safetyRatings: optionalNull(Schema.Unknown),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
 const GeminiEvent = Schema.Struct({
+    error: Schema.optional(Schema.Unknown),
     candidates: optionalNull(Schema.Array(GeminiCandidate)),
     promptFeedback: optionalNull(GeminiPromptFeedback),
     usageMetadata: optionalNull(GeminiUsage),
@@ -479,6 +481,16 @@ const finish = (state) => {
     return events;
 };
 const step = (state, event) => {
+    if (ProviderShared.isRecord(event.error) && typeof event.error.message === "string") {
+        const body = ProviderShared.encodeJson(event);
+        return Effect.fail(new AIError({
+            reason: classifyProviderFailure({
+                message: event.error.message,
+                status: typeof event.error.code === "number" ? event.error.code : undefined,
+                rawBody: body,
+            }),
+        }));
+    }
     const nextState = {
         ...state,
         promptFeedback: event.promptFeedback ?? state.promptFeedback,

package/dist/protocols/google-images.js

@@ -2,7 +2,7 @@ import { Effect, Encoding, Schema } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
 import { GeneratedImage, ImageModel, ImageResponse, } from "../image.js";
 import { Auth } from "../route/auth.js";
-import { InvalidProviderOutputReason, AIError, Usage, mergeHttpOptions, mergeJsonRecords, } from "../schema/index.js";
+import { AIError, Usage, mergeHttpOptions, mergeJsonRecords } from "../schema/index.js";
 import { ProviderShared } from "./shared.js";
 import { ImageInputs } from "./utils/image-input.js";
 const ADAPTER = "google-images";
@@ -58,11 +58,6 @@ const nativeOptions = (options) => {
         thinkingConfig: Object.values(thinkingConfig).some((value) => value !== undefined) ? thinkingConfig : undefined,
     }, native) ?? { responseModalities: ["IMAGE"] });
 };
-const invalidOutput = (message, providerMetadata) => new AIError({
-    module: ADAPTER,
-    method: "generate",
-    reason: new InvalidProviderOutputReason({ message, route: ADAPTER, providerMetadata }),
-});
 const applyQuery = (url, query) => {
     if (!query)
         return url;
@@ -90,8 +85,8 @@ export const model = (input) => {
                 headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
             });
             const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(text, "application/json")));
-            const payload = yield* response.json.pipe(Effect.mapError(() => invalidOutput("Failed to read the Google Images response")));
-            const decoded = yield* Schema.decodeUnknownEffect(GoogleImageResponse)(payload).pipe(Effect.mapError(() => invalidOutput("Google Images returned an invalid response")));
+            const output = yield* ProviderShared.imageResponse(ADAPTER, "Google Images", response);
+            const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(GoogleImageResponse))(output.body).pipe(Effect.mapError((cause) => output.invalid("Google Images returned an invalid response", cause)));
             const candidates = decoded.candidates ?? [];
             const candidateMetadata = candidates.map((candidate, candidateIndex) => ({
                 index: candidate.index ?? candidateIndex,
@@ -117,7 +112,7 @@ export const model = (input) => {
             const encoded = candidates.flatMap((candidate, candidateIndex) => (candidate.content?.parts ?? []).flatMap((part, partIndex) => part.inlineData === undefined || part.thought === true
                 ? []
                 : [{ candidate, candidateIndex, partIndex, inlineData: part.inlineData }]));
-            const images = yield* Effect.forEach(encoded, (item) => Effect.fromResult(Encoding.decodeBase64(item.inlineData.data)).pipe(Effect.mapError(() => invalidOutput(`Google Images candidate ${item.candidateIndex} part ${item.partIndex} contains invalid base64 data`)), Effect.map((data) => new GeneratedImage({
+            const images = yield* Effect.forEach(encoded, (item) => Effect.fromResult(Encoding.decodeBase64(item.inlineData.data)).pipe(Effect.mapError((cause) => output.invalid(`Google Images candidate ${item.candidateIndex} part ${item.partIndex} contains invalid base64 data`, cause)), Effect.map((data) => new GeneratedImage({
                 mediaType: item.inlineData.mimeType,
                 data,
                 providerMetadata: {
@@ -134,12 +129,7 @@ export const model = (input) => {
             }))));
             if (images.length === 0) {
                 const finishReasons = candidates.flatMap((candidate) => candidate.finishReason === undefined ? [] : [candidate.finishReason]);
-                return yield* invalidOutput(`Google Images returned no final images${finishReasons.length === 0 ? "" : ` (finish reasons: ${finishReasons.join(", ")})`}; inspect reason.providerMetadata.google for prompt feedback and candidate details`, {
-                    google: {
-                        promptFeedback: decoded.promptFeedback,
-                        candidates: candidateMetadata,
-                    },
-                });
+                return yield* output.invalid(`Google Images returned no final images${finishReasons.length === 0 ? "" : ` (finish reasons: ${finishReasons.join(", ")})`}; inspect body for prompt feedback and candidate details`);
             }
             const usage = decoded.usageMetadata;
             const outputTokens = usage?.candidatesTokenCount === undefined
@@ -177,14 +167,14 @@ const googleImagePart = (image) => {
     if (image.type === "file-uri")
         return Effect.succeed({ fileData: { mimeType: image.mediaType, fileUri: image.uri } });
     if (image.type === "url")
-        return ImageInputs.decodeDataUrl(image.url, ADAPTER).pipe(Effect.flatMap((decoded) => {
+        return ImageInputs.decodeDataUrl(image.url).pipe(Effect.flatMap((decoded) => {
             if (decoded === undefined)
-                return Effect.fail(ImageInputs.invalid(ADAPTER, "Google generateContent does not fetch public image URLs; use bytes, a data URL, or a Gemini file URI"));
+                return Effect.fail(ImageInputs.invalid("Google generateContent does not fetch public image URLs; use bytes, a data URL, or a Gemini file URI"));
             return Effect.succeed({
                 inlineData: { mimeType: decoded.mediaType, data: Encoding.encodeBase64(decoded.data) },
             });
         }));
-    return Effect.fail(ImageInputs.invalid(ADAPTER, "Google generateContent requires Gemini file URIs rather than provider file IDs"));
+    return Effect.fail(ImageInputs.invalid("Google generateContent requires Gemini file URIs rather than provider file IDs"));
 };
 export const GoogleImages = {
     model,

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

@@ -28,15 +28,15 @@ const driver = (options, body) => {
             return { message: body, mode: "full" };
         }),
         observe: (_create, frame) => Effect.gen(function* () {
-            const event = yield* decodeEvent(frame).pipe(Effect.mapError(() => ProviderShared.eventError(options.id, `Invalid ${options.name} WebSocket event`, frame)));
+            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") {
                 terminal = true;
-                yield* OpenResponses.decodeKnownErrorEvent(event).pipe(Effect.mapError(() => ProviderShared.eventError(options.id, `${options.name} returned a malformed error event`, frame)));
+                yield* OpenResponses.decodeKnownErrorEvent(event).pipe(Effect.mapError((cause) => ProviderShared.eventError(options.id, `${options.name} returned a malformed error event`, frame, cause)));
                 return {
                     type: "provider-failure",
-                    error: OpenResponses.providerFailure(options.id, event, `${options.name} stream error`),
+                    error: OpenResponses.providerFailure(event, `${options.name} stream error`, frame),
                 };
             }
             if (event.type === "response.failed") {
@@ -45,7 +45,7 @@ const driver = (options, body) => {
                     return yield* ProviderShared.eventError(options.id, `${options.name} response ID changed during execution`, frame);
                 return {
                     type: "provider-failure",
-                    error: OpenResponses.providerFailure(options.id, event, `${options.name} response failed`),
+                    error: OpenResponses.providerFailure(event, `${options.name} response failed`, frame),
                 };
             }
             if (event.type === "response.created") {
@@ -110,9 +110,10 @@ export const transport = (options) => {
                 channel,
             };
         }),
-        execute: (prepared, request, runtime, executeOptions) => {
+        execute: (prepared, request, runtime, executeOptions) => Effect.gen(function* () {
             if (!executeOptions?.webSocket || !prepared.channel)
-                return http.execute(prepared.http, request, runtime);
+                return yield* http.execute(prepared.http, request, runtime);
+            let fallbackHttp;
             const exchange = {
                 id: request.id ?? "request",
                 connect: {
@@ -120,11 +121,21 @@ export const transport = (options) => {
                     headers: prepared.channel.headers,
                     rotateAfterMs: prepared.channel.rotateAfterMs,
                 },
-                fallback: () => Stream.unwrap(http.execute(prepared.http, request, runtime).pipe(Effect.map((execution) => execution.frames))),
+                fallback: () => Stream.unwrap(http.execute(prepared.http, request, runtime).pipe(Effect.map((execution) => {
+                    fallbackHttp = execution.http;
+                    return execution.frames;
+                }))),
                 driver: prepared.channel.driver,
             };
-            return executeOptions.webSocket.execute(exchange);
-        },
+            const execution = yield* executeOptions.webSocket.execute(exchange);
+            return {
+                frames: execution.frames,
+                complete: execution.complete,
+                get http() {
+                    return fallbackHttp ?? execution.http;
+                },
+            };
+        }),
     };
 };
 export const OpenResponsesChannel = { transport };

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

@@ -1,4 +1,4 @@
-import { AIError, TransportReason } from "../schema/index.js";
+import { AIError, TransportError } from "../schema/index.js";
 import { Effect, Option, Schema } from "effect";
 import * as ProviderShared from "./shared.js";
 import { OpenResponses } from "./open-responses.js";
@@ -81,14 +81,15 @@ const incremental = (request, checkpoint) => {
     return input.slice(baseline.length);
 };
 const code = (event) => event.code || event.error?.code || event.response?.error?.code || undefined;
-const rejected = (input, observation, recovery) => ({
+const rejected = (observation, recovery) => ({
     type: "rejected",
     recovery,
     error: new AIError({
-        module: input.id,
-        method: "stream",
-        reason: new TransportReason({
+        reason: new TransportError({
             message: observation.error.message,
+            body: observation.error.reason.body,
+            http: observation.error.reason.http,
+            cause: observation.error.reason.cause,
             transport: "websocket",
             operation: "read",
             phase: "receive",
@@ -113,16 +114,16 @@ export const driver = (input) => {
             };
         }),
         observe: (create, frame) => Effect.gen(function* () {
-            const event = yield* decodeEvent(frame).pipe(Effect.mapError(() => ProviderShared.eventError(input.id, `Invalid ${input.name} WebSocket event`, frame)));
+            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);
             if (observation.type === "provider-failure") {
                 const rejection = code(event);
                 if (rejection === "previous_response_not_found")
-                    return rejected(input, observation, "retry-full");
+                    return rejected(observation, "retry-full");
                 if (rejection === "websocket_connection_limit_reached")
-                    return rejected(input, observation, "rotate-and-retry-full");
+                    return rejected(observation, "rotate-and-retry-full");
             }
             if (observation.type !== "completed")
                 return observation;

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

@@ -565,15 +565,19 @@ export interface ParserState {
     readonly name: string;
     readonly providerMetadataKey: string;
     readonly tools: ToolStream.State<string>;
+    readonly completedTools: ReadonlySet<string>;
     readonly hasFunctionCall: boolean;
     readonly lifecycle: Lifecycle.State;
     readonly outputItems: Readonly<Record<number, string>>;
-    readonly messageItems: ReadonlySet<string>;
-    readonly messagePhases: Readonly<Record<string, MessagePhase | null>>;
+    readonly message: {
+        readonly id: string;
+        readonly phase: MessagePhase | null | undefined;
+    } | undefined;
     readonly reasoningItems: Readonly<Record<string, ReasoningStreamItem>>;
 }
 type ReasoningSummaryStatus = "active" | "can-conclude" | "concluded";
 interface ReasoningStreamItem {
+    readonly open: boolean;
     readonly encryptedContent: string | null | undefined;
     readonly summaryParts: Readonly<Record<number, ReasoningSummaryStatus>>;
     readonly deltaIndexes: ReadonlySet<number>;
@@ -804,7 +808,7 @@ export declare const terminal: (event: Event) => boolean;
 export declare const outputItemID: (state: ParserState, event: Event) => string | undefined;
 export declare const onReasoningDelta: (state: ParserState, event: Event, itemID: string) => StepResult;
 export declare const onReasoningDone: (state: ParserState, event: Event, itemID: string) => StepResult;
-export declare const providerFailure: (id: string, event: Event, fallback: string) => AIError;
+export declare const providerFailure: (event: Event, fallback: string, body?: string) => AIError;
 export declare const step: (state: ParserState, input: Event) => AIError | Effect.Effect<[ParserState, readonly ({
     readonly type: "step-start";
     readonly index: number;
@@ -828,6 +832,7 @@ export declare const step: (state: ParserState, input: Event) => AIError | Effec
 } | {
     readonly id: string;
     readonly type: "text-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -853,6 +858,7 @@ export declare const step: (state: ParserState, input: Event) => AIError | Effec
 } | {
     readonly id: string;
     readonly type: "reasoning-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;