@opencode-ai/ai 0.0.0-beta-17492

package/dist/route/executor.js

@@ -0,0 +1,227 @@
+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 { 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 requestId = (headers) => {
+    return (headers["x-request-id"] ??
+        headers["request-id"] ??
+        headers["x-amzn-requestid"] ??
+        headers["x-amz-request-id"] ??
+        headers["x-goog-request-id"] ??
+        headers["cf-ray"]);
+};
+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,
+    });
+};
+const requestDetails = (request) => new HttpRequestDetails({
+    method: request.method,
+    url: request.url,
+    headers: headerDetails(request.headers),
+});
+const responseDetails = (response) => new HttpResponseDetails({
+    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) })),
+})));
+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 responseHttp = (input) => new HttpContext({
+    request: requestDetails(input.request),
+    response: responseDetails(input.response),
+    ...input.body,
+    requestId: input.requestId,
+    rateLimit: input.rateLimit,
+});
+const statusError = (request) => (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,
+                requestId: requestId(headers),
+                rateLimit,
+            }),
+        }),
+    });
+});
+// 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) => {
+    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,
+            requestId: requestId(headers),
+            rateLimit,
+        }),
+    });
+};
+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({
+        module: "RequestExecutor",
+        method: input.operation,
+        reason: new TransportReason({
+            message: failure.message,
+            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;
+    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 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" })));
+}));
+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)));
+        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 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,23 @@
+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,
+ *   drop empty / `[DONE]` keep-alives. Each emitted frame is the JSON `data:`
+ *   payload of one event.
+ * - 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 `decode` step turns
+ * a frame into a typed chunk.
+ */
+export interface Definition<Frame> {
+    readonly id: string;
+    readonly frame: (bytes: Stream.Stream<Uint8Array, AIError>) => Stream.Stream<Frame, AIError>;
+}
+/** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
+export declare const sse: Definition<string>;
+export * as Framing from "./framing.js";

package/dist/route/framing.js

@@ -0,0 +1,4 @@
+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 };
+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, } 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";

package/dist/route/protocol.d.ts

@@ -0,0 +1,77 @@
+import { Schema, type Effect } from "effect";
+import type { AIError, LLMEvent, LLMRequest, ProtocolID } from "../schema/index.js";
+/**
+ * The semantic API contract of one model server family.
+ *
+ * A `Protocol` owns the parts of a route that are intrinsic to "what does
+ * this API look like": how a common `LLMRequest` becomes a provider-native
+ * body, what schema that body must satisfy before it is JSON-encoded, and
+ * how the streaming response decodes back into common `LLMEvent`s.
+ *
+ * Examples:
+ *
+ * - `OpenAIChat.protocol` — chat completions style
+ * - `OpenResponses.protocol` — provider-neutral Responses API baseline
+ * - `OpenAIResponses.protocol` — OpenAI extensions to that baseline
+ * - `AnthropicMessages.protocol` — messages API with content blocks
+ * - `Gemini.protocol` — generateContent
+ * - `BedrockConverse.protocol` — Converse with binary event-stream framing
+ *
+ * A `Protocol` is **not** a deployment. It does not know which URL, which
+ * headers, or which auth scheme to use. Those are deployment concerns owned
+ * by `Route.make(...)` along with the chosen `Endpoint`, `Auth`,
+ * and `Framing`. This separation is what lets DeepSeek, TogetherAI, Cerebras,
+ * etc. all reuse `OpenAIChat.protocol` without forking 300 lines per provider.
+ *
+ * The four type parameters reflect the pipeline:
+ *
+ * - `Body` — provider-native request body candidate. `Route.make(...)`
+ *   validates and JSON-encodes it with `body.schema`.
+ * - `Frame` — one unit of the framed response stream. SSE: a JSON data
+ *   string. AWS event stream: a parsed binary frame.
+ * - `Event` — schema-decoded provider event produced from one frame.
+ * - `State` — accumulator threaded through `stream.step` to translate event
+ *   sequences into `LLMEvent` sequences.
+ */
+export interface Protocol<Body, Frame, Event, State> {
+    /** Stable id for the wire protocol implementation. */
+    readonly id: ProtocolID;
+    /** Request side: schema for the provider-native body and how to build it. */
+    readonly body: ProtocolBody<Body>;
+    /** Response side: streaming state machine. */
+    readonly stream: ProtocolStream<Frame, Event, State>;
+}
+export interface ProtocolBody<Body> {
+    /** Schema for the validated provider-native body sent as the JSON request. */
+    readonly schema: Schema.Codec<Body, unknown>;
+    /** Build the provider-native body from a common `LLMRequest`. */
+    readonly from: (request: LLMRequest) => Effect.Effect<Body, AIError>;
+}
+export interface ProtocolStream<Frame, Event, State> {
+    /** Schema for one decoded streaming event, decoded from a transport frame. */
+    readonly event: Schema.Codec<Event, Frame>;
+    /** Initial parser state. Called once per response with the resolved request. */
+    readonly initial: (request: LLMRequest) => State;
+    /** Translate one event into emitted `LLMEvent`s plus the next state. */
+    readonly step: (state: State, event: Event) => Effect.Effect<readonly [State, ReadonlyArray<LLMEvent>], AIError>;
+    /** Optional request-completion signal for transports that do not end naturally. */
+    readonly terminal?: (event: Event) => boolean;
+    /** Optional flush emitted when the framed stream ends. */
+    readonly onHalt?: (state: State) => ReadonlyArray<LLMEvent>;
+}
+/**
+ * Construct a `Protocol` from its body and stream pieces:
+ *
+ * - `body.schema` infers the provider-native request body shape.
+ * - `body.from` ties the common `LLMRequest` to the provider body.
+ * - `stream.event` infers the decoded streaming event and the wire frame.
+ * - `stream.initial`, `stream.step`, and `stream.onHalt` infer the parser state.
+ *
+ * Provider implementations should usually call `Protocol.make({ ... })`
+ * without explicit type arguments; the schemas and parser functions are the
+ * source of truth. The constructor remains as the public seam for future
+ * cross-cutting concerns such as tracing or instrumentation.
+ */
+export declare const make: <Body, Frame, Event, State>(input: Protocol<Body, Frame, Event, State>) => Protocol<Body, Frame, Event, State>;
+export declare const jsonEvent: <const S extends Schema.Top>(schema: S) => Schema.fromJsonString<S>;
+export * as Protocol from "./protocol.js";

