@opencode/ai 0.0.0-beta-19275

package/dist/route/client.js

@@ -0,0 +1,304 @@
+import { Cause, Context, Effect, Layer, Schema, Stream } from "effect";
+import { Auth } from "./auth.js";
+import { Endpoint } from "./endpoint.js";
+import { RequestExecutor } from "./executor.js";
+import { Framing } from "./framing.js";
+import { HttpTransport } from "./transport/index.js";
+import { applyCachePolicy } from "../cache-policy.js";
+import { normalizeToolHistory } from "../tool-history.js";
+import { sanitizeSurrogates } from "../utils/sanitize.js";
+import * as ProviderShared from "../protocols/shared.js";
+import { AIError, CompactionResponse, CompactionCheckpointResponse, 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)
+        throw new Error(`Route.model(${route.id}) requires a provider`);
+    if (!endpointBaseURL(route.endpoint))
+        throw new Error(`Route.model(${route.id}) requires an endpoint baseURL — configure it on the route first`);
+    return LanguageModel.make({
+        ...mapped,
+        provider,
+        route,
+    });
+};
+const mergeRouteDefaults = (base, patch) => {
+    const headers = mergeHeaders(base?.headers, patch.headers);
+    return {
+        ...base,
+        ...patch,
+        headers,
+        generation: mergeGenerationOptions(generationOptions(base?.generation), generationOptions(patch.generation)),
+        providerOptions: mergeProviderOptions(base?.providerOptions, patch.providerOptions),
+        http: mergeHttpOptions(base?.http, httpOptions(patch.http), headers === undefined ? undefined : new HttpOptions({ headers })),
+    };
+};
+const endpointBaseURL = (endpoint) => typeof endpoint.baseURL === "string" ? endpoint.baseURL : undefined;
+const mergeHeaders = (...items) => {
+    const entries = items.flatMap((item) => item === undefined ? [] : Object.entries(item).filter((entry) => entry[1] !== undefined));
+    if (entries.length === 0)
+        return undefined;
+    return Object.fromEntries(entries);
+};
+export const generationOptions = (input) => input === undefined ? undefined : GenerationOptions.make(input);
+export const httpOptions = (input) => {
+    if (input === undefined)
+        return input;
+    return HttpOptions.make(input);
+};
+export function canCompact(request, options) {
+    if (options?.mechanism === "trigger")
+        return request.model.route.compact?.trigger !== undefined;
+    if (options?.mechanism !== undefined && options.mechanism !== "endpoint")
+        return false;
+    return request.model.route.compact?.endpoint !== undefined;
+}
+const unsupportedCompaction = (request, mechanism) => {
+    if (mechanism !== undefined && mechanism !== "endpoint" && mechanism !== "trigger")
+        return ProviderShared.invalidRequest(`Unknown compaction mechanism: ${mechanism}`);
+    return ProviderShared.unsupportedOperation({
+        operation: mechanism === "trigger" ? "compact.trigger" : "compact",
+        provider: request.model.provider,
+        route: request.model.route.id,
+        message: `${request.model.provider}/${request.model.route.id} does not support ${mechanism === "trigger" ? "trigger" : "explicit"} compaction`,
+    });
+};
+export class Service extends Context.Service()("@opencode/LLMClient") {
+}
+const resolveRequestOptions = (request) => {
+    const messages = normalizeToolHistory(request.messages);
+    const normalized = messages === request.messages ? request : LLMRequest.update(request, { messages });
+    const routeDefaults = normalized.model.route.defaults;
+    const modelDefaults = normalized.model.defaults;
+    const generation = mergeGenerationOptions(routeDefaults.generation, modelDefaults?.generation, normalized.generation);
+    return LLMRequest.update(normalized, {
+        generation: generation ?? new GenerationOptions({}),
+        providerOptions: mergeProviderOptions(routeDefaults.providerOptions, modelDefaults?.providerOptions, normalized.providerOptions),
+        http: mergeHttpOptions(routeDefaults.http, modelDefaults?.http, normalized.http),
+    });
+};
+const streamError = (route, message, cause) => {
+    const failed = cause.reasons.find(Cause.isFailReason)?.error;
+    if (failed instanceof AIError)
+        return failed;
+    return ProviderShared.eventError(route, message, undefined, cause);
+};
+const incompleteStreamError = (route) => new AIError({
+    reason: new InvalidProviderOutputError({
+        message: "The provider response ended unexpectedly.",
+        classification: "incomplete-stream",
+        route,
+    }),
+});
+const requireTerminalEvent = (route) => (events) => Stream.suspend(() => {
+    let terminal = false;
+    return events.pipe(Stream.mapEffect((event) => {
+        if (terminal)
+            return Effect.fail(ProviderShared.eventError(route, `Provider emitted ${event.type} after the terminal event`));
+        if (LLMEvent.is.finish(event) || LLMEvent.is.providerError(event))
+            terminal = true;
+        return Effect.succeed(event);
+    }), Stream.onEnd(Effect.suspend(() => (terminal ? Effect.void : Effect.fail(incompleteStreamError(route))))));
+});
+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((cause) => ProviderShared.eventError(input.id, `Invalid ${route} stream event`, typeof frame === "string" ? frame : ProviderShared.encodeJson(frame), cause)));
+    const build = (routeInput) => {
+        const route = {
+            compact: routeInput.compact,
+            id: routeInput.id,
+            provider: routeInput.provider === undefined ? undefined : ProviderID.make(routeInput.provider),
+            providerMetadataKey: routeInput.providerMetadataKey,
+            protocol: protocol.id,
+            endpoint: routeInput.endpoint,
+            auth: routeInput.auth ?? Auth.none,
+            headers: routeInput.headers,
+            transport: routeInput.transport,
+            defaults: routeInput.defaults ?? {},
+            body: protocol.body,
+            with: (patch) => {
+                const { compact, id, provider, providerMetadataKey, auth, transport, endpoint, ...defaults } = patch;
+                return build({
+                    ...routeInput,
+                    compact: "compact" in patch ? compact : routeInput.compact,
+                    id: id ?? routeInput.id,
+                    provider: provider ?? routeInput.provider,
+                    providerMetadataKey: providerMetadataKey ??
+                        (provider !== undefined && String(provider) !== String(routeInput.provider)
+                            ? String(provider)
+                            : routeInput.providerMetadataKey),
+                    auth: auth ?? routeInput.auth,
+                    endpoint: endpoint ? Endpoint.merge(routeInput.endpoint, endpoint) : routeInput.endpoint,
+                    transport: transport ?? routeInput.transport,
+                    defaults: mergeRouteDefaults(route.defaults, defaults),
+                });
+            },
+            model: (input) => makeRouteLanguageModel(route, input),
+            prepareTransport: (body, request, options) => routeInput.transport.prepare({
+                body,
+                request,
+                endpoint: routeInput.endpoint,
+                auth: routeInput.auth ?? Auth.none,
+                encodeBody,
+                middleware: options?.http,
+                webSocket: options?.webSocket,
+            }),
+            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 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, 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;
+                        }), 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), 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;
+                })));
+            },
+        };
+        return route;
+    };
+    return build({ ...input, defaults: mergeRouteDefaults(undefined, input.defaults ?? {}) });
+}
+export function make(input) {
+    if ("transport" in input)
+        return makeFromTransport(input);
+    const protocol = input.protocol;
+    return makeFromTransport({
+        compact: input.compact,
+        id: input.id,
+        provider: input.provider,
+        providerMetadataKey: input.providerMetadataKey,
+        protocol,
+        endpoint: input.endpoint,
+        auth: input.auth,
+        headers: input.headers,
+        transport: HttpTransport.httpJson({ framing: input.framing }),
+        defaults: input.defaults,
+    });
+}
+const prepareRequest = (request) => {
+    const original = resolveRequestOptions(request);
+    const sanitized = LLMRequest.update(original, sanitizeSurrogates({ ...LLMRequest.input(original), model: undefined }));
+    // Deduplicate per sibling level; a tool and a namespace may share a name.
+    const dedupe = (tools) => [...new Map(tools.map((tool) => [`${tool.type}:${tool.name}`, tool])).values()].map((tool) => tool.type === "tool" ? tool : { ...tool, tools: dedupe(tool.tools) });
+    const resolved = applyCachePolicy(LLMRequest.update(sanitized, { tools: dedupe(sanitized.tools) }));
+    const headers = resolved.model.route.headers?.({ request: resolved });
+    return headers === undefined
+        ? resolved
+        : LLMRequest.update(resolved, { http: mergeHttpOptions(new HttpOptions({ headers }), resolved.http) });
+};
+const compile = Effect.fn("LLM.compile")(function* (request, options) {
+    const resolved = prepareRequest(request);
+    const route = resolved.model.route;
+    const body = yield* route.body
+        .from(resolved)
+        .pipe(Effect.flatMap(ProviderShared.validateWith(Schema.decodeUnknownEffect(route.body.schema))));
+    const prepared = yield* route.prepareTransport(body, resolved, options);
+    return {
+        request: resolved,
+        route,
+        body,
+        prepared,
+    };
+});
+/** @internal Test-only projection of the execution compiler; not exported from package barrels. */
+export const compileRequest = Effect.fn("LLM.compileRequest")(function* (request) {
+    const compiled = yield* compile(request);
+    return {
+        id: compiled.request.id ?? "request",
+        route: compiled.route.id,
+        protocol: compiled.route.protocol,
+        model: compiled.request.model,
+        body: compiled.body,
+        metadata: { transport: compiled.route.transport.id },
+    };
+});
+const streamRequestWith = (runtime) => (request, options) => Stream.unwrap(Effect.gen(function* () {
+    const compiled = yield* compile(request, options);
+    return compiled.route.streamPrepared(compiled.prepared, compiled.request, runtime, options);
+}));
+const generateWith = (stream) => Effect.fn("LLM.generate")(function* (request, options) {
+    const state = yield* stream(request, options).pipe(Stream.runFold(LLMResponse.empty, LLMResponse.reduce));
+    const response = LLMResponse.complete(state);
+    if (response)
+        return response;
+    return yield* incompleteStreamError(`${request.model.provider}/${request.model.route.id}`);
+});
+export function stream(request, options) {
+    return Stream.unwrap(Effect.gen(function* () {
+        return (yield* Service).stream(request, options);
+    }));
+}
+export function generate(request, options) {
+    return Effect.gen(function* () {
+        return yield* (yield* Service).generate(request, options);
+    });
+}
+export function compact(request, options) {
+    return Effect.gen(function* () {
+        const client = yield* Service;
+        if (options?.mechanism === "trigger" && canCompact(request, options))
+            return yield* client.compact(request, options);
+        if ((options?.mechanism === undefined || options.mechanism === "endpoint") && canCompact(request))
+            return yield* client.compact(request, options);
+        return yield* unsupportedCompaction(request, options?.mechanism);
+    });
+}
+export const streamRequest = (request, options) => Stream.unwrap(Effect.gen(function* () {
+    return (yield* Service).stream(request, options);
+}));
+export const layer = Layer.effect(Service, Effect.gen(function* () {
+    const executor = yield* RequestExecutor.Service;
+    const stream = streamRequestWith({ http: executor });
+    function compact(request, options) {
+        return Effect.suspend(() => {
+            if (options?.mechanism === "trigger" && canCompact(request, options))
+                return request.model.route.compact.trigger(prepareRequest(request), executor, options);
+            if ((options?.mechanism === undefined || options.mechanism === "endpoint") && canCompact(request))
+                return request.model.route.compact.endpoint(prepareRequest(request), executor, options);
+            return unsupportedCompaction(request, options?.mechanism);
+        });
+    }
+    return Service.of({
+        stream,
+        generate: generateWith(stream),
+        compact,
+    });
+}));
+export const Route = { make };
+export const LLMClient = {
+    canCompact,
+    compact,
+    Service,
+    layer,
+    stream,
+    generate,
+};

