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

package/dist/provider-error.js

@@ -1,5 +1,5 @@
 import { Option, Schema } from "effect";
-import { AuthenticationReason, ContentPolicyReason, InvalidRequestReason, AIError, ProviderErrorEvent, ProviderInternalReason, QuotaExceededReason, RateLimitReason, UnknownProviderReason, } from "./schema/index.js";
+import { AuthenticationError, ContentPolicyError, InvalidRequestError, AIError, ProviderErrorEvent, ProviderInternalError, QuotaExceededError, RateLimitError, UnknownProviderError, } from "./schema/index.js";
 const patterns = [
     /prompt is too long/i,
     /input is too long for requested model/i,
@@ -24,6 +24,7 @@ const patterns = [
     /too large for model with \d+ maximum context length/i,
     /prompt has [\d,]+ tokens?, but the configured context size is [\d,]+ tokens?/i,
     /model_context_window_exceeded/i,
+    /range of input length should be/i,
     /too many tokens/i,
     /token limit exceeded/i,
     /request_too_large/i,
@@ -38,6 +39,7 @@ export const isContextOverflowFailure = (failure) => failure instanceof AIError
     : Schema.is(ProviderErrorEvent)(failure) && failure.classification === "context-overflow";
 const decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
 const QUOTA_CODES = new Set(["insufficient_quota", "usage_not_included", "billing_error"]);
+const AUTH_CODES = new Set(["authentication_error", "permission_error"]);
 const SERVER_CODES = new Set([
     "api_error",
     "internal_error",
@@ -53,84 +55,66 @@ const INVALID_REQUEST_CODES = new Set(["invalid_prompt", "invalid_request_error"
 const RATE_LIMIT_TEXT = /rate increased too quickly|rate[-_\s]?limit|too[_\s]?many[_\s]?requests/i;
 const QUOTA_TEXT = /insufficient[-_\s]?quota|quota[-_\s]?exceeded/i;
 const CONTENT_POLICY_TEXT = /content[-_\s]?policy|content_filter|safety/i;
-const NETWORK_ERROR_TEXT = /network[-_\s]error/i;
-// Keep HTTP failures and provider-reported stream failures on one typed path so
-// session retry policy never needs provider-specific string matching.
+// Classification records affirmative evidence about a failure. Deterministic
+// failures need positive identification (a 4xx status, quota/auth/policy
+// signals); anything unrecognized stays UnknownProvider, which the session
+// retry policy treats as retry-eligible because transient failures arrive in
+// unpredictable shapes while deterministic rejections almost always carry a
+// status or known code.
 export function classifyProviderFailure(input) {
-    const body = input.http?.body ?? input.rawBody ?? "";
-    const codes = [input.code, ...providerCodes(body), ...providerCodes(input.message)]
-        .filter((code) => code !== undefined)
-        .map((code) => code.toLowerCase());
+    const details = { message: input.message, body: input.rawBody, http: input.http, cause: input.cause };
+    const body = input.rawBody ?? "";
+    const codes = [...providerCodes(input.data), ...providerCodes(body), ...providerCodes(input.message)].map((code) => code.toLowerCase());
     // Scan the raw payload too so signals missing from the summary message
     // (e.g. overflow phrases nested in a JSON error body) still classify.
     const text = [input.message, body].filter((value) => value.length > 0).join("\n");
-    const common = { message: input.message, providerMetadata: input.providerMetadata, http: input.http };
     const clientScoped = input.status === undefined || (input.status >= 400 && input.status < 500);
     if (clientScoped &&
         (codes.includes("context_length_exceeded") ||
             codes.includes("model_context_window_exceeded") ||
             codes.includes("request_too_large") ||
             isContextOverflow(text)))
-        return new InvalidRequestReason({ ...common, classification: "context-overflow" });
+        return new InvalidRequestError({ ...details, classification: "context-overflow" });
     if (input.status === 413 || isPayloadTooLarge(text))
-        return new InvalidRequestReason({ ...common, classification: "payload-too-large" });
+        return new InvalidRequestError({ ...details, classification: "payload-too-large" });
     if (CONTENT_POLICY_TEXT.test(text))
-        return new ContentPolicyReason(common);
+        return new ContentPolicyError(details);
     if (codes.some((code) => QUOTA_CODES.has(code)) || (input.status === 429 && QUOTA_TEXT.test(text)))
-        return new QuotaExceededReason(common);
-    if (input.status === 401)
-        return new AuthenticationReason({ ...common, kind: "invalid" });
-    if (input.status === 403)
-        return new AuthenticationReason({ ...common, kind: "insufficient-permissions" });
-    if (codes.includes("authentication_error"))
-        return new AuthenticationReason({ ...common, kind: "invalid" });
-    if (codes.includes("permission_error"))
-        return new AuthenticationReason({ ...common, kind: "insufficient-permissions" });
-    if (codes.some((code) => code.includes("rate_limit") || code === "too_many_requests" || code === "throttlingexception"))
-        return new RateLimitReason({
-            ...common,
+        return new QuotaExceededError(details);
+    if (input.status === 401 || input.status === 403 || codes.some((code) => AUTH_CODES.has(code)))
+        return new AuthenticationError(details);
+    if (input.status === 429 ||
+        codes.some((code) => code.includes("rate_limit") || code === "too_many_requests" || code === "throttlingexception") ||
+        RATE_LIMIT_TEXT.test(text))
+        return new RateLimitError({
+            ...details,
             retryAfterMs: input.retryAfterMs,
             rateLimit: input.rateLimit,
         });
-    if (RATE_LIMIT_TEXT.test(text))
-        return new RateLimitReason({
-            ...common,
-            retryAfterMs: input.retryAfterMs,
-            rateLimit: input.rateLimit,
-        });
-    if (NETWORK_ERROR_TEXT.test(text))
-        return new ProviderInternalReason({ ...common, status: input.status });
-    if (codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable")))
-        return new ProviderInternalReason({
-            ...common,
-            status: input.status,
-            retryAfterMs: input.retryAfterMs,
-        });
-    if (input.status === 429) {
-        return new RateLimitReason({
-            ...common,
-            retryAfterMs: input.retryAfterMs,
-            rateLimit: input.rateLimit,
-        });
-    }
-    if (input.status === 408 || input.status === 409 || (input.status !== undefined && input.status >= 500))
-        return new ProviderInternalReason({
-            ...common,
-            status: input.status,
+    if (input.status === 408 ||
+        input.status === 409 ||
+        (input.status !== undefined && input.status >= 500) ||
+        codes.some((code) => SERVER_CODES.has(code) || code.includes("exhausted") || code.includes("unavailable")))
+        return new ProviderInternalError({
+            ...details,
             retryAfterMs: input.retryAfterMs,
         });
     if (codes.some((code) => INVALID_REQUEST_CODES.has(code)))
-        return new InvalidRequestReason(common);
-    if (input.status === 400 || input.status === 404 || input.status === 413 || input.status === 422)
-        return new InvalidRequestReason(common);
-    return new UnknownProviderReason({ ...common, status: input.status });
+        return new InvalidRequestError(details);
+    // Any remaining 4xx is a deterministic rejection of this request.
+    if (input.status !== undefined && input.status >= 400 && input.status < 500)
+        return new InvalidRequestError(details);
+    return new UnknownProviderError(details);
 }
 function providerCodes(value) {
-    const decoded = Option.getOrUndefined(decodeJson(value));
+    const decoded = typeof value === "string" ? Option.getOrUndefined(decodeJson(value)) : value;
     if (!isRecord(decoded))
         return [];
     const error = isRecord(decoded.error) ? decoded.error : undefined;
-    return [decoded.code, error?.code, error?.type].filter((value) => typeof value === "string");
+    const response = isRecord(decoded.response) ? decoded.response : undefined;
+    const responseError = response && isRecord(response.error) ? response.error : undefined;
+    const exception = isRecord(decoded.exception) ? decoded.exception : undefined;
+    return [decoded.code, error?.code, error?.type, error?.status, responseError?.code, exception?.type].filter((value) => typeof value === "string");
 }
 function isRecord(value) {
     return typeof value === "object" && value !== null;

package/dist/providers/groq.d.ts

@@ -125,7 +125,7 @@ export declare const protocol: Protocol<{
     readonly parallel_tool_calls?: boolean | undefined;
     readonly reasoning_format?: "parsed" | undefined;
     readonly include_reasoning?: boolean | undefined;
-}, string, {
+}, string, "[DONE]" | {
     readonly [x: string]: unknown;
     readonly error?: {
         readonly [x: string]: unknown;

package/dist/providers/groq.js

@@ -4,7 +4,6 @@ import { ProviderShared } from "../protocols/shared.js";
 import { AuthOptions } from "../route/auth-options.js";
 import { Route } from "../route/client.js";
 import { Endpoint } from "../route/endpoint.js";
-import { Framing } from "../route/framing.js";
 import { Protocol } from "../route/protocol.js";
 import { ProviderID } from "../schema/index.js";
 import { profiles } from "./openai-compatible-profile.js";
@@ -47,7 +46,7 @@ export const route = Route.make({
     providerMetadataKey: "openai",
     protocol,
     endpoint: Endpoint.path("/chat/completions", { baseURL: profiles.groq.baseURL }),
-    framing: Framing.sse,
+    framing: OpenAIChat.framing,
 });
 export const configure = (input = {}) => {
     const { apiKey: _apiKey, auth: _auth, baseURL, ...defaults } = input;

package/dist/providers/openrouter.d.ts

@@ -282,7 +282,7 @@ export declare const protocol: Protocol<{
     readonly tool_stream?: boolean | undefined;
     readonly frequency_penalty?: number | undefined;
     readonly presence_penalty?: number | undefined;
-}, string, {
+}, string, "[DONE]" | {
     readonly [x: string]: unknown;
     readonly error?: {
         readonly [x: string]: unknown;

package/dist/providers/openrouter.js

@@ -1,7 +1,6 @@
 import { Effect, Schema } from "effect";
 import { Route } from "../route/client.js";
 import { Endpoint } from "../route/endpoint.js";
-import { Framing } from "../route/framing.js";
 import { Protocol } from "../route/protocol.js";
 import { AuthOptions } from "../route/auth-options.js";
 import { ProviderID } from "../schema/index.js";
@@ -87,7 +86,7 @@ export const route = Route.make({
     providerMetadataKey: "openrouter",
     protocol,
     endpoint: Endpoint.path("/chat/completions", { baseURL: profile.baseURL }),
-    framing: Framing.sse,
+    framing: OpenAIChat.framing,
 });
 export const routes = [route];
 const configuredRoute = (input) => {

package/dist/route/auth.js

@@ -1,6 +1,6 @@
 import { Config, Effect, Redacted } from "effect";
 import { Headers } from "effect/unstable/http";
-import { AuthenticationReason, InvalidRequestReason, AIError } from "../schema/index.js";
+import { AuthenticationError, InvalidRequestError, AIError } from "../schema/index.js";
 export class MissingCredentialError extends Error {
     source;
     _tag = "MissingCredentialError";
@@ -76,11 +76,9 @@ export function bearerHeader(name, source) {
 const toAIError = (error) => {
     if (error instanceof MissingCredentialError || error instanceof Config.ConfigError) {
         return new AIError({
-            module: "Auth",
-            method: "apply",
             reason: error instanceof MissingCredentialError
-                ? new AuthenticationReason({ message: error.message, kind: "missing" })
-                : new InvalidRequestReason({ message: `Failed to resolve auth config: ${error.message}` }),
+                ? new AuthenticationError({ message: error.message, cause: error })
+                : new InvalidRequestError({ message: `Failed to resolve auth config: ${error.message}`, cause: error }),
         });
     }
     return error;

package/dist/route/client.d.ts

@@ -173,6 +173,7 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
 } | {
     readonly id: string;
     readonly type: "text-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
@@ -198,6 +199,7 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
 } | {
     readonly id: string;
     readonly type: "reasoning-end";
+    readonly text?: string | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;

package/dist/route/client.js

@@ -7,7 +7,7 @@ import { HttpTransport } from "./transport/index.js";
 import { applyCachePolicy } from "../cache-policy.js";
 import { sanitizeSurrogates } from "../utils/sanitize.js";
 import * as ProviderShared from "../protocols/shared.js";
-import { AIError, GenerationOptions, HttpOptions, LLMRequest, LLMResponse, LanguageModel, LLMEvent, InvalidProviderOutputReason, ProviderID, mergeGenerationOptions, mergeHttpOptions, mergeProviderOptions, } from "../schema/index.js";
+import { AIError, AIErrorReason, GenerationOptions, HttpOptions, LLMRequest, LLMResponse, LanguageModel, LLMEvent, InvalidProviderOutputError, ProviderID, mergeGenerationOptions, mergeHttpOptions, mergeProviderOptions, } from "../schema/index.js";
 const makeRouteLanguageModel = (route, mapped) => {
     const provider = route.provider ?? ("provider" in mapped ? mapped.provider : undefined);
     if (!provider)
@@ -60,14 +60,12 @@ const streamError = (route, message, cause) => {
     const failed = cause.reasons.find(Cause.isFailReason)?.error;
     if (failed instanceof AIError)
         return failed;
-    return ProviderShared.eventError(route, message, Cause.pretty(cause));
+    return ProviderShared.eventError(route, message, undefined, cause);
 };
 const incompleteStreamError = (route) => new AIError({
-    module: "LLMClient",
-    method: "stream",
-    reason: new InvalidProviderOutputReason({
-        classification: "incomplete-stream",
+    reason: new InvalidProviderOutputError({
         message: "The provider response ended unexpectedly.",
+        classification: "incomplete-stream",
         route,
     }),
 });
@@ -85,7 +83,7 @@ function makeFromTransport(input) {
     const protocol = input.protocol;
     const encodeBody = Schema.encodeSync(Schema.fromJsonString(protocol.body.schema));
     const decodeEventEffect = Schema.decodeUnknownEffect(protocol.stream.event);
-    const decodeEvent = (route) => (frame) => decodeEventEffect(frame).pipe(Effect.mapError(() => ProviderShared.eventError(input.id, `Invalid ${route} stream event`, typeof frame === "string" ? frame : ProviderShared.encodeJson(frame))));
+    const decodeEvent = (route) => (frame) => decodeEventEffect(frame).pipe(Effect.mapError((cause) => ProviderShared.eventError(input.id, `Invalid ${route} stream event`, typeof frame === "string" ? frame : ProviderShared.encodeJson(frame), cause)));
     const build = (routeInput) => {
         const route = {
             id: routeInput.id,
@@ -127,18 +125,38 @@ function makeFromTransport(input) {
             streamPrepared: (prepared, request, runtime, options) => {
                 const route = `${request.model.provider}/${request.model.route.id}`;
                 return Stream.unwrap(routeInput.transport.execute(prepared, request, runtime, options).pipe(Effect.map((execution) => {
-                    const events = execution.frames.pipe(Stream.mapEffect(decodeEvent(route)), protocol.stream.terminal ? Stream.takeUntil(protocol.stream.terminal) : (stream) => stream);
+                    const terminal = protocol.stream.terminal;
+                    // Preserve assembled inputs; replace only serialized event fallbacks with their original wire data.
+                    const frameError = (frame, event = frame) => (error) => new AIError({
+                        reason: AIErrorReason.make({
+                            ...error.reason,
+                            message: error.reason.message,
+                            cause: error.reason.cause,
+                            body: error.reason.body !== undefined && error.reason.body !== ProviderShared.encodeJson(event)
+                                ? error.reason.body
+                                : (execution.body?.(frame) ??
+                                    (typeof frame === "string" ? frame : ProviderShared.encodeJson(frame))),
+                        }),
+                    });
+                    const events = execution.frames.pipe(Stream.mapEffect((frame) => decodeEvent(route)(frame).pipe(Effect.catchCause((cause) => Effect.fail(streamError(route, `Failed to decode ${route} event`, cause))), Effect.map((event) => ({ event, frame })), Effect.mapError(frameError(frame)))), terminal ? Stream.takeUntil(({ event }) => terminal(event)) : (stream) => stream);
                     const stream = Stream.suspend(() => {
                         let state = protocol.stream.initial(request);
-                        const parsed = events.pipe(Stream.mapEffect((event) => protocol.stream.step(state, event).pipe(Effect.map(([next, output]) => {
+                        const parsed = events.pipe(Stream.mapEffect(({ event, frame }) => protocol.stream.step(state, event).pipe(Effect.catchCause((cause) => Effect.fail(streamError(route, `Failed to parse ${route} event`, cause))), Effect.map(([next, output]) => {
                             state = next;
                             return output;
-                        }))), Stream.flatMap(Stream.fromIterable));
+                        }), Effect.mapError(frameError(frame, event)))), Stream.flatMap(Stream.fromIterable));
                         const onHalt = protocol.stream.onHalt;
                         return onHalt
                             ? parsed.pipe(Stream.concat(Stream.suspend(() => Stream.unwrap(onHalt(state).pipe(Effect.map(Stream.fromIterable))))))
                             : parsed;
-                    }).pipe(Stream.catchCause((cause) => Stream.fail(streamError(route, `Failed to read ${route} stream`, cause))), requireTerminalEvent(route));
+                    }).pipe(Stream.catchCause((cause) => Stream.fail(streamError(route, `Failed to read ${route} stream`, cause))), requireTerminalEvent(route), Stream.mapError((error) => new AIError({
+                        reason: AIErrorReason.make({
+                            ...error.reason,
+                            message: error.reason.message,
+                            cause: error.reason.cause,
+                            http: error.reason.http ?? execution.http,
+                        }),
+                    })));
                     return execution.complete ? stream.pipe(Stream.onEnd(execution.complete)) : stream;
                 })));
             },

package/dist/route/executor.d.ts

@@ -1,6 +1,6 @@
 import { Context, Effect, Layer, Stream } from "effect";
 import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
-import { AIError, TransportReason } from "../schema/index.js";
+import { HttpContext, AIError } from "../schema/index.js";
 export interface Interface {
     readonly execute: (request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>;
 }
@@ -9,14 +9,18 @@ export type HttpMiddleware = (request: HttpClientRequest.HttpClientRequest, hand
 declare const Service_base: Context.ServiceClass<Service, "@opencode/AI/RequestExecutor", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const classifyHttpFailure: (input: {
+export declare const responseHttp: (response: HttpClientResponse.HttpClientResponse) => HttpContext;
+/** Preserve HTTP diagnostics for executor and externally captured failures alike. */
+export declare const httpFailure: (input: {
     readonly message: string;
-    readonly url: string;
+    readonly url?: string | undefined;
     readonly status?: number | undefined;
-    readonly code?: string | undefined;
+    readonly data?: unknown;
     readonly responseHeaders?: Record<string, string> | undefined;
     readonly responseBody?: string | undefined;
-}) => import("../schema/errors.js").InvalidRequestReason | import("../schema/errors.js").NoRouteReason | import("../schema/errors.js").AuthenticationReason | import("../schema/errors.js").RateLimitReason | import("../schema/errors.js").QuotaExceededReason | import("../schema/errors.js").ContentPolicyReason | import("../schema/errors.js").ProviderInternalReason | TransportReason | import("../schema/errors.js").InvalidProviderOutputReason | import("../schema/errors.js").UnknownProviderReason;
+    readonly cause?: unknown;
+}) => AIError;
+export declare const responseStream: (response: HttpClientResponse.HttpClientResponse) => Stream.Stream<Uint8Array, AIError>;
 export declare const stream: (executor: Interface, request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) => Stream.Stream<Uint8Array, AIError>;
 export declare const layer: Layer.Layer<Service, never, HttpClient.HttpClient>;
 export declare const fetchLayer: Layer.Layer<Service, never, never>;

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

@@ -6,8 +6,8 @@ import type { AIError } from "../schema/index.js";
  * `Framing` is the byte-stream-shaped seam between transport and protocol:
  *
  * - SSE (`Framing.sse`) — UTF-8 decode the body, run the SSE channel decoder,
- *   drop empty / `[DONE]` keep-alives. Each emitted frame is the JSON `data:`
- *   payload of one event.
+ *   and emit the `data:` payload of each non-empty event. The default drops
+ *   `[DONE]`; protocols that use it as a terminal select `sseWithDone`.
  * - AWS event stream — length-prefixed binary frames with CRC checksums.
  *   Each emitted frame is one parsed binary event record.
  *
@@ -17,9 +17,13 @@ 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>;
+/** Server-Sent Events framing that retains the conventional `[DONE]` sentinel. */
+export declare const sseWithDone: Definition<string>;
 /** SSE framing restricted to protocol-recognized event names. */
 export declare const sseEvents: (events: ReadonlySet<string>) => Definition<string>;
 export * as Framing from "./framing.js";

package/dist/route/framing.js

@@ -1,6 +1,11 @@
 import * as ProviderShared from "../protocols/shared.js";
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
 export const sse = { id: "sse", frame: ProviderShared.sseFraming };
+/** Server-Sent Events framing that retains the conventional `[DONE]` sentinel. */
+export const sseWithDone = {
+    id: "sse",
+    frame: (bytes) => ProviderShared.sseFraming(bytes, undefined, true),
+};
 /** SSE framing restricted to protocol-recognized event names. */
 export const sseEvents = (events) => ({
     id: "sse",

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>;