@opencode/ai 2.0.13 → 2.0.15

package/dist/providers/openrouter.js

@@ -3,7 +3,8 @@ import { Route } from "../route/client.js";
 import { Endpoint } from "../route/endpoint.js";
 import { Protocol } from "../route/protocol.js";
 import { AuthOptions } from "../route/auth-options.js";
-import { ProviderID } from "../schema/index.js";
+import { HttpOptions, ProviderID } from "../schema/index.js";
+import { SystemOne } from "../experimental/system-one.js";
 import { OpenAIChat } from "../protocols/openai-chat.js";
 import { newBreakpoints, ttlBucket } from "../protocols/utils/cache.js";
 import { isRecord } from "../protocols/shared.js";
@@ -98,13 +99,24 @@ const configuredRoute = (input) => {
 };
 export const configure = (input = {}) => {
     const route = configuredRoute(input);
+    const evaluation = (modelID) => SystemOne.model({
+        id: modelID,
+        provider: id,
+        providerMetadataKey: "openrouter",
+        auth: AuthOptions.bearer(input, "OPENROUTER_API_KEY"),
+        baseURL: input.baseURL ?? baseURL,
+        headers: input.headers,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
     return {
         id,
         model: (modelID) => route.model({ id: modelID, compatibility: { supportsPromptCacheKey: true } }),
+        experimental: { evaluation },
         configure,
     };
 };
 export const provider = configure();
+export const experimental = provider.experimental;
 export const model = (modelID, { apiKey, baseURL, body, headers, ...providerOptions }) => configure({
     apiKey,
     baseURL,

package/dist/providers/vercel-ai-gateway.d.ts

@@ -0,0 +1,41 @@
+import { EvaluationModel } from "../experimental/evaluation.js";
+import { type ProviderAuthOption } from "../route/auth-options.js";
+import { HttpOptions, ModelID } from "../schema/index.js";
+export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+export interface EvaluationOptions {
+    readonly [key: string]: unknown;
+    readonly gateway?: Readonly<{
+        readonly [key: string]: unknown;
+        readonly zeroDataRetention?: boolean;
+        readonly only?: ReadonlyArray<string>;
+    }>;
+}
+export type Options = ProviderAuthOption<"optional"> & {
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions.Input;
+};
+export declare const configure: (input?: Options) => {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    experimental: {
+        evaluation: (modelID: string | ModelID) => EvaluationModel<EvaluationOptions>;
+    };
+    configure: (input?: Options) => /*elided*/ any;
+};
+export declare const provider: {
+    id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+    experimental: {
+        evaluation: (modelID: string | ModelID) => EvaluationModel<EvaluationOptions>;
+    };
+    configure: (input?: Options) => {
+        id: string & import("effect/Brand").Brand<"AI.ProviderID">;
+        experimental: {
+            evaluation: (modelID: string | ModelID) => EvaluationModel<EvaluationOptions>;
+        };
+        configure: /*elided*/ any;
+    };
+};
+export declare const experimental: {
+    evaluation: (modelID: string | ModelID) => EvaluationModel<EvaluationOptions>;
+};
+export * as VercelAIGateway from "./vercel-ai-gateway.js";

package/dist/providers/vercel-ai-gateway.js

@@ -0,0 +1,85 @@
+import { Effect, Schema } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { EvaluationAnswer, EvaluationInput, EvaluationModel, EvaluationQuestion, EvaluationResponse, EvaluationRounding, } from "../experimental/evaluation.js";
+import { Auth } from "../route/auth.js";
+import { AuthOptions } from "../route/auth-options.js";
+import { AIError, HttpContext, HttpOptions, InvalidProviderOutputError, InvalidRequestError, ModelID, ProviderID, ProviderMetadata, Usage, } from "../schema/index.js";
+export const id = ProviderID.make("vercel-ai-gateway");
+const baseURL = "https://ai-gateway.vercel.sh/v1";
+const Request = Schema.StructWithRest(Schema.Struct({
+    model: Schema.String,
+    state: EvaluationInput,
+    questions: Schema.Record(Schema.String, EvaluationQuestion),
+    providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+}), [Schema.Record(Schema.String, Schema.Any)]);
+const Response = Schema.Struct({
+    model: Schema.optional(Schema.String),
+    answers: Schema.Record(Schema.String, EvaluationAnswer),
+    usage: Schema.optional(Schema.Struct({
+        inputTokens: Schema.optional(Schema.Number),
+        outputTokens: Schema.optional(Schema.Number),
+    })),
+    rounding: Schema.optional(EvaluationRounding),
+    providerMetadata: Schema.optional(ProviderMetadata),
+});
+export const configure = (input = {}) => {
+    const evaluation = (modelID) => EvaluationModel.make({
+        id: modelID,
+        provider: id,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+        route: {
+            id: "vercel-evaluation",
+            evaluate: (req, send) => Effect.gen(function* () {
+                const url = new URL(`${(input.baseURL ?? baseURL).replace(/\/$/, "")}/evaluate`);
+                Object.entries(req.http?.query ?? {}).forEach(([key, value]) => url.searchParams.set(key, value));
+                const body = yield* Schema.encodeUnknownEffect(Schema.fromJsonString(Request))({
+                    ...req.http?.body,
+                    model: req.model.id,
+                    state: req.state,
+                    questions: req.questions,
+                    providerOptions: req.options,
+                }).pipe(Effect.mapError((cause) => new AIError({ reason: new InvalidRequestError({ message: cause.message, cause }) })));
+                const headers = yield* Auth.toEffect(AuthOptions.bearer(input, ["AI_GATEWAY_API_KEY", "VERCEL_OIDC_TOKEN"]))({
+                    request: req,
+                    method: "POST",
+                    url: url.toString(),
+                    body,
+                    headers: Headers.fromInput({ ...input.headers, ...req.http?.headers }),
+                });
+                const res = yield* send(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(body, "application/json")));
+                const http = new HttpContext({ url: res.request.url, status: res.status, headers: res.headers });
+                const fail = (message, cause, body) => new AIError({
+                    reason: new InvalidProviderOutputError({
+                        route: "vercel-evaluation",
+                        message,
+                        body,
+                        http,
+                        cause,
+                    }),
+                });
+                const text = yield* res.text.pipe(Effect.mapError((cause) => fail("Failed to read the Vercel AI Gateway evaluation response", cause)));
+                const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(text).pipe(Effect.mapError((cause) => fail("Vercel AI Gateway returned an invalid evaluation response", cause, text)));
+                return new EvaluationResponse({
+                    model: ModelID.make(data.model ?? req.model.id),
+                    answers: data.answers,
+                    usage: data.usage
+                        ? new Usage({
+                            inputTokens: data.usage.inputTokens,
+                            outputTokens: data.usage.outputTokens,
+                            totalTokens: data.usage.inputTokens === undefined && data.usage.outputTokens === undefined
+                                ? undefined
+                                : (data.usage.inputTokens ?? 0) + (data.usage.outputTokens ?? 0),
+                            providerMetadata: { gateway: data.usage },
+                        })
+                        : undefined,
+                    rounding: data.rounding,
+                    providerMetadata: data.providerMetadata,
+                });
+            }),
+        },
+    });
+    return { id, experimental: { evaluation }, configure };
+};
+export const provider = configure();
+export const experimental = provider.experimental;
+export * as VercelAIGateway from "./vercel-ai-gateway.js";

package/dist/route/client.d.ts

@@ -381,6 +381,14 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
         };
     } | undefined;
     readonly namespace?: string | undefined;
+} | {
+    readonly type: "media";
+    readonly media: import("../media.js").Asset;
+    readonly providerMetadata?: {
+        readonly [x: string]: {
+            readonly [x: string]: unknown;
+        };
+    } | undefined;
 } | {
     readonly type: "step-finish";
     readonly reason: {
@@ -409,12 +417,12 @@ export declare const streamRequest: (request: LLMRequest, options?: StreamOption
 } | {
     readonly type: "provider-error";
     readonly message: string;
+    readonly classification?: "context-overflow" | "payload-too-large" | undefined;
     readonly providerMetadata?: {
         readonly [x: string]: {
             readonly [x: string]: unknown;
         };
     } | undefined;
-    readonly classification?: "context-overflow" | "payload-too-large" | undefined;
 }, AIError, Service>;
 export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
 export declare const Route: {

package/dist/route/endpoint.d.ts

@@ -1,9 +1,9 @@
 import type { LLMRequest } from "../schema/index.js";
-export interface EndpointInput<Body> {
-    readonly request: LLMRequest;
+export interface EndpointInput<Body, Request = LLMRequest> {
+    readonly request: Request;
     readonly body: Body;
 }
-export type EndpointPart<Body> = string | ((input: EndpointInput<Body>) => string);
+export type EndpointPart<Body, Request = LLMRequest> = string | ((input: EndpointInput<Body, Request>) => string);
 /**
  * Declarative URL construction for one route.
  *
@@ -13,16 +13,16 @@ export type EndpointPart<Body> = string | ((input: EndpointInput<Body>) => strin
  *
  * `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).
+ * Gemini). Media routes reuse the same shape with their own request type.
  */
-export interface Definition<Body> {
+export interface Definition<Body, Request = LLMRequest> {
     readonly baseURL?: string;
-    readonly path: EndpointPart<Body>;
+    readonly path: EndpointPart<Body, Request>;
     readonly query?: Record<string, string>;
 }
-export type EndpointPatch<Body> = Partial<Definition<Body>>;
+export type EndpointPatch<Body, Request = LLMRequest> = Partial<Definition<Body, Request>>;
 /** 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 declare const path: <Body, Request = LLMRequest>(value: EndpointPart<Body, Request>, options?: Omit<Definition<Body, Request>, "path">) => Definition<Body, Request>;
+export declare const merge: <Body, Request = LLMRequest>(base: Definition<Body, Request>, patch: EndpointPatch<Body, Request>) => Definition<Body, Request>;
+export declare const render: <Body, Request = LLMRequest>(endpoint: Definition<Body, Request>, input: EndpointInput<Body, Request>) => URL;
 export * as Endpoint from "./endpoint.js";

package/dist/route/executor-service.d.ts

@@ -0,0 +1,12 @@
+import { Context, type Effect } from "effect";
+import type { HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
+import type { AIError } from "../schema/errors.js";
+export interface Interface {
+    readonly execute: (request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>;
+}
+export type HttpHandler = (request: HttpClientRequest.HttpClientRequest) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>;
+export type HttpMiddleware = (request: HttpClientRequest.HttpClientRequest, handler: HttpHandler) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>;
+declare const Service_base: Context.ServiceClass<Service, "@opencode/AI/RequestExecutor", Interface>;
+export declare class Service extends Service_base {
+}
+export {};

package/dist/route/executor-service.js

@@ -0,0 +1,3 @@
+import { Context } from "effect";
+export class Service extends Context.Service()("@opencode/AI/RequestExecutor") {
+}

package/dist/route/executor.d.ts

@@ -1,14 +1,9 @@
-import { Context, Effect, Layer, Stream } from "effect";
+import { Layer, Stream } from "effect";
 import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http";
 import { HttpContext, AIError } from "../schema/index.js";
-export interface Interface {
-    readonly execute: (request: HttpClientRequest.HttpClientRequest, middleware?: HttpMiddleware) => Effect.Effect<HttpClientResponse.HttpClientResponse, AIError>;
-}
-export type HttpHandler = (request: HttpClientRequest.HttpClientRequest) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>;
-export type HttpMiddleware = (request: HttpClientRequest.HttpClientRequest, handler: HttpHandler) => Effect.Effect<HttpClientResponse.HttpClientResponse, Error>;
-declare const Service_base: Context.ServiceClass<Service, "@opencode/AI/RequestExecutor", Interface>;
-export declare class Service extends Service_base {
-}
+import { Service, type HttpMiddleware, type Interface } from "./executor-service.js";
+export { Service } from "./executor-service.js";
+export type { HttpHandler, HttpMiddleware, Interface } from "./executor-service.js";
 export declare const responseHttp: (response: HttpClientResponse.HttpClientResponse) => HttpContext;
 /** Preserve HTTP diagnostics for executor and externally captured failures alike. */
 export declare const httpFailure: (input: {

package/dist/route/executor.js

@@ -1,9 +1,9 @@
-import { Cause, Context, Effect, Layer, Option, Schema, Stream } from "effect";
+import { Cause, Effect, Layer, Option, Schema, Stream } from "effect";
 import { FetchHttpClient, Headers, HttpClient, HttpClientError, HttpClientRequest, HttpClientResponse, } from "effect/unstable/http";
 import { HttpContext, HttpRateLimitDetails, AIError, TransportError } from "../schema/index.js";
 import { classifyProviderFailure } from "../provider-error.js";
-export class Service extends Context.Service()("@opencode/AI/RequestExecutor") {
-}
+import { Service } from "./executor-service.js";
+export { Service } from "./executor-service.js";
 const headerDetails = (headers) => Object.fromEntries(Object.entries(headers).map(([name, value]) => [name, String(value)]));
 const normalizedHeaders = (headers) => Object.fromEntries(Object.entries(headers).map(([key, value]) => [key.toLowerCase(), value]));
 const retryAfterMs = (headers) => {

package/dist/route/index.d.ts

@@ -4,6 +4,8 @@ export * from "./executor.js";
 export { Auth } from "./auth.js";
 export { AuthOptions } from "./auth-options.js";
 export { Endpoint } from "./endpoint.js";
+export { MediaRoute } from "./media.js";
+export { MediaProtocol } from "./media-protocol.js";
 export { Framing } from "./framing.js";
 export { Protocol } from "./protocol.js";
 export { HttpTransport, WebSocketTransport } from "./transport/index.js";

package/dist/route/index.js

@@ -3,6 +3,8 @@ export * from "./executor.js";
 export { Auth } from "./auth.js";
 export { AuthOptions } from "./auth-options.js";
 export { Endpoint } from "./endpoint.js";
+export { MediaRoute } from "./media.js";
+export { MediaProtocol } from "./media-protocol.js";
 export { Framing } from "./framing.js";
 export { Protocol } from "./protocol.js";
 export { HttpTransport, WebSocketTransport } from "./transport/index.js";

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

@@ -0,0 +1,45 @@
+import { Effect, Schema } from "effect";
+import { HttpClientResponse } from "effect/unstable/http";
+import { AIError, HttpContext } from "../schema/index.js";
+export type Body = {
+    readonly type: "json";
+    readonly value: Record<string, unknown>;
+} | {
+    readonly type: "multipart";
+    readonly value: FormData;
+};
+export declare const json: (value: Record<string, unknown>) => Body;
+export declare const multipart: (value: FormData) => Body;
+export interface DecodeContext<Request> {
+    readonly request: Request;
+    readonly body: Body;
+}
+/** One request, one response. JSON or multipart in; JSON or raw bytes out. */
+export interface Inline<Request, Response> {
+    readonly kind: "inline";
+    readonly id: string;
+    readonly name: string;
+    /** Common request fields this protocol cannot lower; the route rejects them before `body.from` runs. */
+    readonly unsupported?: ReadonlyArray<keyof Request & string>;
+    readonly body: {
+        readonly from: (request: Request) => Effect.Effect<Body, AIError>;
+    };
+    readonly 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>;
+/** Read a text body while retaining the original payload and HTTP context on every downstream error. */
+export declare const text: (route: string, name: string, response: HttpClientResponse.HttpClientResponse) => Effect.Effect<{
+    body: string;
+    http: HttpContext;
+    invalid: (message: string, cause?: unknown) => AIError;
+}, AIError, never>;
+/** 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;
+}, AIError, never>;
+export * as MediaProtocol from "./media-protocol.js";

package/dist/route/media-protocol.js

@@ -0,0 +1,40 @@
+import { Effect, Schema } from "effect";
+import { HttpClientResponse } from "effect/unstable/http";
+import { AIError, HttpContext, InvalidProviderOutputError } from "../schema/index.js";
+export const json = (value) => ({ type: "json", value });
+export const multipart = (value) => ({ type: "multipart", value });
+export const inline = (input) => ({
+    kind: "inline",
+    ...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. */
+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`,
+            http,
+            cause,
+        }),
+    })));
+    return {
+        body,
+        http,
+        invalid: (message, cause) => new AIError({ reason: new InvalidProviderOutputError({ route, message, body, http, cause }) }),
+    };
+});
+/** 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 };
+    });
+};
+export * as MediaProtocol from "./media-protocol.js";

package/dist/route/media.d.ts

@@ -0,0 +1,46 @@
+import { Effect } from "effect";
+import { Auth } from "./auth.js";
+import { Endpoint } from "./endpoint.js";
+import type { Interface } from "./executor-service.js";
+import { MediaProtocol } from "./media-protocol.js";
+import { AIError, HttpOptions, ProviderID } from "../schema/index.js";
+export type Execute = Interface["execute"];
+/** The minimum a media request must carry for the route to build a transport request. */
+export interface MediaRequest {
+    readonly model: {
+        readonly id: string;
+        readonly provider: ProviderID;
+        readonly http?: HttpOptions;
+    };
+    readonly http?: HttpOptions;
+}
+/** Deployment inputs every media model factory accepts; provider facades fill these from `configure(...)`. */
+export interface ModelInput {
+    readonly id: string;
+    readonly auth: Auth.Definition;
+    readonly baseURL?: string;
+    readonly headers?: Record<string, string>;
+    readonly http?: HttpOptions;
+}
+export interface Route<Request extends MediaRequest, Response> {
+    readonly id: string;
+    readonly provider: ProviderID;
+    readonly protocol: string;
+    readonly generate: (request: Request, execute: Execute) => Effect.Effect<Response, AIError>;
+}
+export interface MakeInput<Request extends MediaRequest, Response> {
+    readonly id: string;
+    readonly provider: string | ProviderID;
+    readonly protocol: MediaProtocol.Inline<Request, Response>;
+    readonly endpoint: Endpoint.Definition<MediaProtocol.Body, Request>;
+    readonly auth: Auth.Definition;
+    /** Deployment headers applied before transport authentication. */
+    readonly headers?: Record<string, string>;
+}
+/**
+ * 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 rejection, URL and query
+ * rendering, auth headers, JSON vs multipart encoding, and handing the response back to the protocol for decoding.
+ */
+export declare const make: <Request extends MediaRequest, Response>(input: MakeInput<Request, Response>) => Route<Request, Response>;
+export * as MediaRoute from "./media.js";

package/dist/route/media.js

@@ -0,0 +1,64 @@
+import { Effect } from "effect";
+import { Headers, HttpClientRequest } from "effect/unstable/http";
+import { Auth } from "./auth.js";
+import { Endpoint } from "./endpoint.js";
+import { MediaProtocol } from "./media-protocol.js";
+import { ProviderShared } from "../protocols/shared.js";
+import { AIError, HttpOptions, ProviderID, mergeHttpOptions } from "../schema/index.js";
+import { sanitizeSurrogates } from "../utils/sanitize.js";
+/**
+ * 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 rejection, URL and query
+ * rendering, auth headers, JSON vs multipart encoding, and handing the response back to the protocol for decoding.
+ */
+export const make = (input) => {
+    const provider = ProviderID.make(input.provider);
+    const routeHttp = input.headers === undefined ? undefined : new HttpOptions({ headers: input.headers });
+    const authorize = Auth.toEffect(input.auth);
+    return {
+        id: input.id,
+        provider,
+        protocol: input.protocol.id,
+        generate: Effect.fn(`MediaRoute.generate`)(function* (request, execute) {
+            yield* rejectUnsupported(input.id, provider, request, input.protocol.unsupported);
+            const http = mergeHttpOptions(routeHttp, request.model.http, request.http);
+            // Sanitize after merging so model-level overlays are covered; the model value is restored, not sanitized.
+            const resolved = { ...sanitizeSurrogates({ ...request, http }), model: request.model };
+            const body = yield* input.protocol.body.from(resolved);
+            const url = Endpoint.render(input.endpoint, { request: resolved, body });
+            for (const [key, value] of Object.entries(http?.query ?? {}))
+                url.searchParams.set(key, value);
+            const encoded = body.type === "json" ? ProviderShared.encodeJson(body.value) : "[multipart/form-data]";
+            const baseHeaders = Headers.fromInput(http?.headers);
+            const headers = yield* authorize({
+                request: resolved,
+                method: "POST",
+                url: url.toString(),
+                body: encoded,
+                // The HTTP client sets the multipart boundary; a caller-supplied content-type would corrupt it.
+                headers: body.type === "multipart" ? Headers.remove(baseHeaders, "content-type") : baseHeaders,
+            });
+            const transport = HttpClientRequest.post(url.toString()).pipe(HttpClientRequest.setHeaders(headers), body.type === "json"
+                ? HttpClientRequest.bodyText(encoded, "application/json")
+                : HttpClientRequest.bodyFormData(body.value));
+            const response = yield* execute(transport);
+            return yield* input.protocol.response.decode(response, { request: resolved, body });
+        }),
+    };
+};
+/** Common fields are never silently dropped: a present field the protocol declared unsupported fails typed. */
+const rejectUnsupported = (route, provider, request, unsupported) => {
+    const present = (unsupported ?? []).filter((field) => {
+        const value = request[field];
+        return Array.isArray(value) ? value.length > 0 : value !== undefined;
+    });
+    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(", ")}`,
+    }));
+};
+export * as MediaRoute from "./media.js";

package/dist/schema/errors.d.ts

@@ -147,13 +147,23 @@ declare const UnknownProviderError_base: Schema.Class<UnknownProviderError, Sche
 }>, import("effect/Cause").YieldableError>;
 export declare class UnknownProviderError extends UnknownProviderError_base {
 }
-export declare const AIErrorReason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestError, typeof UnsupportedOperationError, typeof NoRouteError, typeof AuthenticationError, typeof RateLimitError, typeof QuotaExceededError, typeof ContentPolicyError, typeof ProviderInternalError, typeof TransportError, typeof InvalidProviderOutputError, typeof UnknownProviderError]>;
+declare const TimeoutError_base: Schema.Class<TimeoutError, Schema.TaggedStruct<"Timeout", {
+    readonly timeoutMs: Schema.optional<Schema.Number>;
+    readonly message: Schema.String;
+    readonly body: Schema.optional<Schema.String>;
+    readonly http: Schema.optional<typeof HttpContext>;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+/** A caller-supplied deadline elapsed, such as `Generation.await` polling past its `Poll.timeout`. */
+export declare class TimeoutError extends TimeoutError_base {
+}
+export declare const AIErrorReason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestError, typeof UnsupportedOperationError, typeof NoRouteError, typeof AuthenticationError, typeof RateLimitError, typeof QuotaExceededError, typeof ContentPolicyError, typeof ProviderInternalError, typeof TransportError, typeof InvalidProviderOutputError, typeof UnknownProviderError, typeof TimeoutError]>;
 export type AIErrorReason = Schema.Schema.Type<typeof AIErrorReason>;
 declare const AIError_base: Schema.Class<AIError, Schema.TaggedStruct<"AI.Error", {
-    readonly reason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestError, typeof UnsupportedOperationError, typeof NoRouteError, typeof AuthenticationError, typeof RateLimitError, typeof QuotaExceededError, typeof ContentPolicyError, typeof ProviderInternalError, typeof TransportError, typeof InvalidProviderOutputError, typeof UnknownProviderError]>;
+    readonly reason: Schema.toTaggedUnion<"_tag", readonly [typeof InvalidRequestError, typeof UnsupportedOperationError, typeof NoRouteError, typeof AuthenticationError, typeof RateLimitError, typeof QuotaExceededError, typeof ContentPolicyError, typeof ProviderInternalError, typeof TransportError, typeof InvalidProviderOutputError, typeof UnknownProviderError, typeof TimeoutError]>;
 }>, import("effect/Cause").YieldableError>;
 export declare class AIError extends AIError_base {
-    readonly cause: InvalidRequestError | UnsupportedOperationError | NoRouteError | AuthenticationError | RateLimitError | QuotaExceededError | ContentPolicyError | ProviderInternalError | TransportError | InvalidProviderOutputError | UnknownProviderError;
+    readonly cause: InvalidRequestError | UnsupportedOperationError | NoRouteError | AuthenticationError | RateLimitError | QuotaExceededError | ContentPolicyError | ProviderInternalError | TransportError | InvalidProviderOutputError | UnknownProviderError | TimeoutError;
     get message(): string;
 }
 /**

package/dist/schema/errors.js

@@ -97,6 +97,12 @@ export class InvalidProviderOutputError extends Schema.TaggedError("AI.Error.Inv
 }
 export class UnknownProviderError extends Schema.TaggedError("AI.Error.UnknownProvider")("UnknownProvider", ReasonFields) {
 }
+/** A caller-supplied deadline elapsed, such as `Generation.await` polling past its `Poll.timeout`. */
+export class TimeoutError extends Schema.TaggedError("AI.Error.Timeout")("Timeout", {
+    ...ReasonFields,
+    timeoutMs: Schema.optional(Schema.Number),
+}) {
+}
 export const AIErrorReason = Schema.Union([
     InvalidRequestError,
     UnsupportedOperationError,
@@ -109,6 +115,7 @@ export const AIErrorReason = Schema.Union([
     TransportError,
     InvalidProviderOutputError,
     UnknownProviderError,
+    TimeoutError,
 ]).pipe(Schema.toTaggedUnion("_tag"));
 export class AIError extends Schema.TaggedError()("AI.Error", {
     reason: AIErrorReason,