@opencode-ai/ai 0.0.0-dev-18409 → 0.0.0-dev-18411

package/dist/route/executor.js

@@ -1,6 +1,6 @@
 import { Cause, Context, Effect, Layer, Option, Schema, Stream } from "effect";
 import { FetchHttpClient, Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, } from "effect/unstable/http";
-import { HttpContext, HttpRateLimitDetails, HttpRequestDetails, HttpResponseDetails, AIError, TransportReason, } from "../schema/index.js";
+import { HttpContext, HttpRateLimitDetails, AIError, TransportError } from "../schema/index.js";
 import { classifyProviderFailure } from "../provider-error.js";
 export class Service extends Context.Service()("@opencode/AI/RequestExecutor") {
 }
@@ -60,20 +60,11 @@ const rateLimitDetails = (headers, retryAfter) => {
         reset: Object.keys(reset).length === 0 ? undefined : reset,
     });
 };
-const requestDetails = (request) => new HttpRequestDetails({
-    method: request.method,
-    url: request.url,
-    headers: headerDetails(request.headers),
-});
-const responseDetails = (response) => new HttpResponseDetails({
+export const responseHttp = (response) => new HttpContext({
+    url: response.request.url,
     status: response.status,
     headers: headerDetails(response.headers),
 });
-const responseBody = (body) => {
-    if (body === undefined)
-        return {};
-    return { body };
-};
 const decodeProviderBody = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Struct({
     message: Schema.optionalKey(Schema.String),
     error: Schema.optionalKey(Schema.Struct({ message: Schema.optionalKey(Schema.String) })),
@@ -83,60 +74,36 @@ const providerMessage = (status, body) => {
     return ([decoded?.error?.message, decoded?.message].find((message) => message?.trim()) ??
         `Provider request failed with HTTP ${status}`);
 };
-const responseHttp = (input) => new HttpContext({
-    request: requestDetails(input.request),
-    response: responseDetails(input.response),
-    ...input.body,
-    rateLimit: input.rateLimit,
-});
-const statusError = (request) => (response) => Effect.gen(function* () {
+const statusError = (response) => Effect.gen(function* () {
     if (response.status < 400)
         return response;
-    const body = yield* response.text.pipe(Effect.catch(() => Effect.void));
-    const headers = normalizedHeaders(response.headers);
-    const retryAfter = retryAfterMs(headers);
-    const rateLimit = rateLimitDetails(headers, retryAfter);
-    const details = responseBody(body);
-    return yield* new AIError({
-        module: "RequestExecutor",
-        method: "execute",
-        reason: classifyProviderFailure({
-            status: response.status,
-            message: providerMessage(response.status, body),
-            retryAfterMs: retryAfter,
-            rateLimit,
-            http: responseHttp({
-                request,
-                response,
-                body: details,
-                rateLimit,
-            }),
-        }),
+    const result = yield* response.text.pipe(Effect.result);
+    return yield* httpFailure({
+        message: providerMessage(response.status, result._tag === "Success" ? result.success : undefined),
+        url: response.request.url,
+        status: response.status,
+        responseHeaders: headerDetails(response.headers),
+        responseBody: result._tag === "Success" ? result.success : undefined,
+        cause: result._tag === "Failure" ? (result.failure.cause ?? result.failure) : undefined,
     });
 });
-// Classifies an HTTP failure captured outside the executor (for example by the
-// AI SDK's own fetch) onto the same reason types and HttpContext that
-// executor-driven requests produce. The originating request is not available on
-// that path, so the method is assumed (language model calls are always POST),
-// request headers are empty.
-export const classifyHttpFailure = (input) => {
+/** Preserve HTTP diagnostics for executor and externally captured failures alike. */
+export const httpFailure = (input) => {
     const headers = normalizedHeaders(Headers.fromInput(input.responseHeaders));
     const retryAfter = retryAfterMs(headers);
     const rateLimit = rateLimitDetails(headers, retryAfter);
-    const details = responseBody(input.responseBody);
-    return classifyProviderFailure({
-        message: input.message,
-        status: input.status,
-        code: input.code,
-        retryAfterMs: retryAfter,
-        rateLimit,
-        http: new HttpContext({
-            request: new HttpRequestDetails({ method: "POST", url: input.url, headers: {} }),
-            response: input.status === undefined
-                ? undefined
-                : new HttpResponseDetails({ status: input.status, headers: headerDetails(Headers.fromInput(headers)) }),
-            ...details,
+    return new AIError({
+        reason: classifyProviderFailure({
+            message: input.message,
+            status: input.status,
+            data: input.data,
+            rawBody: input.responseBody,
+            retryAfterMs: retryAfter,
             rateLimit,
+            cause: input.cause,
+            http: input.status === undefined || input.url === undefined
+                ? undefined
+                : new HttpContext({ url: input.url, status: input.status, headers }),
         }),
     });
 };
@@ -160,19 +127,18 @@ const nativeTransportFailure = (error) => {
 const httpError = (input) => {
     const request = HttpClientError.isHttpClientError(input.error) ? input.error.request : input.request;
     const transportError = (failure) => new AIError({
-        module: "RequestExecutor",
-        method: input.operation,
-        reason: new TransportReason({
+        reason: new TransportError({
             message: failure.message,
+            cause: source,
+            http: input.http,
             transport: "http",
             operation: input.operation,
             code: failure.code,
             url: request.url,
-            http: new HttpContext({ request: requestDetails(request) }),
         }),
     });
     const source = HttpClientError.isHttpClientError(input.error) && "cause" in input.error.reason
-        ? input.error.reason.cause
+        ? (input.error.reason.cause ?? input.error)
         : input.error;
     const native = nativeTransportFailure(source);
     const code = native?.code;
@@ -194,19 +160,20 @@ const httpError = (input) => {
         code: code ?? input.error.reason._tag,
     });
 };
+export const responseStream = (response) => response.stream.pipe(Stream.mapError((error) => httpError({ error, request: response.request, operation: "read", http: responseHttp(response) })));
 export const stream = (executor, request, middleware) => Stream.unwrap(Effect.gen(function* () {
     const response = yield* executor.execute(request, middleware);
-    return response.stream.pipe(Stream.mapError((error) => httpError({ error, request: response.request, operation: "read" })));
+    return responseStream(response);
 }));
 export const layer = Layer.effect(Service, Effect.gen(function* () {
     const http = yield* HttpClient.HttpClient;
     const executeOnce = (request, middleware) => Effect.gen(function* () {
         if (!middleware)
-            return yield* http.execute(request).pipe(Effect.mapError((error) => httpError({ error, request, operation: "request" })), Effect.flatMap(statusError(request)));
+            return yield* http.execute(request).pipe(Effect.mapError((error) => httpError({ error, request, operation: "request" })), Effect.flatMap(statusError));
         const response = yield* middleware(request, (input) => http
             .execute(input)
             .pipe(Effect.mapError((cause) => (cause instanceof Error ? cause : new Error(String(cause)))))).pipe(Effect.mapError((error) => httpError({ error, request, operation: "request" })));
-        return yield* statusError(response.request)(response);
+        return yield* statusError(response);
     });
     return Service.of({
         execute: executeOnce,

package/dist/route/framing.d.ts

@@ -17,6 +17,8 @@ import type { AIError } from "../schema/index.js";
 export interface Definition<Frame> {
     readonly id: string;
     readonly frame: (bytes: Stream.Stream<Uint8Array, AIError>) => Stream.Stream<Frame, AIError>;
+    /** Original wire representation when framing transforms the provider payload. */
+    readonly body?: (frame: Frame) => string | undefined;
 }
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
 export declare const sse: Definition<string>;

package/dist/route/transport/http.js

@@ -53,8 +53,13 @@ export const httpJson = (input) => ({
             middleware: prepareInput.middleware,
         };
     }),
-    execute: (prepared, _request, runtime) => Effect.succeed({
-        frames: prepared.framing.frame(RequestExecutor.stream(runtime.http, prepared.request, prepared.middleware)),
+    execute: (prepared, _request, runtime) => Effect.gen(function* () {
+        const response = yield* runtime.http.execute(prepared.request, prepared.middleware);
+        return {
+            frames: prepared.framing.frame(RequestExecutor.responseStream(response)),
+            http: RequestExecutor.responseHttp(response),
+            body: prepared.framing.body,
+        };
     }),
 });
 export const sseJson = {

package/dist/route/transport/index.d.ts

@@ -3,12 +3,14 @@ import { Endpoint } from "../endpoint.js";
 import { Auth } from "../auth.js";
 import type { HttpMiddleware, Interface as RequestExecutorInterface } from "../executor.js";
 import type { WebSocketChannelExecutor } from "./websocket-channel.js";
-import type { AIError, LLMRequest } from "../../schema/index.js";
+import type { AIError, HttpContext, LLMRequest } from "../../schema/index.js";
 export interface TransportRuntime {
     readonly http: RequestExecutorInterface;
 }
 export interface TransportExecution<Frame> {
     readonly frames: Stream.Stream<Frame, AIError>;
+    readonly http?: HttpContext;
+    body?(frame: Frame): string | undefined;
     /** Optional successful-consumption acknowledgement. HTTP leaves this absent. */
     readonly complete?: Effect.Effect<void>;
 }

package/dist/route/transport/websocket-channel.d.ts

@@ -1,11 +1,12 @@
 import type { Effect, Scope, Stream } from "effect";
 import type { Headers } from "effect/unstable/http";
-import type { AIError } from "../../schema/index.js";
+import type { AIError, HttpContext } from "../../schema/index.js";
 export interface WebSocketChannelExecutor {
     readonly execute: (exchange: WebSocketChannelExchange) => Effect.Effect<WebSocketChannelExecution, AIError, Scope.Scope>;
 }
 export interface WebSocketChannelExecution {
     readonly frames: Stream.Stream<string, AIError>;
+    readonly http?: HttpContext;
     /** Commits staged state after the decoded Route stream ends successfully. */
     readonly complete: Effect.Effect<void>;
 }

package/dist/route/transport/websocket.d.ts

@@ -1,7 +1,7 @@
 import { Effect, Stream } from "effect";
 import { Headers } from "effect/unstable/http";
 import { Socket } from "effect/unstable/socket";
-import { AIError } from "../../schema/index.js";
+import { AIError, type HttpContext } from "../../schema/index.js";
 import type { Transport } from "./index.js";
 import type { WebSocketChannelExecutor } from "./websocket-channel.js";
 export interface WebSocketRequest {
@@ -9,6 +9,7 @@ export interface WebSocketRequest {
     readonly headers: Headers.Headers;
 }
 export interface WebSocketConnection {
+    readonly http?: HttpContext;
     readonly sendText: (message: string) => Effect.Effect<void, AIError>;
     readonly messages: Stream.Stream<string | Uint8Array, AIError>;
     readonly close: Effect.Effect<void, never>;

package/dist/route/transport/websocket.js

@@ -1,14 +1,14 @@
 import { Cause, Effect, Queue, Stream } from "effect";
 import { Headers } from "effect/unstable/http";
 import { Socket } from "effect/unstable/socket";
-import { AIError, TransportReason } from "../../schema/index.js";
+import { AIError, AIErrorReason, TransportError, } from "../../schema/index.js";
 import * as HttpTransport from "./http.js";
 const MAX_FRAME_BYTES = 16 * 1024 * 1024;
-const transportError = (method, message, input) => new AIError({
-    module: "WebSocketConnector",
-    method,
-    reason: new TransportReason({
+const transportError = (message, input) => new AIError({
+    reason: new TransportError({
         message,
+        body: input.body,
+        cause: input.cause,
         transport: "websocket",
         operation: input.operation,
         url: input.url,
@@ -19,18 +19,12 @@ const transportError = (method, message, input) => new AIError({
 });
 const annotateTransportError = (error, input) => error.reason._tag === "Transport"
     ? new AIError({
-        module: error.module,
-        method: error.method,
-        reason: new TransportReason({
+        reason: new TransportError({
+            ...error.reason,
             message: error.reason.message,
-            transport: error.reason.transport,
-            operation: error.reason.operation,
-            code: error.reason.code,
-            url: error.reason.url,
-            http: error.reason.http,
+            cause: error.reason.cause,
             phase: input.phase,
             delivery: input.delivery,
-            recovery: error.reason.recovery,
         }),
     })
     : error;
@@ -52,7 +46,7 @@ const waitOpen = (ws, input) => {
     if (ws.readyState === globalThis.WebSocket.OPEN)
         return Effect.void;
     if (ws.readyState === globalThis.WebSocket.CLOSING || ws.readyState === globalThis.WebSocket.CLOSED) {
-        return Effect.fail(transportError("open", `WebSocket closed before opening (state ${ws.readyState})`, {
+        return Effect.fail(transportError(`WebSocket closed before opening (state ${ws.readyState})`, {
             url: input.url,
             operation: "request",
             code: "closed",
@@ -78,7 +72,8 @@ const waitOpen = (ws, input) => {
         };
         const onError = (event) => {
             cleanup();
-            resume(Effect.fail(transportError("open", `Failed to open WebSocket: ${eventMessage(event)}`, {
+            resume(Effect.fail(transportError(`Failed to open WebSocket: ${eventMessage(event)}`, {
+                cause: "error" in event ? (event.error ?? event) : event,
                 url: input.url,
                 operation: "request",
                 phase: "connect",
@@ -87,7 +82,9 @@ const waitOpen = (ws, input) => {
         };
         const onClose = (event) => {
             cleanup();
-            resume(Effect.fail(transportError("open", `WebSocket closed before opening with code ${event.code}`, {
+            resume(Effect.fail(transportError(`WebSocket closed before opening with code ${event.code}`, {
+                body: event.reason,
+                cause: event,
                 url: input.url,
                 operation: "request",
                 code: String(event.code),
@@ -114,7 +111,8 @@ export const toWebSocketUrl = (value) => Effect.try({
         }
         throw new Error(`Unsupported WebSocket URL protocol ${url.protocol}`);
     },
-    catch: (error) => transportError("prepare", error instanceof Error ? error.message : "Invalid WebSocket URL", {
+    catch: (error) => transportError(error instanceof Error ? error.message : "Invalid WebSocket URL", {
+        cause: error,
         url: value,
         operation: "request",
         code: "invalid-url",
@@ -131,7 +129,8 @@ export const open = (input) => Effect.gen(function* () {
         constructor(input.url, {
             headers: input.headers,
         }),
-        catch: (error) => transportError("open", error instanceof Error ? error.message : "Failed to construct WebSocket", {
+        catch: (error) => transportError(error instanceof Error ? error.message : "Failed to construct WebSocket", {
+            cause: error,
             url: input.url,
             operation: "request",
             phase: "connect",
@@ -147,7 +146,8 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
     const rejectOversized = (message) => {
         if (!oversized(message))
             return false;
-        Queue.failCauseUnsafe(messages, Cause.fail(transportError("message", "WebSocket message exceeds the 16 MiB limit", {
+        Queue.failCauseUnsafe(messages, Cause.fail(transportError("WebSocket message exceeds the 16 MiB limit", {
+            body: typeof message === "string" ? message : new TextDecoder().decode(message),
             url: input.url,
             operation: "read",
             code: "message-too-large",
@@ -162,7 +162,8 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
             return;
         if (Queue.offerUnsafe(messages, message))
             return;
-        Queue.failCauseUnsafe(messages, Cause.fail(transportError("message", "WebSocket inbound queue overflow", {
+        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",
@@ -175,7 +176,8 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
         const binary = binaryMessage(event.data);
         if (binary)
             return offer(binary);
-        Queue.failCauseUnsafe(messages, Cause.fail(transportError("message", "Unsupported WebSocket message payload", {
+        Queue.failCauseUnsafe(messages, Cause.fail(transportError("Unsupported WebSocket message payload", {
+            cause: event,
             url: input.url,
             operation: "read",
             code: "message",
@@ -183,7 +185,8 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
         })));
     };
     const onError = (event) => {
-        Queue.failCauseUnsafe(messages, Cause.fail(transportError("message", `WebSocket error: ${eventMessage(event)}`, {
+        Queue.failCauseUnsafe(messages, Cause.fail(transportError(`WebSocket error: ${eventMessage(event)}`, {
+            cause: "error" in event ? (event.error ?? event) : event,
             url: input.url,
             operation: "read",
             code: "message",
@@ -191,7 +194,9 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
         })));
     };
     const onClose = (event) => {
-        Queue.failCauseUnsafe(messages, Cause.fail(transportError("message", `WebSocket closed with code ${event.code}`, {
+        Queue.failCauseUnsafe(messages, Cause.fail(transportError(`WebSocket closed with code ${event.code}`, {
+            body: event.reason,
+            cause: event,
             url: input.url,
             operation: "read",
             code: String(event.code),
@@ -209,7 +214,7 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
     return {
         sendText: (message) => Effect.suspend(() => {
             if (ws.readyState !== globalThis.WebSocket.OPEN)
-                return Effect.fail(transportError("sendText", `WebSocket is not open (state ${ws.readyState})`, {
+                return Effect.fail(transportError(`WebSocket is not open (state ${ws.readyState})`, {
                     url: input.url,
                     operation: "write",
                     phase: "send",
@@ -217,7 +222,8 @@ export const fromWebSocket = (ws, input) => Effect.gen(function* () {
                 }));
             return Effect.try({
                 try: () => ws.send(message),
-                catch: (error) => transportError("sendText", error instanceof Error ? error.message : "Failed to send WebSocket message", {
+                catch: (error) => transportError(error instanceof Error ? error.message : "Failed to send WebSocket message", {
+                    cause: error,
                     url: input.url,
                     operation: "write",
                     phase: "send",
@@ -246,17 +252,51 @@ export const makeDirect = (connector) => ({
             .open(exchange.connect)
             .pipe(Effect.mapError((error) => annotateTransportError(error, { phase: "connect", delivery: "not-sent" }))), (connection) => connection.close);
         const create = yield* exchange.driver.create(undefined);
-        yield* connection.sendText(create.message);
+        yield* connection.sendText(create.message).pipe(Effect.mapError((error) => new AIError({
+            reason: AIErrorReason.make({
+                ...error.reason,
+                message: error.reason.message,
+                cause: error.reason.cause,
+                http: error.reason.http ?? connection.http,
+            }),
+        })));
         const decoder = new TextDecoder();
         let observed = false;
         return {
+            http: connection.http,
             frames: connection.messages.pipe(Stream.map((message) => {
                 observed = true;
                 return messageText(message, decoder);
             }), Stream.mapError((error) => annotateTransportError(error, {
                 phase: error.reason._tag === "Transport" && error.reason.phase === "close" ? "close" : "receive",
                 delivery: observed ? "accepted" : "ambiguous",
-            })), Stream.mapEffect((frame) => exchange.driver.observe(create, frame)), Stream.takeUntil(observationTerminal), Stream.mapEffect(observationFrame)),
+            })), Stream.mapEffect((frame) => exchange.driver.observe(create, frame).pipe(Effect.mapError((error) => new AIError({
+                reason: AIErrorReason.make({
+                    ...error.reason,
+                    message: error.reason.message,
+                    cause: error.reason.cause,
+                    body: frame,
+                }),
+            })), Effect.map((observation) => "error" in observation
+                ? {
+                    ...observation,
+                    error: new AIError({
+                        reason: AIErrorReason.make({
+                            ...observation.error.reason,
+                            message: observation.error.reason.message,
+                            cause: observation.error.reason.cause,
+                            body: frame,
+                        }),
+                    }),
+                }
+                : observation))), Stream.takeUntil(observationTerminal), Stream.mapEffect(observationFrame), Stream.mapError((error) => new AIError({
+                reason: AIErrorReason.make({
+                    ...error.reason,
+                    message: error.reason.message,
+                    cause: error.reason.cause,
+                    http: error.reason.http ?? connection.http,
+                }),
+            }))),
             complete: Effect.void,
         };
     }),
@@ -283,7 +323,7 @@ export const json = (input) => ({
     execute: (prepared, request, _runtime, options) => {
         const webSocket = options?.webSocket;
         if (!webSocket) {
-            return Effect.fail(transportError("json", "WebSocket JSON transport requires StreamOptions.webSocket", {
+            return Effect.fail(transportError("WebSocket JSON transport requires StreamOptions.webSocket", {
                 url: prepared.url,
                 operation: "request",
                 code: "unavailable",
@@ -298,7 +338,7 @@ export const json = (input) => ({
         const exchange = {
             id: request.id ?? "request",
             connect: { url: prepared.url, headers: prepared.headers },
-            fallback: () => Stream.fail(transportError("fallback", "WebSocket JSON transport does not provide HTTP fallback", {
+            fallback: () => Stream.fail(transportError("WebSocket JSON transport does not provide HTTP fallback", {
                 url: prepared.url,
                 operation: "request",
                 code: "websocket",