@opencode/ai 2.0.10 → 2.0.11

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

@@ -190,16 +190,10 @@ export declare const protocol: Protocol<{
     readonly [x: string]: unknown;
     readonly type: string;
     readonly status?: unknown;
-    readonly code?: string | null | undefined;
-    readonly message?: string | undefined;
-    readonly headers?: unknown;
+    readonly code?: unknown;
+    readonly message?: 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 error?: unknown;
     readonly item?: {
         readonly [x: string]: unknown;
         readonly type: string;
@@ -224,12 +218,7 @@ export declare const protocol: Protocol<{
             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 error?: unknown;
         readonly usage?: {
             readonly input_tokens?: number | undefined;
             readonly output_tokens?: number | undefined;
@@ -248,10 +237,9 @@ export declare const protocol: Protocol<{
         } | 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;
+    readonly status_code?: unknown;
 }, OpenResponses.ParserState>;
 export * as AlibabaResponses from "./alibaba-responses.js";

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

@@ -219,16 +219,10 @@ export declare const protocol: Protocol<{
     readonly [x: string]: unknown;
     readonly type: string;
     readonly status?: unknown;
-    readonly code?: string | null | undefined;
-    readonly message?: string | undefined;
-    readonly headers?: unknown;
+    readonly code?: unknown;
+    readonly message?: 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 error?: unknown;
     readonly item?: {
         readonly [x: string]: unknown;
         readonly type: string;
@@ -253,12 +247,7 @@ export declare const protocol: Protocol<{
             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 error?: unknown;
         readonly usage?: {
             readonly input_tokens?: number | undefined;
             readonly output_tokens?: number | undefined;
@@ -277,11 +266,10 @@ export declare const protocol: Protocol<{
         } | 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;
+    readonly status_code?: unknown;
 }, ParserState>;
 export declare const httpTransport: HttpTransport.HttpJsonTransport<{
     readonly input: readonly ({

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

@@ -32,7 +32,6 @@ const driver = (options, body) => {
                 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((cause) => ProviderShared.eventError(options.id, `${options.name} returned a malformed error event`, frame, cause)));
                 return {
                     type: "provider-failure",
                     error: OpenResponses.providerFailure(event, `${options.name} stream error`, frame),

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

@@ -83,7 +83,7 @@ const incremental = (request, checkpoint) => {
         return undefined;
     return input.slice(baseline.length);
 };
-const code = (event) => event.code || event.error?.code || event.response?.error?.code || undefined;
+const code = (event) => OpenResponses.errorDetail(event).code;
 const rejected = (observation, recovery) => ({
     type: "rejected",
     recovery,

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

@@ -564,45 +564,7 @@ export type StreamItem = Schema.Schema.Type<typeof StreamItem>;
 export type OutputItem = StreamItem & {
     readonly id: string;
 };
-export declare const WebSocketErrorEvent: Schema.StructWithRest<Schema.Struct<{
-    readonly type: Schema.tag<"error">;
-    readonly status: Schema.optional<Schema.Number>;
-    readonly status_code: Schema.optional<Schema.Number>;
-    readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
-    readonly message: Schema.optional<Schema.String>;
-    readonly param: Schema.optional<Schema.NullOr<Schema.String>>;
-    readonly error: Schema.optional<Schema.NullOr<Schema.decodeTo<Schema.Struct<{
-        readonly type: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly message: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly param: Schema.optional<Schema.NullOr<Schema.String>>;
-    }>, Schema.Union<readonly [Schema.String, Schema.Struct<{
-        readonly type: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly message: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly param: Schema.optional<Schema.NullOr<Schema.String>>;
-    }>]>, never, never>>>;
-    readonly headers: Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Number, Schema.Boolean]>>>;
-}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
-export declare const decodeKnownErrorEvent: (event: Event) => Effect.Effect<{
-    readonly [x: string]: unknown;
-    readonly type: "error";
-    readonly status?: number | undefined;
-    readonly code?: string | null | undefined;
-    readonly message?: string | undefined;
-    readonly headers?: {
-        readonly [x: string]: string | number | boolean;
-    } | 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 param?: string | null | undefined;
-    readonly status_code?: number | undefined;
-}, Schema.SchemaError, never>;
-export declare const Event: Schema.decodeTo<Schema.toType<Schema.StructWithRest<Schema.Struct<{
+export declare const Event: Schema.StructWithRest<Schema.Struct<{
     readonly type: Schema.String;
     readonly delta: Schema.optional<Schema.String>;
     readonly arguments: Schema.optional<Schema.String>;
@@ -646,131 +608,31 @@ export declare const Event: Schema.decodeTo<Schema.toType<Schema.StructWithRest<
             }>>>;
             readonly total_tokens: Schema.optional<Schema.Number>;
         }>>>;
-        readonly error: Schema.optional<Schema.NullOr<Schema.decodeTo<Schema.Struct<{
-            readonly type: Schema.optional<Schema.NullOr<Schema.String>>;
-            readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
-            readonly message: Schema.optional<Schema.NullOr<Schema.String>>;
-            readonly param: Schema.optional<Schema.NullOr<Schema.String>>;
-        }>, Schema.Union<readonly [Schema.String, Schema.Struct<{
-            readonly type: Schema.optional<Schema.NullOr<Schema.String>>;
-            readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
-            readonly message: Schema.optional<Schema.NullOr<Schema.String>>;
-            readonly param: Schema.optional<Schema.NullOr<Schema.String>>;
-        }>]>, never, never>>>;
-    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
-    readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
-    readonly message: Schema.optional<Schema.String>;
-    readonly param: Schema.optional<Schema.NullOr<Schema.String>>;
-    readonly error: Schema.optional<Schema.NullOr<Schema.decodeTo<Schema.Struct<{
-        readonly type: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly message: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly param: Schema.optional<Schema.NullOr<Schema.String>>;
-    }>, Schema.Union<readonly [Schema.String, Schema.Struct<{
-        readonly type: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly message: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly param: Schema.optional<Schema.NullOr<Schema.String>>;
-    }>]>, never, never>>>;
-    readonly status: Schema.optional<Schema.Unknown>;
-    readonly status_code: Schema.optional<Schema.Unknown>;
-    readonly headers: Schema.optional<Schema.Unknown>;
-}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>, Schema.StructWithRest<Schema.Struct<{
-    readonly type: Schema.String;
-    readonly delta: Schema.optional<Schema.String>;
-    readonly arguments: Schema.optional<Schema.String>;
-    readonly text: Schema.optional<Schema.String>;
-    readonly item_id: Schema.optional<Schema.String>;
-    readonly output_index: Schema.optional<Schema.Number>;
-    readonly summary_index: Schema.optional<Schema.Number>;
-    readonly item: Schema.optional<Schema.NullOr<Schema.StructWithRest<Schema.Struct<{
-        readonly type: Schema.String;
-        readonly id: Schema.optional<Schema.String>;
-        readonly call_id: Schema.optional<Schema.String>;
-        readonly name: Schema.optional<Schema.String>;
-        readonly namespace: Schema.optional<Schema.String>;
-        readonly arguments: Schema.optional<Schema.String>;
-        readonly encrypted_content: Schema.optional<Schema.NullOr<Schema.String>>;
-    }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
-    readonly response: Schema.optional<Schema.StructWithRest<Schema.Struct<{
-        readonly id: Schema.optional<Schema.String>;
-        readonly service_tier: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly incomplete_details: Schema.optional<Schema.NullOr<Schema.Struct<{
-            readonly reason: Schema.optional<Schema.String>;
-        }>>>;
-        readonly output: Schema.optional<Schema.$Array<Schema.StructWithRest<Schema.Struct<{
-            readonly type: Schema.String;
-            readonly id: Schema.optional<Schema.String>;
-            readonly call_id: Schema.optional<Schema.String>;
-            readonly name: Schema.optional<Schema.String>;
-            readonly namespace: Schema.optional<Schema.String>;
-            readonly arguments: Schema.optional<Schema.String>;
-            readonly encrypted_content: Schema.optional<Schema.NullOr<Schema.String>>;
-        }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>>;
-        readonly usage: Schema.optional<Schema.NullOr<Schema.Struct<{
-            readonly input_tokens: Schema.optional<Schema.Number>;
-            readonly input_tokens_details: Schema.optional<Schema.NullOr<Schema.Struct<{
-                readonly cached_tokens: Schema.optional<Schema.Number>;
-                readonly cache_write_tokens: Schema.optional<Schema.Number>;
-            }>>>;
-            readonly output_tokens: Schema.optional<Schema.Number>;
-            readonly output_tokens_details: Schema.optional<Schema.NullOr<Schema.Struct<{
-                readonly reasoning_tokens: Schema.optional<Schema.Number>;
-            }>>>;
-            readonly total_tokens: Schema.optional<Schema.Number>;
-        }>>>;
-        readonly error: Schema.optional<Schema.NullOr<Schema.decodeTo<Schema.Struct<{
-            readonly type: Schema.optional<Schema.NullOr<Schema.String>>;
-            readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
-            readonly message: Schema.optional<Schema.NullOr<Schema.String>>;
-            readonly param: Schema.optional<Schema.NullOr<Schema.String>>;
-        }>, Schema.Union<readonly [Schema.String, Schema.Struct<{
-            readonly type: Schema.optional<Schema.NullOr<Schema.String>>;
-            readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
-            readonly message: Schema.optional<Schema.NullOr<Schema.String>>;
-            readonly param: Schema.optional<Schema.NullOr<Schema.String>>;
-        }>]>, never, never>>>;
+        readonly error: Schema.optional<Schema.Unknown>;
     }>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>>;
-    readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
-    readonly message: Schema.optional<Schema.String>;
-    readonly param: Schema.optional<Schema.NullOr<Schema.String>>;
-    readonly error: Schema.optional<Schema.NullOr<Schema.decodeTo<Schema.Struct<{
-        readonly type: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly message: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly param: Schema.optional<Schema.NullOr<Schema.String>>;
-    }>, Schema.Union<readonly [Schema.String, Schema.Struct<{
-        readonly type: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly code: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly message: Schema.optional<Schema.NullOr<Schema.String>>;
-        readonly param: Schema.optional<Schema.NullOr<Schema.String>>;
-    }>]>, never, never>>>;
+    readonly code: Schema.optional<Schema.Unknown>;
+    readonly message: Schema.optional<Schema.Unknown>;
+    readonly error: Schema.optional<Schema.Unknown>;
     readonly status: Schema.optional<Schema.Unknown>;
     readonly status_code: Schema.optional<Schema.Unknown>;
-    readonly headers: Schema.optional<Schema.Unknown>;
-}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>, never, never>;
+}>, readonly [Schema.$Record<Schema.String, Schema.Unknown>]>;
 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.
+ * Decodes one WebSocket frame. Some providers and gateways answer a rejected `response.create` with a bare
+ * `{ "error": ... }` envelope and no event type; that reads as an error event so it 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 code?: unknown;
+    readonly message?: 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 error?: unknown;
     readonly item?: {
         readonly [x: string]: unknown;
         readonly type: string;
@@ -795,12 +657,7 @@ export declare const decodeChannelEvent: (frame: string) => Effect.Effect<{
             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 error?: unknown;
         readonly usage?: {
             readonly input_tokens?: number | undefined;
             readonly output_tokens?: number | undefined;
@@ -819,11 +676,10 @@ export declare const decodeChannelEvent: (frame: string) => Effect.Effect<{
         } | 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;
+    readonly status_code?: unknown;
 }, Schema.SchemaError, never>;
 export interface ProviderAdapter {
     readonly id: string;
@@ -1146,6 +1002,11 @@ export declare const terminal: (event: Event) => boolean;
 export declare const normalize: (state: Pick<ParserState, "outputItems">, input: Event) => NormalizedEvent;
 export declare const onReasoningDelta: (state: ParserState, event: Event, itemID: string) => StepResult;
 export declare const onReasoningDone: (state: ParserState, event: Event, itemID: string) => StepResult;
+/** Error code and message from wherever the frame put them; top-level fields win over nested ones. */
+export declare const errorDetail: (event: Event) => {
+    message: string | undefined;
+    code: string | undefined;
+};
 export declare const providerFailure: (event: Event, fallback: string, body?: string) => AIError;
 export declare const step: (state: ParserState, event: NormalizedEvent) => AIError | Effect.Effect<[ParserState, readonly (({
     readonly type: "compaction";
@@ -1525,16 +1386,10 @@ export declare const protocol: Protocol<{
     readonly [x: string]: unknown;
     readonly type: string;
     readonly status?: unknown;
-    readonly code?: string | null | undefined;
-    readonly message?: string | undefined;
-    readonly headers?: unknown;
+    readonly code?: unknown;
+    readonly message?: 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 error?: unknown;
     readonly item?: {
         readonly [x: string]: unknown;
         readonly type: string;
@@ -1559,12 +1414,7 @@ export declare const protocol: Protocol<{
             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 error?: unknown;
         readonly usage?: {
             readonly input_tokens?: number | undefined;
             readonly output_tokens?: number | undefined;
@@ -1583,11 +1433,10 @@ export declare const protocol: Protocol<{
         } | 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;
+    readonly status_code?: unknown;
 }, ParserState>;
 export declare const httpTransport: HttpTransport.HttpJsonTransport<{
     readonly input: readonly ({

package/dist/protocols/open-responses.js

@@ -1,4 +1,4 @@
-import { Effect, Option, Schema, SchemaGetter } from "effect";
+import { Effect, Option, Schema } from "effect";
 import { HttpTransport } from "../route/transport/index.js";
 import { Protocol } from "../route/protocol.js";
 import { AIError, LLMEvent, ProviderInternalError, Usage, } from "../schema/index.js";
@@ -237,39 +237,12 @@ export const StreamItem = Schema.StructWithRest(Schema.Struct({
     arguments: Schema.optional(Schema.String),
     encrypted_content: optionalNull(Schema.String),
 }), [Schema.Record(Schema.String, Schema.Unknown)]);
-// Responses-compatible providers put streaming error details at the top level or
-// under `error`, and response failures under `response.error`. Accept all three shapes.
+// Responses-compatible providers put error details at the top level, under `error`, or under
+// `response.error`, and gateways reshape them freely: strings, numeric codes, extra fields. Those
+// fields decode as opaque values and `errorDetail` reads them defensively, so an error frame can
+// only fail on invalid JSON and otherwise always classifies with the raw body as the fallback.
 // https://www.openresponses.org/specification
-const OpenResponsesErrorObject = Schema.Struct({
-    type: optionalNull(Schema.String),
-    code: optionalNull(Schema.String),
-    message: optionalNull(Schema.String),
-    param: optionalNull(Schema.String),
-});
-const OpenResponsesErrorPayload = Schema.Union([Schema.String, OpenResponsesErrorObject]).pipe(Schema.decodeTo(OpenResponsesErrorObject, {
-    decode: SchemaGetter.transform((error) => (typeof error === "string" ? { message: error } : error)),
-    encode: SchemaGetter.passthrough(),
-}));
-const WebSocketErrorHeader = Schema.Union([Schema.String, Schema.Number, Schema.Boolean]);
-export const WebSocketErrorEvent = Schema.StructWithRest(Schema.Struct({
-    type: Schema.tag("error"),
-    status: Schema.optional(Schema.Number),
-    status_code: Schema.optional(Schema.Number),
-    code: optionalNull(Schema.String),
-    message: Schema.optional(Schema.String),
-    param: optionalNull(Schema.String),
-    error: optionalNull(OpenResponsesErrorPayload),
-    headers: Schema.optional(Schema.Record(Schema.String, WebSocketErrorHeader)),
-}), [Schema.Record(Schema.String, Schema.Unknown)]);
-const decodeWebSocketErrorEvent = Schema.decodeUnknownEffect(WebSocketErrorEvent);
-export const decodeKnownErrorEvent = (event) => decodeWebSocketErrorEvent({
-    ...event,
-    status: typeof event.status === "number" ? event.status : undefined,
-    status_code: typeof event.status_code === "number" ? event.status_code : undefined,
-    headers: ProviderShared.isRecord(event.headers)
-        ? Object.fromEntries(Object.entries(event.headers).filter((entry) => typeof entry[1] === "string" || typeof entry[1] === "number" || typeof entry[1] === "boolean"))
-        : undefined,
-});
+const asText = (value) => typeof value === "string" && value.length > 0 ? value : typeof value === "number" ? String(value) : undefined;
 export const Event = Schema.StructWithRest(Schema.Struct({
     type: Schema.String,
     delta: Schema.optional(Schema.String),
@@ -286,36 +259,22 @@ export const Event = Schema.StructWithRest(Schema.Struct({
         incomplete_details: optionalNull(Schema.Struct({ reason: Schema.optional(Schema.String) })),
         output: Schema.optional(Schema.Array(StreamItem)),
         usage: optionalNull(OpenResponsesUsage),
-        error: optionalNull(OpenResponsesErrorPayload),
+        error: Schema.optional(Schema.Unknown),
     }), [Schema.Record(Schema.String, Schema.Unknown)])),
-    code: optionalNull(Schema.String),
-    message: Schema.optional(Schema.String),
-    param: optionalNull(Schema.String),
-    error: optionalNull(OpenResponsesErrorPayload),
+    code: Schema.optional(Schema.Unknown),
+    message: Schema.optional(Schema.Unknown),
+    error: Schema.optional(Schema.Unknown),
     status: Schema.optional(Schema.Unknown),
     status_code: Schema.optional(Schema.Unknown),
-    headers: Schema.optional(Schema.Unknown),
-}), [Schema.Record(Schema.String, Schema.Unknown)]).pipe(Schema.decode({
-    decode: SchemaGetter.transform((event) => {
-        if (event.type !== "error" || event.error != null)
-            return event;
-        const { code, message, param, ...rest } = event;
-        if (code === undefined && message === undefined && param === undefined)
-            return event;
-        // Flat errors (for example, Meta's) can also arrive through generic Responses endpoints.
-        return { ...rest, error: { code, message, param } };
-    }),
-    encode: SchemaGetter.passthrough(),
-}));
+}), [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.
+ * Decodes one WebSocket frame. Some providers and gateways answer a rejected `response.create` with a bare
+ * `{ "error": ... }` envelope and no event type; that reads as an error event so it classifies instead of
+ * failing decoding.
  */
-export const decodeChannelEvent = (frame) => decodeFrame(frame).pipe(Effect.flatMap((value) => decodeEventValue(ProviderShared.isRecord(value) &&
-    value.type === undefined &&
-    (typeof value.error === "string" || ProviderShared.isRecord(value.error))
+export const decodeChannelEvent = (frame) => decodeFrame(frame).pipe(Effect.flatMap((value) => decodeEventValue(ProviderShared.isRecord(value) && value.type === undefined && value.error != null
     ? { ...value, type: "error" }
     : value)));
 const BASE_ADAPTER = { id: ADAPTER, name: NAME };
@@ -1121,22 +1080,20 @@ const onResponseFinish = Effect.fn("OpenResponses.onResponseFinish")(function* (
     });
     return [{ ...current, lifecycle }, events];
 });
-// Build the prettiest summary available from whatever the provider supplied.
-// When both code and message are present, prefix the code so consumers see
-// the failure mode (e.g. `rate_limit_exceeded: Slow down`) instead of just
-// the bare message — production rate limits and context-length failures used
-// to be indistinguishable from generic stream drops. Returns undefined when
-// the payload carries no usable summary.
-const providerErrorMessage = (event, nested) => {
-    const message = event.message || nested?.message || undefined;
-    const code = event.code || nested?.code || undefined;
-    if (message && code)
-        return `${code}: ${message}`;
-    return message || code;
+/** Error code and message from wherever the frame put them; top-level fields win over nested ones. */
+export const errorDetail = (event) => {
+    const raw = event.error ?? event.response?.error;
+    const nested = typeof raw === "string" ? { message: raw } : ProviderShared.isRecord(raw) ? raw : undefined;
+    return {
+        message: asText(event.message) ?? asText(nested?.message),
+        code: asText(event.code) ?? asText(nested?.code),
+    };
 };
+// Prefix the code when both are present (`rate_limit_exceeded: Slow down`) so the failure mode is
+// visible; fall back to the raw frame rather than a generic message when neither decodes.
 export const providerFailure = (event, fallback, body = ProviderShared.encodeJson(event)) => {
-    const nested = event.error ?? event.response?.error ?? undefined;
-    const summary = providerErrorMessage(event, nested);
+    const detail = errorDetail(event);
+    const summary = detail.message && detail.code ? `${detail.code}: ${detail.message}` : (detail.message ?? detail.code);
     const message = summary ?? (body === "{}" ? fallback : body);
     const status = typeof event.status === "number"
         ? event.status
@@ -1210,7 +1167,7 @@ export const step = (state, event) => {
     if (event.type === "response.failed")
         return providerFailure(event, `${state.name} response failed`);
     if (event.type === "error")
-        return decodeKnownErrorEvent(event).pipe(Effect.mapError((cause) => ProviderShared.eventError(state.id, `${state.name} returned a malformed error event`, ProviderShared.encodeJson(event), cause)), Effect.flatMap(() => providerFailure(event, `${state.name} stream error`)));
+        return providerFailure(event, `${state.name} stream error`);
     return Effect.succeed([state, NO_EVENTS]);
 };
 // =============================================================================

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

@@ -450,16 +450,10 @@ export declare const protocol: Protocol<{
     readonly [x: string]: unknown;
     readonly type: string;
     readonly status?: unknown;
-    readonly code?: string | null | undefined;
-    readonly message?: string | undefined;
-    readonly headers?: unknown;
+    readonly code?: unknown;
+    readonly message?: 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 error?: unknown;
     readonly item?: {
         readonly [x: string]: unknown;
         readonly type: string;
@@ -484,12 +478,7 @@ export declare const protocol: Protocol<{
             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 error?: unknown;
         readonly usage?: {
             readonly input_tokens?: number | undefined;
             readonly output_tokens?: number | undefined;
@@ -508,11 +497,10 @@ export declare const protocol: Protocol<{
         } | 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;
+    readonly status_code?: unknown;
 }, OpenResponses.ParserState>;
 export declare const httpTransport: HttpTransport.HttpJsonTransport<{
     readonly input: readonly ({

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

@@ -184,16 +184,10 @@ export declare const protocol: Protocol<{
     readonly [x: string]: unknown;
     readonly type: string;
     readonly status?: unknown;
-    readonly code?: string | null | undefined;
-    readonly message?: string | undefined;
-    readonly headers?: unknown;
+    readonly code?: unknown;
+    readonly message?: 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 error?: unknown;
     readonly item?: {
         readonly [x: string]: unknown;
         readonly type: string;
@@ -218,12 +212,7 @@ export declare const protocol: Protocol<{
             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 error?: unknown;
         readonly usage?: {
             readonly input_tokens?: number | undefined;
             readonly output_tokens?: number | undefined;
@@ -242,11 +231,10 @@ export declare const protocol: Protocol<{
         } | 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;
+    readonly status_code?: unknown;
 }, OpenResponses.ParserState>;
 export declare const compact: import("../route/client.js").CompactOperation;
 export * as XAIResponses from "./xai-responses.js";

package/dist/route/transport/websocket.js

@@ -145,7 +145,9 @@ export const open = (input) => Effect.gen(function* () {
 });
 export const fromWebSocket = (ws, input) => Effect.gen(function* () {
     yield* waitOpen(ws, input);
-    const messages = yield* Queue.bounded(128);
+    // The socket pushes frames synchronously and cannot be paused, so the hand-off to the consumer
+    // fiber must absorb whole read buffers. Bun delivers over a thousand small frames in one tick.
+    const messages = yield* Queue.unbounded();
     const oversized = (message) => typeof message === "string" ? new Blob([message]).size > MAX_FRAME_BYTES : message.byteLength > MAX_FRAME_BYTES;
     const rejectOversized = (message) => {
         if (!oversized(message))
@@ -164,15 +166,7 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
     const offer = (message) => {
         if (rejectOversized(message))
             return;
-        if (Queue.offerUnsafe(messages, message))
-            return;
-        Queue.failCauseUnsafe(messages, Cause.fail(transportError("WebSocket inbound queue overflow", {
-            body: typeof message === "string" ? message : new TextDecoder().decode(message),
-            url: input.url,
-            operation: "read",
-            code: "queue-overflow",
-            phase: "receive",
-        })));
+        Queue.offerUnsafe(messages, message);
     };
     const onMessage = (event) => {
         if (typeof event.data === "string")

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "2.0.10",
+  "version": "2.0.11",
   "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": "2.0.10",
+    "@opencode/http-recorder": "2.0.11",
     "@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": "2.0.10",
+    "@opencode/schema": "2.0.11",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"