package/dist/route/endpoint.d.ts

@@ -0,0 +1,28 @@
+import type { LLMRequest } from "../schema/index.js";
+export interface EndpointInput<Body> {
+    readonly request: LLMRequest;
+    readonly body: Body;
+}
+export type EndpointPart<Body> = string | ((input: EndpointInput<Body>) => string);
+/**
+ * Declarative URL construction for one route.
+ *
+ * `Endpoint` carries URL construction for one route. Routes with a canonical
+ * host put `baseURL` here; provider helpers can override it by configuring the
+ * route before selecting a model.
+ *
+ * `path` may be a string or a function of `EndpointInput`, for routes whose
+ * URL embeds the model id, region, or another body field (e.g. Bedrock,
+ * Gemini).
+ */
+export interface Definition<Body> {
+    readonly baseURL?: string;
+    readonly path: EndpointPart<Body>;
+    readonly query?: Record<string, string>;
+}
+export type EndpointPatch<Body> = Partial<Definition<Body>>;
+/** Construct an `Endpoint` from a path string or path function. */
+export declare const path: <Body>(value: EndpointPart<Body>, options?: Omit<Definition<Body>, "path">) => Definition<Body>;
+export declare const merge: <Body>(base: Definition<Body>, patch: EndpointPatch<Body>) => Definition<Body>;
+export declare const render: <Body>(endpoint: Definition<Body>, input: EndpointInput<Body>) => URL;
+export * as Endpoint from "./endpoint.js";