package/dist/route/protocol.js

@@ -0,0 +1,17 @@
+import { Schema } from "effect";
+/**
+ * Construct a `Protocol` from its body and stream pieces:
+ *
+ * - `body.schema` infers the provider-native request body shape.
+ * - `body.from` ties the common `LLMRequest` to the provider body.
+ * - `stream.event` infers the decoded streaming event and the wire frame.
+ * - `stream.initial`, `stream.step`, and `stream.onHalt` infer the parser state.
+ *
+ * Provider implementations should usually call `Protocol.make({ ... })`
+ * without explicit type arguments; the schemas and parser functions are the
+ * source of truth. The constructor remains as the public seam for future
+ * cross-cutting concerns such as tracing or instrumentation.
+ */
+export const make = (input) => input;
+export const jsonEvent = (schema) => Schema.fromJsonString(schema);
+export * as Protocol from "./protocol.js";

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

@@ -0,0 +1,34 @@
+import { Effect } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { Framing } from "../framing.js";
+import type { HttpMiddleware, Transport, TransportPrepareInput } from "./index.js";
+export type JsonRequestInput<Body> = TransportPrepareInput<Body>;
+export interface JsonRequestParts<Body = unknown> {
+    readonly url: string;
+    readonly jsonBody: Body | Record<string, unknown>;
+    readonly bodyText: string;
+    readonly headers: Headers.Headers;
+}
+export interface HttpPrepared<Frame> {
+    readonly request: HttpClientRequest.HttpClientRequest;
+    readonly framing: Framing.Definition<Frame>;
+    readonly middleware?: HttpMiddleware;
+}
+export declare const jsonRequestParts: <Body>(input: JsonRequestInput<Body>) => Effect.Effect<{
+    url: string;
+    jsonBody: Record<string, unknown> | Body;
+    bodyText: string;
+    headers: Headers.Headers;
+}, import("../../schema/errors.js").AIError, never>;
+export interface HttpJsonInput<_Body, Frame> {
+    readonly framing: Framing.Definition<Frame>;
+}
+export type HttpJsonPatch<Body, Frame> = Partial<HttpJsonInput<Body, Frame>>;
+export interface HttpJsonTransport<Body, Frame> extends Transport<Body, HttpPrepared<Frame>, Frame> {
+    readonly with: (patch: HttpJsonPatch<Body, Frame>) => HttpJsonTransport<Body, Frame>;
+}
+export declare const httpJson: <Body, Frame>(input: HttpJsonInput<Body, Frame>) => HttpJsonTransport<Body, Frame>;
+export declare const sseJson: {
+    readonly id: "http-json/sse";
+    readonly with: <Body>() => HttpJsonTransport<Body, string>;
+};

package/dist/route/transport/http.js

