@opencode/ai 0.0.0-dev-20120 → 0.0.0-dev-20123

package/dist/route/framing.js

@@ -1,16 +1,56 @@
-import { Stream } from "effect";
-import * as ProviderShared from "../protocols/shared.js";
+import { Effect, Stream } from "effect";
+import { makeParser } from "effect/unstable/encoding/Sse";
+import { AIError, InvalidProviderOutputError } from "../schema/index.js";
+/**
+ * `framing` step for Server-Sent Events. Decodes UTF-8, runs the SSE channel
+ * decoder, optionally filters named events, and drops empty events and known
+ * keepalives that proxies send as data. `[DONE]` is dropped by default or
+ * retained for protocols that use it as their stream boundary. Retry control events are ignored without
+ * interrupting the stream. Decoder failures become provider output errors so
+ * the public error channel stays `AIError`.
+ */
+export const sseFraming = (bytes, events, includeDone = false) => bytes.pipe(Stream.decodeText(), Stream.mapAccumEffect(() => {
+    const output = [];
+    return {
+        output,
+        parser: makeParser((event) => {
+            if (event._tag === "Event")
+                output.push(event);
+        }),
+    };
+}, (state, chunk) => Effect.gen(function* () {
+    const error = state.parser.feed(chunk);
+    if (error)
+        return yield* new AIError({
+            reason: new InvalidProviderOutputError({
+                route: "sse",
+                message: error.message,
+                body: chunk,
+                cause: error,
+            }),
+        });
+    return [state, state.output.splice(0)];
+})), Stream.filter((event) => (events === undefined || events.has(event.event)) &&
+    event.data.length > 0 &&
+    // Some OpenAI-compatible proxies serialize an empty flush as a bare
+    // `data: null`, between events or after `[DONE]`. No protocol has a
+    // null event, so it carries nothing and must not abort the stream.
+    event.data !== "null" &&
+    // Vertex AI partner models (e.g. `xai/grok-4.6`) send their SSE
+    // keepalive comment as `data: : keepalive` while reasoning.
+    event.data !== ": keepalive" &&
+    (event.data !== "[DONE]" || includeDone || (events !== undefined && event.event !== "message"))), Stream.map((event) => event.data));
 /** Server-Sent Events framing. Used by every JSON-streaming HTTP provider. */