package/dist/route/endpoint.js

@@ -0,0 +1,21 @@
+import * as ProviderShared from "../protocols/shared.js";
+/** Construct an `Endpoint` from a path string or path function. */
+export const path = (value, options = {}) => ({
+    ...options,
+    path: value,
+});
+export const merge = (base, patch) => ({
+    ...base,
+    ...patch,
+    baseURL: patch.baseURL ?? base.baseURL,
+    path: patch.path ?? base.path,
+    query: patch.query === undefined ? base.query : { ...base.query, ...patch.query },
+});
+const renderPart = (part, input) => typeof part === "function" ? part(input) : part;
+export const render = (endpoint, input) => {
+    const url = new URL(`${ProviderShared.trimBaseUrl(endpoint.baseURL ?? "")}${renderPart(endpoint.path, input)}`);
+    for (const [key, value] of Object.entries(endpoint.query ?? {}))
+        url.searchParams.set(key, value);
+    return url;
+};
+export * as Endpoint from "./endpoint.js";

package/dist/route/executor.d.ts

@@ -0,0 +1,27 @@
+import { Context, Effect, Layer, Stream } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { HttpContext, AIError } from "../schema/index.js";
+export interface Interface {
+    readonly execute: (request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>;
+}
+export type HttpHandler = (request: HttpClientRequest.HttpClientRequest) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>;
+export type HttpMiddleware = (request: HttpClientRequest.HttpClientRequest, handler: HttpHandler) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>;
+declare const Service_base: Context.ServiceClass<Service, "@opencode/AI/RequestExecutor", Interface>;
+export declare class Service extends Service_base {
+}
+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 | undefined;
+    readonly status?: number | undefined;
+    readonly data?: unknown;
+    readonly responseHeaders?: Record<string, string> | undefined;
+    readonly responseBody?: string | undefined;
+    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>;
+export * as RequestExecutor from "./executor.js";

package/dist/route/executor.js

@@ -0,0 +1,183 @@
+import { Cause, Context, Effect, Layer, Option, Schema, Stream } from "effect";
+import { FetchHttpClient, Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, } from "effect/unstable/http";
+import { HttpContext, HttpRateLimitDetails, AIError, TransportError } from "../schema/index.js";
+import { classifyProviderFailure } from "../provider-error.js";
+export class Service extends Context.Service()("@opencode/AI/RequestExecutor") {
+}
+const headerDetails = (headers) => Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, String(value)]));
+const normalizedHeaders = (headers) => Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
+const retryAfterMs = (headers) => {
+    const millis = Number(headers["retry-after-ms"]);
+    if (Number.isFinite(millis))
+        return Math.max(0, millis);
+    const value = headers["retry-after"];
+    if (!value)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds))
+        return Math.max(0, seconds * 1000);
+    const date = Date.parse(value);
+    if (!Number.isNaN(date))
+        return Math.max(0, date - Date.now());
+    return undefined;
+};
+const addRateLimitValue = (target, key, value) => {
+    if (key.length > 0)
+        target[key] = value;
+};
+const rateLimitDetails = (headers, retryAfter) => {
+    const limit = {};
+    const remaining = {};
+    const reset = {};
+    Object.entries(headers).forEach(([name, value]) => {
+        const openaiLimit = /^x-ratelimit-limit-(.+)$/.exec(name)?.[1];
+        if (openaiLimit)
+            return addRateLimitValue(limit, openaiLimit, value);
+        const openaiRemaining = /^x-ratelimit-remaining-(.+)$/.exec(name)?.[1];
+        if (openaiRemaining)
+            return addRateLimitValue(remaining, openaiRemaining, value);
+        const openaiReset = /^x-ratelimit-reset-(.+)$/.exec(name)?.[1];
+        if (openaiReset)
+            return addRateLimitValue(reset, openaiReset, value);
+        const anthropic = /^anthropic-ratelimit-(.+)-(limit|remaining|reset)$/.exec(name);
+        if (!anthropic)
+            return;
+        if (anthropic[2] === "limit")
+            return addRateLimitValue(limit, anthropic[1], value);
+        if (anthropic[2] === "remaining")
+            return addRateLimitValue(remaining, anthropic[1], value);
+        return addRateLimitValue(reset, anthropic[1], value);
+    });
+    if (retryAfter === undefined &&
+        Object.keys(limit).length === 0 &&
+        Object.keys(remaining).length === 0 &&
+        Object.keys(reset).length === 0)
+        return undefined;
+    return new HttpRateLimitDetails({
+        retryAfterMs: retryAfter,
+        limit: Object.keys(limit).length === 0 ? undefined : limit,
+        remaining: Object.keys(remaining).length === 0 ? undefined : remaining,
+        reset: Object.keys(reset).length === 0 ? undefined : reset,
+    });
+};
+export const responseHttp = (response) => new HttpContext({
+    url: response.request.url,
+    status: response.status,
+    headers: headerDetails(response.headers),
+});
+const decodeProviderBody = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Struct({
+    message: Schema.optionalKey(Schema.String),
+    error: Schema.optionalKey(Schema.Struct({ message: Schema.optionalKey(Schema.String) })),
+})));
+const providerMessage = (status, body) => {
+    const decoded = body === undefined ? undefined : Option.getOrUndefined(decodeProviderBody(body));
+    return ([decoded?.error?.message, decoded?.message].find((message) => message?.trim()) ??
+        `Provider request failed with HTTP ${status}`);
+};
+const statusError = (response) => Effect.gen(function* () {
+    if (response.status < 400)
+        return response;
+    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,
+    });
+});
+/** 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);
+    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 }),
+        }),
+    });
+};
+const NativeTransportFailure = Schema.Struct({
+    message: Schema.String,
+    code: Schema.optionalKey(Schema.String),
+    cause: Schema.optionalKey(Schema.Unknown),
+});
+const decodeNativeTransportFailure = Schema.decodeUnknownOption(NativeTransportFailure);
+const nativeTransportFailure = (error) => {
+    const failure = Option.getOrUndefined(decodeNativeTransportFailure(error));
+    if (!failure)
+        return undefined;
+    if (failure.code !== undefined)
+        return failure;
+    const cause = Option.getOrUndefined(decodeNativeTransportFailure(failure.cause));
+    if (cause?.code !== undefined)
+        return cause;
+    return failure;
+};
+const httpError = (input) => {
+    const request = HttpClientError.isHttpClientError(input.error) ? input.error.request : input.request;
+    const transportError = (failure) => new AIError({
+        reason: new TransportError({
+            message: failure.message,
+            cause: source,
+            http: input.http,
+            transport: "http",
+            operation: input.operation,
+            code: failure.code,
+            url: request.url,
+        }),
+    });
+    const source = HttpClientError.isHttpClientError(input.error) && "cause" in input.error.reason
+        ? (input.error.reason.cause ?? input.error)
+        : input.error;
+    const native = nativeTransportFailure(source);
+    const code = native?.code;
+    const raw = native?.message ?? (input.error instanceof Error ? input.error.message : undefined);
+    const detail = raw;
+    const message = code && detail && !detail.includes(code) ? `${code}: ${detail}` : detail;
+    if (Cause.isTimeoutError(input.error) || Cause.isTimeoutError(source))
+        return transportError({ message: message ?? "HTTP transport timed out", code: code ?? "Timeout" });
+    if (!HttpClientError.isHttpClientError(input.error))
+        return transportError({ message: message ?? "HTTP transport failed", code });
+    if (input.error.reason._tag === "TransportError") {
+        return transportError({
+            message: message ?? input.error.reason.description ?? "HTTP transport failed",
+            code: code ?? input.error.reason._tag,
+        });
+    }
+    return transportError({
+        message: message ?? `HTTP transport failed: ${input.error.reason._tag}`,
+        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 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));
+        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);
+    });
+    return Service.of({
+        execute: executeOnce,
+    });
+}));
+export const fetchLayer = layer.pipe(Layer.provide(FetchHttpClient.layer));
+export * as RequestExecutor from "./executor.js";

package/dist/route/framing.d.ts

@@ -0,0 +1,29 @@
+import type { Stream } from "effect";
+import type { AIError } from "../schema/index.js";
+/**
+ * Decode a streaming HTTP response body into provider-protocol frames.
+ *
+ * `Framing` is the byte-stream-shaped seam between transport and protocol:
+ *
+ * - SSE (`Framing.sse`) — UTF-8 decode the body, run the SSE channel decoder,
+ *   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.
+ *
+ * The frame type is opaque to this layer; the protocol's event schema decodes
+ * each frame before its state machine handles it.
+ */
+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