@@ -0,0 +1,63 @@
+import { Effect } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { Auth } from "../auth.js";
+import { render as renderEndpoint } from "../endpoint.js";
+import { Framing } from "../framing.js";
+import * as ProviderShared from "../../protocols/shared.js";
+import { mergeJsonRecords } from "../../schema/index.js";
+import { RequestExecutor } from "../executor.js";
+const applyQuery = (url, query) => {
+    if (!query)
+        return url;
+    const next = new URL(url);
+    Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value));
+    return next.toString();
+};
+const bodyWithOverlay = (body, request, encodeBody) => Effect.gen(function* () {
+    if (request.http?.body === undefined)
+        return { jsonBody: body, bodyText: encodeBody(body) };
+    if (ProviderShared.isRecord(body)) {
+        const overlaid = mergeJsonRecords(body, request.http.body) ?? {};
+        return { jsonBody: overlaid, bodyText: ProviderShared.encodeJson(overlaid) };
+    }
+    return yield* ProviderShared.invalidRequest("http.body can only overlay JSON object request bodies");
+});
+export const jsonRequestParts = (input) => Effect.gen(function* () {
+    const url = applyQuery(renderEndpoint(input.endpoint, { request: input.request, body: input.body }).toString(), input.request.http?.query);
+    const body = yield* bodyWithOverlay(input.body, input.request, input.encodeBody);
+    const headers = yield* Auth.toEffect(input.auth)({
+        request: input.request,
+        method: "POST",
+        url,
+        body: body.bodyText,
+        headers: Headers.fromInput({
+            ...input.headers?.({ request: input.request }),
+            ...input.request.http?.headers,
+        }),
+    });
+    return { url, jsonBody: body.jsonBody, bodyText: body.bodyText, headers };
+});
+export const httpJson = (input) => ({
+    id: "http-json",
+    with: (patch) => httpJson({ ...input, ...patch }),
+    prepare: (prepareInput) => Effect.gen(function* () {
+        const parts = yield* jsonRequestParts({ ...prepareInput });
+        const request = ProviderShared.jsonPost({
+            url: parts.url,
+            body: parts.bodyText,
+            headers: parts.headers,
+        });
+        return {
+            request,
+            framing: input.framing,
+            middleware: prepareInput.middleware,
+        };
+    }),
+    execute: (prepared, _request, runtime) => Effect.succeed({
+        frames: prepared.framing.frame(RequestExecutor.stream(runtime.http, prepared.request, prepared.middleware)),
+    }),
+});
+export const sseJson = {
+    id: "http-json/sse",
+    with: () => httpJson({ framing: Framing.sse }),
+};

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

@@ -0,0 +1,39 @@
+import type { Effect, Scope, Stream } from "effect";
+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";
+export interface TransportRuntime {
+    readonly http: RequestExecutorInterface;
+}
+export interface TransportExecution<Frame> {
+    readonly frames: Stream.Stream<Frame, AIError>;
+    /** Optional successful-consumption acknowledgement. HTTP leaves this absent. */
+    readonly complete?: Effect.Effect<void>;
+}
+export interface TransportExecuteOptions {
+    readonly webSocket?: WebSocketChannelExecutor;
+}
+export interface Transport<Body, Prepared, Frame> {
+    readonly id: string;
+    readonly prepare: (input: TransportPrepareInput<Body>) => Effect.Effect<Prepared, AIError>;
+    readonly execute: (prepared: Prepared, request: LLMRequest, runtime: TransportRuntime, options?: TransportExecuteOptions) => Effect.Effect<TransportExecution<Frame>, AIError, Scope.Scope>;
+}
+export interface TransportPrepareInput<Body> {
+    readonly body: Body;
+    readonly request: LLMRequest;
+    readonly endpoint: Endpoint.Definition<Body>;
+    readonly auth: Auth.Definition;
+    readonly encodeBody: (body: Body) => string;
+    readonly headers?: (input: {
+        readonly request: LLMRequest;
+    }) => Record<string, string>;
+    readonly middleware?: HttpMiddleware;
+    readonly webSocket?: WebSocketChannelExecutor;
+}
+export * as HttpTransport from "./http.js";
+export type { HttpHandler, HttpMiddleware } from "../executor.js";
+export type { ChannelCheckpoint, ChannelCreate, ChannelObservation, WebSocketChannelDriver, WebSocketChannelExchange, WebSocketChannelExecution, WebSocketChannelExecutor, } from "./websocket-channel.js";
+export type { WebSocketConnection, WebSocketConnector, WebSocketRequest } from "./websocket.js";
+export { WebSocketTransport } from "./websocket.js";

package/dist/route/transport/index.js

@@ -0,0 +1,4 @@
+import { Endpoint } from "../endpoint.js";
+import { Auth } from "../auth.js";
+export * as HttpTransport from "./http.js";
+export { WebSocketTransport } from "./websocket.js";

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