-export const sse = { id: "sse", frame: ProviderShared.sseFraming };
+export const sse = { id: "sse", frame: sseFraming };
 /** Server-Sent Events framing that retains the conventional `[DONE]` sentinel. */
 export const sseWithDone = {
     id: "sse",
-    frame: (bytes) => ProviderShared.sseFraming(bytes, undefined, true),
+    frame: (bytes) => sseFraming(bytes, undefined, true),
 };
 /** SSE framing restricted to protocol-recognized event names. */
 export const sseEvents = (events) => ({
     id: "sse",
-    frame: (bytes) => ProviderShared.sseFraming(bytes, events),
+    frame: (bytes) => sseFraming(bytes, events),
 });
 export const lines = {
     id: "lines",

package/dist/route/media-protocol.d.ts

@@ -3,7 +3,7 @@ import { HttpClientResponse } from "effect/unstable/http";
 import type { Snapshot, Status } from "../generation.js";
 import { Media } from "../media.js";
 import type { AuthInput } from "./auth.js";
-import { AIError, HttpContext } from "../schema/index.js";
+import { AIError, HttpContext, ProviderID } from "../schema/index.js";
 /** Array values become repeated parameters (`keyterm=a&keyterm=b`). */
 export type Query = Readonly<Record<string, string | ReadonlyArray<string>>>;
 /** `query` is appended to the endpoint URL before the route and caller `http.query` overlays. */
@@ -34,7 +34,7 @@ export interface DecodeContext<Request> {
 export interface Inline<Request, Response> {
     readonly kind: "inline";
     readonly id: string;
-    readonly name: string;
+    readonly provider: ProviderID;
     /** Common request fields this protocol cannot lower; the route rejects them before `body.from` runs. */
     readonly unsupported?: ReadonlyArray<keyof Request & string>;
     readonly body: {
@@ -44,7 +44,7 @@ export interface Inline<Request, Response> {
         readonly decode: (response: HttpClientResponse.HttpClientResponse, context: DecodeContext<Request>) => Effect.Effect<Response, AIError>;
     };
 }
-export declare const inline: <Request, Response>(input: Omit<Inline<Request, Response>, "kind">) => Inline<Request, Response>;
+export declare const inline: <Request, Response>(route: Identity, input: Omit<Inline<Request, Response>, "kind" | "id" | "provider">) => Inline<Request, Response>;
 /** What `start` learned from the submission response: the route-owned handle plus the first observation. */
 export interface Started<Token> {
     readonly token: Token;
@@ -70,7 +70,7 @@ export interface PollContext<Token> {
 export interface Queued<Request, Response, Token> {
     readonly kind: "queued";
     readonly id: string;
-    readonly name: string;
+    readonly provider: ProviderID;
     /** Common request fields this protocol cannot lower; the route rejects them before `start.body.from` runs. */
     readonly unsupported?: ReadonlyArray<keyof Request & string>;
     /** Serializable handle. `Generation.token` carries the encoded form so it can be persisted and resumed elsewhere. */
@@ -95,7 +95,7 @@ export interface Queued<Request, Response, Token> {
         readonly path: (token: Token) => string;
     };
 }
-export declare const queued: <Request, Response, Token>(input: Omit<Queued<Request, Response, Token>, "kind">) => Queued<Request, Response, Token>;
+export declare const queued: <Request, Response, Token>(route: Identity, input: Omit<Queued<Request, Response, Token>, "kind" | "id" | "provider">) => Queued<Request, Response, Token>;
 export type Mode = "generate" | "stream";
 export type Addressed<Request> = Request & {
     readonly mode: Mode;
@@ -110,7 +110,7 @@ export interface ResponseContext<Request> extends DecodeContext<Addressed<Reques
 export interface Streamed<Request, Event, Frame, State> {
     readonly kind: "stream";
     readonly id: string;
-    readonly name: string;
+    readonly provider: ProviderID;
     /** Common request fields this protocol cannot lower; the route rejects them before `body.from` runs. */
     readonly unsupported?: ReadonlyArray<keyof Request & string>;
     readonly body: {
@@ -122,37 +122,44 @@ export interface Streamed<Request, Event, Frame, State> {
     /** Emit exactly one terminal event, or fail when the provider stopped before completing. */
     readonly finish: (state: State, context: ResponseContext<Request>) => Effect.Effect<ReadonlyArray<Event>, AIError>;
 }
-export declare const stream: <Request, Event, Frame, State>(input: Omit<Streamed<Request, Event, Frame, State>, "kind">) => Streamed<Request, Event, Frame, State>;
-/**
- * Read a text body while retaining the original payload and HTTP context on every downstream error. `invalid` is a
- * malformed provider document; `ended` is a generation that reached a terminal status without output (`failed` is
- * provider-side, `cancelled`/`expired` mean the result will never exist); `contentPolicy` is a moderated result.
- */
-export declare const text: (route: string, name: string, response: HttpClientResponse.HttpClientResponse) => Effect.Effect<{
-    body: string;
-    http: HttpContext;
-    invalid: (message: string, cause?: unknown) => AIError;
-    ended: (status: Exclude<Status, "queued" | "running" | "completed">, message: string) => AIError;
-    contentPolicy: (message: string) => AIError;
-}, AIError, never>;
-export type Output = Effect.Success<ReturnType<typeof text>>;
-/** Read and Schema-decode a JSON body. Decode failures keep the raw body as `reason.body`. */
-export declare const decodeJson: <A>(route: string, name: string, schema: Schema.Codec<A, unknown>) => (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<{
-    value: A;
-    body: string;
-    http: HttpContext;
-    invalid: (message: string, cause?: unknown) => AIError;
-    ended: (status: Exclude<Status, "queued" | "running" | "completed">, message: string) => AIError;
-    contentPolicy: (message: string) => AIError;
-}, AIError, never>;
-/** Decode a submission response into the token and first snapshot. */
-export declare const decodeStarted: <A, Token>(route: string, name: string, schema: Schema.Codec<A, unknown>, started: (value: A) => Started<Token>) => (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<Started<Token>, AIError, never>;
+export declare const stream: <Request, Event, Frame, State>(route: Identity, input: Omit<Streamed<Request, Event, Frame, State>, "kind" | "id" | "provider">) => Streamed<Request, Event, Frame, State>;
+/** One protocol's route id, display name, and provider, with the decoders and errors that carry them. */
+export declare const identity: (input: {
+    readonly id: string;
+    readonly name: string;
+    readonly provider: string;
+}) => {
+    id: string;
+    name: string;
+    provider: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    text: (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<{
+        body: string;
+        http: HttpContext;
+        invalid: (message: string, cause?: unknown) => AIError;
+        ended: (status: Exclude<Status, "queued" | "running" | "completed">, message: string) => AIError;
+        contentPolicy: (message: string) => AIError;
+    }, AIError, never>;
+    decodeJson: <A>(schema: Schema.Codec<A, unknown>) => (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<{
+        value: A;
+        body: string;
+        http: HttpContext;
+        invalid: (message: string, cause?: unknown) => AIError;
+        ended: (status: Exclude<Status, "queued" | "running" | "completed">, message: string) => AIError;
+        contentPolicy: (message: string) => AIError;
+    }, AIError, never>;
+    /** Decode a submission response into the token and first snapshot. */
+    decodeStarted: <A, Token>(schema: Schema.Codec<A, unknown>, started: (value: A) => Started<Token>) => (response: HttpClientResponse.HttpClientResponse) => Effect.Effect<Started<Token>, AIError, never>;
+    /** Schema-decode one JSON stream frame. Decode failures keep the frame as `reason.body`. */
+    decodeFrame: <A>(schema: Schema.Codec<A, unknown>) => (frame: string) => Effect.Effect<A, AIError, never>;
+    /** A stream-time failure; the frame stays on `reason.body`. */
+    frameError: (message: string, body?: string, cause?: unknown) => AIError;
+    incomplete: () => AIError;
+    unsupported: (operation: string, message: string) => AIError;
+};
+export type Identity = ReturnType<typeof identity>;
+export type Output = Effect.Success<ReturnType<Identity["text"]>>;
 /** Map a provider status string through the protocol's table; unknown values are an invalid provider document. */
 export declare const status: <Table extends Record<string, Status>>(table: Table, raw: string, output: Output) => Effect.Effect<Status, AIError>;
-export declare const frameError: (route: string, message: string, body?: string, cause?: unknown) => AIError;
-export declare const incomplete: (route: string) => AIError;
-/** Schema-decode one JSON stream frame. Decode failures keep the frame as `reason.body`. */
-export declare const decodeFrame: <A>(route: string, name: string, schema: Schema.Codec<A, unknown>) => (frame: string) => Effect.Effect<A, AIError, never>;
 /** A `url` asset whose provider-declared retention window starts now. */
 export declare const expiringUrl: (url: string, retention: Duration.Duration, options?: Parameters<typeof Media.url>[1]) => Effect.Effect<Media.Asset, never, never>;
 export * as MediaProtocol from "./media-protocol.js";

package/dist/route/media-protocol.js

@@ -1,7 +1,7 @@
 import { Clock, Duration, Effect, Schema } from "effect";
 import { HttpClientResponse } from "effect/unstable/http";
 import { Media } from "../media.js";
-import { AIError, ContentPolicyError, HttpContext, InvalidProviderOutputError, InvalidRequestError, ProviderInternalError, } from "../schema/index.js";
+import { AIError, ContentPolicyError, HttpContext, InvalidProviderOutputError, InvalidRequestError, ProviderID, ProviderInternalError, UnsupportedOperationError, } from "../schema/index.js";
 export const json = (value, query) => ({
     type: "json",
     value,
@@ -14,62 +14,80 @@ export const binary = (value, contentType, query) => ({
     contentType,
     query,
 });
-export const inline = (input) => ({
-    kind: "inline",
-    ...input,
-});
-export const queued = (input) => ({
-    kind: "queued",
-    ...input,
-});
-export const stream = (input) => ({
-    kind: "stream",
-    ...input,
-});
+export const inline = (route, input) => ({ kind: "inline", id: route.id, provider: route.provider, ...input });
+export const queued = (route, input) => ({ kind: "queued", id: route.id, provider: route.provider, ...input });
+export const stream = (route, input) => ({ kind: "stream", id: route.id, provider: route.provider, ...input });
 // ---------------------------------------------------------------------------
 // Response helpers
 // ---------------------------------------------------------------------------
 const context = (response) => new HttpContext({ url: response.request.url, status: response.status, headers: response.headers });
-/**
- * Read a text body while retaining the original payload and HTTP context on every downstream error. `invalid` is a
- * malformed provider document; `ended` is a generation that reached a terminal status without output (`failed` is
- * provider-side, `cancelled`/`expired` mean the result will never exist); `contentPolicy` is a moderated result.
- */
-export const text = Effect.fn("MediaProtocol.text")(function* (route, name, response) {
-    const http = context(response);
-    const body = yield* response.text.pipe(Effect.mapError((cause) => new AIError({
-        reason: new InvalidProviderOutputError({
-            route,
-            message: `Failed to read the ${name} response`,
+/** One protocol's route id, display name, and provider, with the decoders and errors that carry them. */
+export const identity = (input) => {
+    const provider = ProviderID.make(input.provider);
+    const frameError = (message, body, cause) => new AIError({ reason: new InvalidProviderOutputError({ route: input.id, message, body, cause }) });
+    /**
+     * Read a text body while retaining the original payload and HTTP context on every downstream error. `invalid` is a
+     * malformed provider document; `ended` is a generation that reached a terminal status without output (`failed` is
+     * provider-side, `cancelled`/`expired` mean the result will never exist); `contentPolicy` is a moderated result.
+     */
+    const text = Effect.fn("MediaProtocol.text")(function* (response) {
+        const http = context(response);
+        const body = yield* response.text.pipe(Effect.mapError((cause) => new AIError({
+            reason: new InvalidProviderOutputError({
+                route: input.id,
+                message: `Failed to read the ${input.name} response`,
+                http,
+                cause,
+            }),
+        })));
+        return {
+            body,
             http,
-            cause,
-        }),
-    })));
+            invalid: (message, cause) => new AIError({ reason: new InvalidProviderOutputError({ route: input.id, message, body, http, cause }) }),
+            ended: (status, message) => new AIError({
+                reason: status === "failed"
+                    ? new ProviderInternalError({ message, body, http })
+                    : new InvalidRequestError({ message, body, http }),
+            }),
+            contentPolicy: (message) => new AIError({ reason: new ContentPolicyError({ message, body, http }) }),
+        };
+    });
+    /** Read and Schema-decode a JSON body. Decode failures keep the raw body as `reason.body`. */
+    const decodeJson = (schema) => {
+        const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(schema));
+        return Effect.fn("MediaProtocol.decodeJson")(function* (response) {
+            const output = yield* text(response);
+            const value = yield* decode(output.body).pipe(Effect.mapError((cause) => output.invalid(`${input.name} returned an invalid response`, cause)));
+            return { ...output, value };
+        });
+    };
     return {
-        body,
-        http,
-        invalid: (message, cause) => new AIError({ reason: new InvalidProviderOutputError({ route, message, body, http, cause }) }),
-        ended: (status, message) => new AIError({
-            reason: status === "failed"
-                ? new ProviderInternalError({ message, body, http })
-                : new InvalidRequestError({ message, body, http }),
+        id: input.id,
+        name: input.name,
+        provider,
+        text,
+        decodeJson,
+        /** Decode a submission response into the token and first snapshot. */
+        decodeStarted: (schema, started) => {
+            const decode = decodeJson(schema);
+            return (response) => decode(response).pipe(Effect.map((output) => started(output.value)));
+        },
+        /** Schema-decode one JSON stream frame. Decode failures keep the frame as `reason.body`. */
+        decodeFrame: (schema) => {
+            const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(schema));
+            return (frame) => decode(frame).pipe(Effect.mapError((cause) => frameError(`${input.name} sent an invalid stream event`, frame, cause)));
+        },
+        /** A stream-time failure; the frame stays on `reason.body`. */
+        frameError,
+        incomplete: () => new AIError({
+            reason: new InvalidProviderOutputError({
+                route: input.id,
+                message: "The provider response ended unexpectedly.",
+                classification: "incomplete-stream",
+            }),
         }),
-        contentPolicy: (message) => new AIError({ reason: new ContentPolicyError({ message, body, http }) }),
+        unsupported: (operation, message) => new AIError({ reason: new UnsupportedOperationError({ operation, provider, route: input.id, message }) }),
     };
-});
-/** Read and Schema-decode a JSON body. Decode failures keep the raw body as `reason.body`. */
-export const decodeJson = (route, name, schema) => {
-    const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(schema));
-    return Effect.fn("MediaProtocol.decodeJson")(function* (response) {
-        const output = yield* text(route, name, response);
-        const value = yield* decode(output.body).pipe(Effect.mapError((cause) => output.invalid(`${name} returned an invalid response`, cause)));
-        return { ...output, value };
-    });
-};
-/** Decode a submission response into the token and first snapshot. */
-export const decodeStarted = (route, name, schema, started) => {
-    const decode = decodeJson(route, name, schema);
-    return (response) => decode(response).pipe(Effect.map((output) => started(output.value)));
 };
 /** Map a provider status string through the protocol's table; unknown values are an invalid provider document. */
 export const status = (table, raw, output) => {
@@ -78,19 +96,6 @@ export const status = (table, raw, output) => {
         return Effect.fail(output.invalid(`Unknown generation status "${raw}"`));
     return Effect.succeed(normalized);
 };
-export const frameError = (route, message, body, cause) => new AIError({ reason: new InvalidProviderOutputError({ route, message, body, cause }) });
-export const incomplete = (route) => new AIError({
-    reason: new InvalidProviderOutputError({
-        route,
-        message: "The provider response ended unexpectedly.",
-        classification: "incomplete-stream",
-    }),
-});
-/** Schema-decode one JSON stream frame. Decode failures keep the frame as `reason.body`. */
-export const decodeFrame = (route, name, schema) => {
-    const decode = Schema.decodeUnknownEffect(Schema.fromJsonString(schema));
-    return (frame) => decode(frame).pipe(Effect.mapError((cause) => frameError(route, `${name} sent an invalid stream event`, frame, cause)));
-};
 /** A `url` asset whose provider-declared retention window starts now. */
 export const expiringUrl = (url, retention, options) => Clock.currentTimeMillis.pipe(Effect.map((now) => Media.url(url, { ...options, expiresAt: now + Duration.toMillis(retention) })));
 export * as MediaProtocol from "./media-protocol.js";

package/dist/route/media.d.ts

@@ -23,6 +23,12 @@ export interface ModelInput {
     readonly headers?: Record<string, string>;
     readonly http?: HttpOptions;
 }
+/** A provider facade's `configure(...)` input as the `ModelInput` every media selector shares, minus the model id. */
+export declare const deployment: (input: {
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions.Input;
+}, auth: Auth.Definition) => Omit<ModelInput, "id">;
 /** One request, one response. */
 export interface Route<Request extends MediaRequest, Response> {
     readonly kind: "inline";
@@ -52,8 +58,6 @@ export interface StreamRoute<Request extends MediaRequest, Event, Response> {
 }
 export type AnyRoute<Request extends MediaRequest, Event, Response> = Route<Request, Response> | StreamRoute<Request, Event, Response> | QueuedRoute<Request, Response>;
 export interface Composition<Request extends MediaRequest> {
-    readonly id: string;
-    readonly provider: string | ProviderID;
     readonly endpoint: Endpoint.Definition<MediaProtocol.Body, Request>;
     readonly auth: Auth.Definition;
     /** Deployment headers applied before transport authentication. */

package/dist/route/media.js

@@ -2,13 +2,20 @@ import { Effect, Schema, Stream } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
 import { Auth } from "./auth.js";
 import { Endpoint } from "./endpoint.js";
-import { Service as RequestExecutorService } from "./executor-service.js";
+import { RequestExecutorService } from "./executor-service.js";
 import { RequestExecutor } from "./executor.js";
 import { MediaProtocol } from "./media-protocol.js";
-import { Generation, resultEvents, } from "../generation.js";
-import { ProviderShared } from "../protocols/shared.js";
-import { AIError, AIErrorReason, HttpOptions, InvalidRequestError, ProviderID, mergeHttpOptions, } from "../schema/index.js";
+import { Generation, resultEvents } from "../generation.js";
+import { AIError, AIErrorReason, HttpOptions, InvalidRequestError, ProviderID, UnsupportedOperationError, mergeHttpOptions, } from "../schema/index.js";
+import { encodeJson } from "../utils/json.js";
 import { sanitizeSurrogates } from "../utils/sanitize.js";
+/** A provider facade's `configure(...)` input as the `ModelInput` every media selector shares, minus the model id. */
+export const deployment = (input, auth) => ({
+    auth,
+    baseURL: input.baseURL,
+    headers: input.headers,
+    http: HttpOptions.make(input.http),
+});
 /**
  * Compose an inline media protocol with an endpoint and auth into a runnable route. The route owns the transport
  * plumbing every media protocol would otherwise duplicate: option merging, surrogate sanitizing, unsupported-field
@@ -19,8 +26,8 @@ export const inline = (input) => {
     const transport = makeTransport(input);
     return {
         kind: "inline",
-        id: input.id,
-        provider: transport.provider,
+        id: input.protocol.id,
+        provider: input.protocol.provider,
         protocol: input.protocol.id,
         generate: Effect.fn(`MediaRoute.generate`)(function* (request, execute) {
             const submitted = yield* transport.submit(request, { unsupported: input.protocol.unsupported, from: input.protocol.body.from }, execute);
@@ -45,14 +52,13 @@ export const queued = (input) => {
             .call("GET", operation.path(token), http, execute)
             .pipe(Effect.flatMap((sent) => operation.decode(sent.response, { token, auth: sent.auth, materialize })));
         const cancel = protocol.cancel;
-        const route = {
+        return {
             status: poll(protocol.status),
             result: poll(protocol.result),
             cancel: cancel === undefined
                 ? undefined
                 : transport.call(cancel.method, cancel.path(token), http, execute).pipe(Effect.asVoid),
         };
-        return route;
     };
     const start = Effect.fn("MediaRoute.start")(function* (request, execute) {
         const submitted = yield* transport.submit(request, { unsupported: protocol.unsupported, prepare: protocol.start.prepare, from: protocol.start.body.from }, execute);
@@ -63,14 +69,14 @@ export const queued = (input) => {
     const resume = Effect.fn("MediaRoute.resume")(function* (model, raw, execute) {
         const token = yield* decodeToken(raw).pipe(Effect.mapError((cause) => new AIError({
             reason: new InvalidRequestError({
-                message: `${input.id} cannot resume a generation from this token`,
+                message: `${protocol.id} cannot resume a generation from this token`,
                 cause,
             }),
         })));
         const route = generationRoute(token, transport.http(model), execute);
         return new Generation(route, encodeToken(token), yield* route.status);
     });
-    return { kind: "queued", id: input.id, provider: transport.provider, protocol: protocol.id, start, resume };
+    return { kind: "queued", id: protocol.id, provider: protocol.provider, protocol: protocol.id, start, resume };
 };
 /** Compose a streaming media protocol; `generate` runs the same stream in `generate` mode and folds it with `collect`. */
 export const stream = (input) => {
@@ -99,19 +105,21 @@ export const stream = (input) => {
     }));
     return {
         kind: "stream",
-        id: input.id,
-        provider: transport.provider,
+        id: protocol.id,
+        provider: protocol.provider,
         protocol: protocol.id,
         stream: (request, execute) => events(request, execute, "stream"),
         generate: (request, execute) => events(request, execute, "generate").pipe(Stream.runCollect, Effect.flatMap(input.collect)),
     };
 };
 export const dispatch = (input) => {
-    const notQueued = (route, operation) => ProviderShared.unsupportedOperation({
-        operation: `${input.modality}.${operation}`,
-        provider: route.provider,
-        route: route.id,
-        message: `${route.provider}/${route.id} is not a queued route; use generate or stream`,
+    const notQueued = (route, operation) => new AIError({
+        reason: new UnsupportedOperationError({
+            operation: `${input.modality}.${operation}`,
+            provider: route.provider,
+            route: route.id,
+            message: `${route.provider}/${route.id} is not a queued route; use generate or stream`,
+        }),
     });
     const start = (route, request) => {
         if (route.kind !== "queued")
@@ -143,11 +151,10 @@ export const dispatch = (input) => {
 // Transport plumbing shared by every kind
 // ---------------------------------------------------------------------------
 const makeTransport = (input) => {
-    const provider = ProviderID.make(input.provider);
     const routeHttp = input.headers === undefined ? undefined : new HttpOptions({ headers: input.headers });
     const authorize = Auth.toEffect(input.auth);
-    const baseURL = (path) => new URL(`${ProviderShared.trimBaseUrl(input.endpoint.baseURL ?? "")}${path}`);
-    /** `auth` is only what `Auth` added, never deployment headers. */
+    const baseURL = (path) => new URL(`${Endpoint.trimBaseUrl(input.endpoint.baseURL ?? "")}${path}`);
+    /** `auth` is only what `Auth` added or changed, never untouched deployment headers. */
     const send = Effect.fn("MediaRoute.send")(function* (call, execute) {
         const encoded = encode(call.body, call.headers);
         const url = call.url.toString();
@@ -159,15 +166,17 @@ const makeTransport = (input) => {
             headers: encoded.headers,
         });
         const response = yield* execute(encoded.apply(HttpClientRequest.make(call.method)(url).pipe(HttpClientRequest.setHeaders(headers))));
-        return { response, auth: Object.fromEntries(Object.entries(headers).filter(([key]) => !(key in call.headers))) };
+        return {
+            response,
+            auth: Object.fromEntries(Object.entries(headers).filter(([key, value]) => encoded.headers[key] !== value)),
+        };
     });
     return {
-        provider,
         /** Route and model overlays; `start` additionally merges the request's own `http`. */
         http: (model) => mergeHttpOptions(routeHttp, model.http),
         /** POST the protocol body to the route endpoint. */
         submit: Effect.fn("MediaRoute.submit")(function* (request, protocol, execute) {
-            yield* rejectUnsupported(input.id, provider, request, protocol.unsupported);
+            yield* rejectUnsupported(input.protocol.id, input.protocol.provider, request, protocol.unsupported);
             const http = mergeHttpOptions(routeHttp, request.model.http, request.http);
             const headers = Headers.fromInput(http?.headers);
             const prepared = protocol.prepare === undefined
@@ -202,7 +211,7 @@ const encode = (body, headers) => {
     if (body === undefined)
         return { text: "", headers, apply: (request) => request };
     if (body.type === "json") {
-        const text = ProviderShared.encodeJson(body.value);
+        const text = encodeJson(body.value);
         return { text, headers, apply: HttpClientRequest.bodyText(text, "application/json") };
     }
     if (body.type === "binary")
@@ -226,11 +235,13 @@ const rejectUnsupported = (route, provider, request, unsupported) => {
     });
     if (present.length === 0)
         return Effect.void;
-    return Effect.fail(ProviderShared.unsupportedOperation({
-        operation: `media.${present[0]}`,
-        provider,
-        route,
-        message: `${provider}/${route} does not support ${present.join(", ")}`,
+    return Effect.fail(new AIError({
+        reason: new UnsupportedOperationError({
+            operation: `media.${present[0]}`,
+            provider,
+            route,
+            message: `${provider}/${route} does not support ${present.join(", ")}`,
+        }),
     }));
 };
 export * as MediaRoute from "./media.js";

package/dist/schema/options.d.ts

@@ -18,8 +18,9 @@ export declare class HttpOptions extends HttpOptions_base {
 }
 export declare namespace HttpOptions {
     type Input = HttpOptions | ConstructorParameters<typeof HttpOptions>[0];
-    /** Normalize HTTP option input into the canonical `HttpOptions` class. */
-    const make: (input: Input) => HttpOptions;
+    /** Normalize HTTP option input into the canonical `HttpOptions` class; `undefined` stays `undefined`. */
+    function make(input: Input): HttpOptions;
+    function make(input: Input | undefined): HttpOptions | undefined;
 }
 export declare const mergeHttpOptions: (...items: ReadonlyArray<HttpOptions | undefined>) => HttpOptions | undefined;
 declare const GenerationOptions_base: Schema.Class<GenerationOptions, Schema.Struct<{
@@ -67,8 +68,10 @@ export declare namespace LanguageModelDefaults {
     /** Normalize selected-model request defaults without applying precedence. */
     const make: (input: Input) => LanguageModelDefaults;
 }
+/** Provider-defined string enum: known values for autocomplete, any string accepted. */
+export type OpenString<Known extends string> = Known | (string & {});
 export declare const ReasoningEfforts: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
-export type ReasoningEffort = (typeof ReasoningEfforts)[number] | (string & {});
+export type ReasoningEffort = OpenString<(typeof ReasoningEfforts)[number]>;
 export declare const ReasoningEffort: Schema.declare<ReasoningEffort, ReasoningEffort>;
 /** Tool schema sanitizer for a model family. `none` opts out of the protocol and model-name defaults. */
 export declare const LanguageModelSanitizerCompatibility: Schema.Literals<readonly ["gemini", "moonshot", "none"]>;

package/dist/schema/options.js

@@ -39,8 +39,12 @@ export class HttpOptions extends Schema.Class("AI.HttpOptions")({
 }) {
 }
 (function (HttpOptions) {
-    /** Normalize HTTP option input into the canonical `HttpOptions` class. */
-    HttpOptions.make = (input) => (input instanceof HttpOptions ? input : new HttpOptions(input));
+    function make(input) {
+        if (input === undefined || input instanceof HttpOptions)
+            return input;
+        return new HttpOptions(input);
+    }
+    HttpOptions.make = make;
 })(HttpOptions || (HttpOptions = {}));
 export const mergeHttpOptions = (...items) => {
     const body = mergeJsonRecords(...items.map((item) => item?.body));
@@ -93,7 +97,7 @@ export class LanguageModelDefaults extends Schema.Class("LLM.LanguageModelDefaul
         return new LanguageModelDefaults({
             generation: input.generation === undefined ? undefined : GenerationOptions.make(input.generation),
             providerOptions: input.providerOptions,
-            http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+            http: HttpOptions.make(input.http),
         });
     };
 })(LanguageModelDefaults || (LanguageModelDefaults = {}));

package/dist/speech.d.ts

@@ -3,7 +3,7 @@ import { Media } from "./media.js";
 import { MediaModel } from "./media-model.js";
 import { MediaRoute } from "./route/media.js";
 import type { MediaProtocol } from "./route/media-protocol.js";
-import { AIError, HttpOptions } from "./schema/index.js";
+import { AIError, HttpOptions, type OpenString } from "./schema/index.js";
 import { Service } from "./speech-client.js";
 export type SpeechOptions = Record<string, unknown>;
 export type SpeechRoute<Options extends SpeechOptions = SpeechOptions> = MediaRoute.StreamRoute<SpeechRequestFor<Options>, SpeechEvent, SpeechResponse>;
@@ -22,7 +22,7 @@ export declare const SpeechVoice: Schema.Union<readonly [Schema.String, Schema.S
     readonly id: Schema.String;
 }>]>;
 export type SpeechVoice = Schema.Schema.Type<typeof SpeechVoice>;
-export type SpeechFormat = "mp3" | "wav" | "pcm" | "opus" | "aac" | "flac" | (string & {});
+export type SpeechFormat = OpenString<"mp3" | "wav" | "pcm" | "opus" | "aac" | "flac">;
 /** Granularity is provider-native: characters on ElevenLabs, words on Cartesia. */
 export declare const SpeechTimestamp: Schema.Struct<{
     readonly text: Schema.String;

package/dist/speech.js

@@ -12,7 +12,7 @@ export class SpeechModel extends MediaModel {
     static fromRoute(route, input) {
         return new SpeechModel({
             id: input.id,
-            provider: route.provider,
+            provider: route.protocol.provider,
             http: input.http,
             route: composeRoute((composition) => MediaRoute.stream({ ...composition, collect: collectResponse }), route, input),
         });
@@ -102,7 +102,7 @@ export function request(input) {
         return input;
     return new SpeechRequest({
         ...input,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        http: HttpOptions.make(input.http),
     });
 }
 const requestEffect = (input) => tryRequest(() => request(input));

package/dist/transcription.js

@@ -12,7 +12,7 @@ export class TranscriptionModel extends MediaModel {
     static fromRoute(route, input) {
         return new TranscriptionModel({
             id: input.id,
-            provider: route.provider,
+            provider: route.protocol.provider,
             http: input.http,
             route: composeAnyRoute(route, input, collectResponse),
         });
@@ -110,7 +110,7 @@ export function request(input) {
         return input;
     return new TranscriptionRequest({
         ...input,
-        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        http: HttpOptions.make(input.http),
     });
 }
 const requestEffect = (input) => tryRequest(() => request(input));