@@ -0,0 +1,14 @@
+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",
+    frame: (bytes) => ProviderShared.sseFraming(bytes, events),
+});
+export * as Framing from "./framing.js";

package/dist/route/index.d.ts

@@ -0,0 +1,16 @@
+export { Route, LLMClient } from "./client.js";
+export type { Route as RouteShape, RouteLanguageModelInput, RouteRoutedLanguageModelInput, RouteDefaults, RouteDefaultsInput, AnyRoute, Interface as LLMClientShape, Service as LLMClientService, StreamOptions, CompactMethod, CompactionOperations, CompactionRequest, CheckpointRequest, EndpointCompactOptions, TriggerCompactOptions, } from "./client.js";
+export * from "./executor.js";
+export { Auth } from "./auth.js";
+export { AuthOptions } from "./auth-options.js";
+export { Endpoint } from "./endpoint.js";
+export { Framing } from "./framing.js";
+export { Protocol } from "./protocol.js";
+export { HttpTransport, WebSocketTransport } from "./transport/index.js";
+export * as Transport from "./transport/index.js";
+export type { Definition as AuthShape, AuthInput, Credential, CredentialError } from "./auth.js";
+export type { ApiKeyMode, AuthOverride, ProviderAuthOption } from "./auth-options.js";
+export type { Definition as EndpointFn, EndpointInput } from "./endpoint.js";
+export type { Definition as FramingDef } from "./framing.js";
+export type { Protocol as ProtocolDef } from "./protocol.js";
+export type { ChannelCheckpoint, ChannelCreate, ChannelObservation, HttpHandler, HttpMiddleware, Transport as TransportDef, TransportExecuteOptions, TransportExecution, TransportRuntime, WebSocketConnection, WebSocketChannelDriver, WebSocketChannelExchange, WebSocketChannelExecution, WebSocketChannelExecutor, WebSocketConnector, WebSocketRequest, } from "./transport/index.js";

package/dist/route/index.js

@@ -0,0 +1,9 @@
+export { Route, LLMClient } from "./client.js";
+export * from "./executor.js";
+export { Auth } from "./auth.js";
+export { AuthOptions } from "./auth-options.js";
+export { Endpoint } from "./endpoint.js";
+export { Framing } from "./framing.js";
+export { Protocol } from "./protocol.js";
+export { HttpTransport, WebSocketTransport } from "./transport/index.js";
+export * as Transport from "./transport/index.js";