@@ -0,0 +1,56 @@
+import type { Effect, Scope, Stream } from "effect";
+import type { Headers } from "effect/unstable/http";
+import type { AIError } 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>;
+    /** Commits staged state after the decoded Route stream ends successfully. */
+    readonly complete: Effect.Effect<void>;
+}
+export interface WebSocketChannelExchange {
+    readonly id: string;
+    readonly connect: {
+        readonly url: string;
+        readonly headers: Headers.Headers;
+        /** Provider-safe connection age after which Core should rotate before sending. */
+        readonly rotateAfterMs?: number;
+    };
+    readonly fallback: () => Stream.Stream<string, AIError>;
+    readonly driver: WebSocketChannelDriver;
+}
+export interface WebSocketChannelDriver {
+    readonly create: (checkpoint: ChannelCheckpoint | undefined) => Effect.Effect<ChannelCreate, AIError>;
+    readonly observe: (create: ChannelCreate, frame: string) => Effect.Effect<ChannelObservation, AIError>;
+}
+export interface ChannelCreate {
+    readonly message: string;
+    readonly mode: "full" | "incremental";
+}
+export type ChannelObservation = {
+    readonly type: "frame";
+    readonly frame: string;
+} | {
+    readonly type: "completed";
+    readonly frame: string;
+    readonly checkpoint?: ChannelCheckpoint;
+} | {
+    readonly type: "incomplete";
+    readonly frame: string;
+} | {
+    readonly type: "provider-failure";
+    readonly error: AIError;
+} | {
+    readonly type: "rejected";
+    readonly error: AIError;
+    readonly recovery: "retry-full";
+} | {
+    readonly type: "rejected";
+    readonly error: AIError;
+    readonly recovery: "rotate-and-retry-full";
+};
+export interface ChannelCheckpoint {
+    readonly protocol: string;
+    readonly value: unknown;
+}

package/dist/route/transport/websocket-channel.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,55 @@
+import { Effect, Stream } from "effect";
+import { Headers } from "effect/unstable/http";
+import { Socket } from "effect/unstable/socket";
+import { AIError } from "../../schema/index.js";
+import type { Transport } from "./index.js";
+import type { WebSocketChannelExecutor } from "./websocket-channel.js";
+export interface WebSocketRequest {
+    readonly url: string;
+    readonly headers: Headers.Headers;
+}
+export interface WebSocketConnection {
+    readonly sendText: (message: string) => Effect.Effect<void, AIError>;
+    readonly messages: Stream.Stream<string | Uint8Array, AIError>;
+    readonly close: Effect.Effect<void, never>;
+}
+export interface WebSocketConnector {
+    readonly open: (input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError>;
+}
+export declare const toWebSocketUrl: (value: string) => Effect.Effect<string, AIError, never>;
+export declare const open: (input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError, Socket.WebSocketConstructor>;
+export declare const fromWebSocket: (ws: globalThis.WebSocket, input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError>;
+export declare const messageText: (message: string | Uint8Array, decoder: TextDecoder) => string;
+export declare const makeDirect: (connector: WebSocketConnector) => WebSocketChannelExecutor;
+export declare const direct: Effect.Effect<WebSocketChannelExecutor, never, Socket.WebSocketConstructor>;
+export interface JsonPrepared {
+    readonly url: string;
+    readonly headers: Headers.Headers;
+    readonly message: string;
+}
+export interface JsonInput<Body, Message> {
+    readonly toMessage: (body: Body | Record<string, unknown>) => Effect.Effect<Message, AIError>;
+    readonly encodeMessage: (message: Message) => string;
+}
+export type JsonPatch<Body, Message> = Partial<JsonInput<Body, Message>>;
+export interface JsonTransport<Body, Message> extends Transport<Body, JsonPrepared, string> {
+    readonly with: (patch: JsonPatch<Body, Message>) => JsonTransport<Body, Message>;
+}
+export declare const json: <Body, Message>(input: JsonInput<Body, Message>) => JsonTransport<Body, Message>;
+export declare const jsonTransport: {
+    readonly id: "websocket-json";
+    readonly with: <Body, Message>(input: JsonInput<Body, Message>) => JsonTransport<Body, Message>;
+};
+export declare const WebSocketTransport: {
+    readonly json: <Body, Message>(input: JsonInput<Body, Message>) => JsonTransport<Body, Message>;
+    readonly jsonTransport: {
+        readonly id: "websocket-json";
+        readonly with: <Body, Message>(input: JsonInput<Body, Message>) => JsonTransport<Body, Message>;
+    };
+    readonly direct: Effect.Effect<WebSocketChannelExecutor, never, Socket.WebSocketConstructor>;
+    readonly makeDirect: (connector: WebSocketConnector) => WebSocketChannelExecutor;
+    readonly open: (input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError, Socket.WebSocketConstructor>;
+    readonly fromWebSocket: (ws: globalThis.WebSocket, input: WebSocketRequest) => Effect.Effect<WebSocketConnection, AIError>;
+    readonly messageText: (message: string | Uint8Array, decoder: TextDecoder) => string;
+    readonly toWebSocketUrl: (value: string) => Effect.Effect<string, AIError, never>;
+};