@opencode-ai/ai 0.0.0-bootstrap.0 → 0.0.0-next-15618

package/dist/route/client.js

@@ -0,0 +1,211 @@
+import { Cause, Context, Effect, Layer, Schema, Stream } from "effect";
+import * as Option from "effect/Option";
+import { Auth } from "./auth";
+import { Endpoint } from "./endpoint";
+import { RequestExecutor } from "./executor";
+import { Framing } from "./framing";
+import { HttpTransport } from "./transport";
+import { WebSocketExecutor } from "./transport";
+import { applyCachePolicy } from "../cache-policy";
+import * as ProviderShared from "../protocols/shared";
+import { GenerationOptions, HttpOptions, LLMRequest, LLMResponse, Model, ModelLimits, LLMError as LLMErrorClass, LLMEvent, PreparedRequest, ProviderID, mergeGenerationOptions, mergeHttpOptions, mergeProviderOptions, } from "../schema";
+const makeRouteModel = (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 Model.make({
+        ...mapped,
+        provider,
+        route,
+    });
+};
+const mergeRouteDefaults = (base, patch) => {
+    const headers = mergeHeaders(base?.headers, patch.headers);
+    return {
+        ...base,
+        ...patch,
+        headers,
+        limits: patch.limits === undefined ? base?.limits : ModelLimits.make(patch.limits),
+        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 class Service extends Context.Service()("@opencode/LLMClient") {
+}
+const resolveRequestOptions = (request) => {
+    const routeDefaults = request.model.route.defaults;
+    const modelDefaults = request.model.defaults;
+    const generation = mergeGenerationOptions(routeDefaults.generation, modelDefaults?.generation, request.generation);
+    return LLMRequest.update(request, {
+        generation: generation ?? new GenerationOptions({}),
+        providerOptions: mergeProviderOptions(routeDefaults.providerOptions, modelDefaults?.providerOptions, request.providerOptions),
+        http: mergeHttpOptions(routeDefaults.http, modelDefaults?.http, request.http),
+    });
+};
+const streamError = (route, message, cause) => {
+    const failed = cause.reasons.find(Cause.isFailReason)?.error;
+    if (failed instanceof LLMErrorClass)
+        return failed;
+    return ProviderShared.eventError(route, message, Cause.pretty(cause));
+};
+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(ProviderShared.eventError(route, "Provider stream ended without a terminal finish event")))));
+});
+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 build = (routeInput) => {
+        const route = {
+            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,
+            transport: routeInput.transport,
+            defaults: routeInput.defaults ?? {},
+            body: protocol.body,
+            with: (patch) => {
+                const { id, provider, auth, transport, endpoint, ...defaults } = patch;
+                return build({
+                    ...routeInput,
+                    id: id ?? routeInput.id,
+                    provider: provider ?? routeInput.provider,
+                    auth: auth ?? routeInput.auth,
+                    endpoint: endpoint ? Endpoint.merge(routeInput.endpoint, endpoint) : routeInput.endpoint,
+                    transport: transport ?? routeInput.transport,
+                    defaults: mergeRouteDefaults(route.defaults, defaults),
+                });
+            },
+            model: (input) => makeRouteModel(route, input),
+            prepareTransport: (body, request) => routeInput.transport.prepare({
+                body,
+                request,
+                endpoint: routeInput.endpoint,
+                auth: routeInput.auth ?? Auth.none,
+                encodeBody,
+                headers: routeInput.headers,
+            }),
+            streamPrepared: (prepared, request, runtime) => {
+                const route = `${request.model.provider}/${request.model.route.id}`;
+                const events = routeInput.transport
+                    .frames(prepared, request, runtime)
+                    .pipe(Stream.mapEffect(decodeEvent(route)), protocol.stream.terminal ? Stream.takeUntil(protocol.stream.terminal) : (stream) => stream);
+                return events.pipe(Stream.mapAccumEffect(() => protocol.stream.initial(request), protocol.stream.step, protocol.stream.onHalt ? { onHalt: protocol.stream.onHalt } : undefined), Stream.catchCause((cause) => Stream.fail(streamError(route, `Failed to read ${route} stream`, cause))), requireTerminalEvent(route));
+            },
+        };
+        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({
+        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,
+    });
+}
+// `compile` is the important boundary: it turns a common `LLMRequest` into a
+// validated provider body plus transport-private prepared data, but does not
+// execute transport.
+const compile = Effect.fn("LLM.compile")(function* (request) {
+    const resolved = applyCachePolicy(resolveRequestOptions(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);
+    return {
+        request: resolved,
+        route,
+        body,
+        prepared,
+    };
+});
+const prepareWith = Effect.fn("LLMClient.prepare")(function* (request) {
+    const compiled = yield* compile(request);
+    return new PreparedRequest({
+        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) => Stream.unwrap(Effect.gen(function* () {
+    const compiled = yield* compile(request);
+    return compiled.route.streamPrepared(compiled.prepared, compiled.request, runtime);
+}));
+const generateWith = (stream) => Effect.fn("LLM.generate")(function* (request) {
+    const state = yield* stream(request).pipe(Stream.runFold(LLMResponse.empty, LLMResponse.reduce));
+    const response = LLMResponse.complete(state);
+    if (response)
+        return response;
+    return yield* ProviderShared.eventError(`${request.model.provider}/${request.model.route.id}`, "Provider stream ended without a terminal finish event");
+});
+export const prepare = (request) => prepareWith(request);
+export function stream(request) {
+    return Stream.unwrap(Effect.gen(function* () {
+        return (yield* Service).stream(request);
+    }));
+}
+export function generate(request) {
+    return Effect.gen(function* () {
+        return yield* (yield* Service).generate(request);
+    });
+}
+export const streamRequest = (request) => Stream.unwrap(Effect.gen(function* () {
+    return (yield* Service).stream(request);
+}));
+export const layer = Layer.effect(Service, Effect.gen(function* () {
+    const stream = streamRequestWith({
+        http: yield* RequestExecutor.Service,
+        webSocket: Option.getOrUndefined(yield* Effect.serviceOption(WebSocketExecutor.Service)),
+    });
+    return Service.of({ prepare: prepareWith, stream, generate: generateWith(stream) });
+}));
+export const Route = { make };
+export const LLMClient = {
+    Service,
+    layer,
+    prepare,
+    stream,
+    generate,
+};

package/dist/route/endpoint.d.ts

@@ -0,0 +1,28 @@
+import type { LLMRequest } from "../schema";
+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";

package/dist/route/endpoint.js

@@ -0,0 +1,21 @@
+import * as ProviderShared from "../protocols/shared";
+/** 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";

package/dist/route/executor.d.ts

@@ -0,0 +1,12 @@
+import { Context, Effect, Layer } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import { LLMError } from "../schema";
+export interface Interface {
+    readonly execute: (request: HttpClientRequest.HttpClientRequest) => Effect.Effect<HttpClientResponse.HttpClientResponse, LLMError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/LLM/RequestExecutor", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, HttpClient.HttpClient>;
+export declare const fetchLayer: Layer.Layer<Service, never, never>;
+export * as RequestExecutor from "./executor";

package/dist/route/executor.js

@@ -0,0 +1,229 @@
+import { Cause, Context, Effect, Layer } from "effect";
+import { FetchHttpClient, Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, } from "effect/unstable/http";
+import { HttpContext, HttpRateLimitDetails, HttpRequestDetails, HttpResponseDetails, LLMError, TransportReason, } from "../schema";
+import { classifyProviderFailure } from "../provider-error";
+export class Service extends Context.Service()("@opencode/LLM/RequestExecutor") {
+}
+const BODY_LIMIT = 16_384;
+const REDACTED = "<redacted>";
+// One source of truth for what counts as a sensitive name across headers,
+// URL query keys, and field names embedded inside request/response bodies.
+//
+// `SENSITIVE_NAME` is used as both a substring matcher (for free-form header
+// names like `Authorization` / `X-API-Key`) and as the body-field alternation
+// list. `SHORT_QUERY_NAME` covers anchored short keys like `?key=…` / `?sig=…`
+// that are too generic to redact substring-style without false positives.
+const SENSITIVE_NAME_SOURCE = "authorization|api[-_]?key|access[-_]?token|refresh[-_]?token|id[-_]?token|token|secret|credential|signature|x-amz-signature";
+const SENSITIVE_NAME = new RegExp(SENSITIVE_NAME_SOURCE, "i");
+const SHORT_QUERY_NAME = /^(key|sig)$/i;
+const SENSITIVE_BODY_FIELD = new RegExp(`(?:${SENSITIVE_NAME_SOURCE}|key)`, "i");
+const REDACT_JSON_FIELD = new RegExp(`("(?:${SENSITIVE_BODY_FIELD.source})"\\s*:\\s*)"[^"]*"`, "gi");
+const REDACT_QUERY_FIELD = new RegExp(`((?:${SENSITIVE_BODY_FIELD.source})=)[^&\\s"]+`, "gi");
+const isSensitiveHeaderName = (name) => SENSITIVE_NAME.test(name);
+const isSensitiveQueryName = (name) => isSensitiveHeaderName(name) || SHORT_QUERY_NAME.test(name);
+const redactHeaders = (headers, redactedNames) => Object.fromEntries(Object.entries(Headers.redact(headers, [...redactedNames, SENSITIVE_NAME])).map(([name, value]) => [
+    name,
+    String(value),
+]));
+const redactUrl = (value) => {
+    if (!URL.canParse(value))
+        return REDACTED;
+    const url = new URL(value);
+    url.searchParams.forEach((_, key) => {
+        if (isSensitiveQueryName(key))
+            url.searchParams.set(key, REDACTED);
+    });
+    return url.toString();
+};
+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, redactedNames) => new HttpRequestDetails({
+    method: request.method,
+    url: redactUrl(request.url),
+    headers: redactHeaders(request.headers, redactedNames),
+});
+const responseDetails = (response, redactedNames) => new HttpResponseDetails({
+    status: response.status,
+    headers: redactHeaders(response.headers, redactedNames),
+});
+const secretValues = (request) => {
+    const values = new Set();
+    const add = (value) => {
+        if (value.length < 4)
+            return;
+        values.add(value);
+        values.add(encodeURIComponent(value));
+    };
+    Object.entries(request.headers).forEach(([name, value]) => {
+        if (!isSensitiveHeaderName(name))
+            return;
+        add(value);
+        const bearer = /^Bearer\s+(.+)$/i.exec(value)?.[1];
+        if (bearer)
+            add(bearer);
+    });
+    if (!URL.canParse(request.url))
+        return values;
+    new URL(request.url).searchParams.forEach((value, key) => {
+        if (isSensitiveQueryName(key))
+            add(value);
+    });
+    return values;
+};
+// Two passes: structural (redact `"name": "value"` and `name=value` patterns
+// for any field name that looks sensitive) plus literal (replace any actual
+// secret values we sent in the request, in case the response echoes one back).
+const redactBody = (body, request) => Array.from(secretValues(request)).reduce((text, secret) => text.split(secret).join(REDACTED), body.replace(REDACT_JSON_FIELD, `$1"${REDACTED}"`).replace(REDACT_QUERY_FIELD, `$1${REDACTED}`));
+const responseBody = (body, request) => {
+    if (body === undefined)
+        return {};
+    const redacted = redactBody(body, request);
+    if (redacted.length <= BODY_LIMIT)
+        return { body: redacted };
+    return { body: redacted.slice(0, BODY_LIMIT), bodyTruncated: true };
+};
+const providerMessage = (status, body) => {
+    if (body.body && body.body.length <= 500)
+        return `Provider request failed with HTTP ${status}: ${body.body}`;
+    return `Provider request failed with HTTP ${status}`;
+};
+const responseHttp = (input) => new HttpContext({
+    request: requestDetails(input.request, input.redactedNames),
+    response: responseDetails(input.response, input.redactedNames),
+    ...input.body,
+    requestId: input.requestId,
+    rateLimit: input.rateLimit,
+});
+const statusError = (request, redactedNames) => (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, request);
+    return yield* new LLMError({
+        module: "RequestExecutor",
+        method: "execute",
+        reason: classifyProviderFailure({
+            status: response.status,
+            message: providerMessage(response.status, details),
+            retryAfterMs: retryAfter,
+            rateLimit,
+            http: responseHttp({
+                request,
+                response,
+                redactedNames,
+                body: details,
+                requestId: requestId(headers),
+                rateLimit,
+            }),
+        }),
+    });
+});
+const toHttpError = (redactedNames) => (error) => {
+    const transportError = (input) => new LLMError({
+        module: "RequestExecutor",
+        method: "execute",
+        reason: new TransportReason({
+            message: input.message,
+            kind: input.kind,
+            url: input.request ? redactUrl(input.request.url) : undefined,
+            http: input.request ? new HttpContext({ request: requestDetails(input.request, redactedNames) }) : undefined,
+        }),
+    });
+    if (Cause.isTimeoutError(error)) {
+        return transportError({ message: error.message, kind: "Timeout" });
+    }
+    if (!HttpClientError.isHttpClientError(error)) {
+        return transportError({ message: "HTTP transport failed" });
+    }
+    const request = "request" in error ? error.request : undefined;
+    if (error.reason._tag === "TransportError") {
+        return transportError({
+            message: error.reason.description ?? "HTTP transport failed",
+            kind: error.reason._tag,
+            request,
+        });
+    }
+    return transportError({
+        message: `HTTP transport failed: ${error.reason._tag}`,
+        kind: error.reason._tag,
+        request,
+    });
+};
+export const layer = Layer.effect(Service, Effect.gen(function* () {
+    const http = yield* HttpClient.HttpClient;
+    const executeOnce = (request) => Effect.gen(function* () {
+        const redactedNames = yield* Headers.CurrentRedactedNames;
+        return yield* http
+            .execute(request)
+            .pipe(Effect.mapError(toHttpError(redactedNames)), Effect.flatMap(statusError(request, redactedNames)));
+    });
+    return Service.of({
+        execute: executeOnce,
+    });
+}));
+export const fetchLayer = layer.pipe(Layer.provide(FetchHttpClient.layer));
+export * as RequestExecutor from "./executor";

package/dist/route/framing.d.ts

@@ -0,0 +1,23 @@
+import type { Stream } from "effect";
+import type { LLMError } from "../schema";
+/**
+ * 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, LLMError>) => Stream.Stream<Frame, LLMError>;
+}
+/** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
+export declare const sse: Definition<string>;
+export * as Framing from "./framing";

package/dist/route/framing.js

@@ -0,0 +1,4 @@
+import * as ProviderShared from "../protocols/shared";
+/** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
+export const sse = { id: "sse", frame: ProviderShared.sseFraming };
+export * as Framing from "./framing";

package/dist/route/index.d.ts

@@ -0,0 +1,16 @@
+export { Route, LLMClient } from "./client";
+export type { Route as RouteShape, RouteModelInput, RouteRoutedModelInput, RouteDefaults, RouteDefaultsInput, AnyRoute, Interface as LLMClientShape, Service as LLMClientService, } from "./client";
+export * from "./executor";
+export { Auth } from "./auth";
+export { AuthOptions } from "./auth-options";
+export { Endpoint } from "./endpoint";
+export { Framing } from "./framing";
+export { Protocol } from "./protocol";
+export { HttpTransport, WebSocketExecutor, WebSocketTransport } from "./transport";
+export * as Transport from "./transport";
+export type { Definition as AuthShape, AuthInput, Credential, CredentialError } from "./auth";
+export type { ApiKeyMode, AuthOverride, ProviderAuthOption } from "./auth-options";
+export type { Definition as EndpointFn, EndpointInput } from "./endpoint";
+export type { Definition as FramingDef } from "./framing";
+export type { Protocol as ProtocolDef } from "./protocol";
+export type { Transport as TransportDef, TransportRuntime } from "./transport";

package/dist/route/index.js

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

package/dist/route/protocol.d.ts

@@ -0,0 +1,76 @@
+import { Schema, type Effect } from "effect";
+import type { LLMError, LLMEvent, LLMRequest, ProtocolID } from "../schema";
+/**
+ * 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
+ * - `OpenAIResponses.protocol` — responses API
+ * - `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, LLMError>;
+}
+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>], LLMError>;
+    /** 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";

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