@opencode/ai 2.1.1 → 2.1.3

package/dist/cache-policy.js

@@ -94,8 +94,9 @@ const markSystemBoundaries = (system, hint, budget) => {
     return changed ? next : system;
 };
 const lastIndexOfRole = (messages, role) => messages.findLastIndex((m) => m.role === role);
+const isCacheablePart = (part) => part.type !== "compaction" && part.type !== "effort";
 // Mark the last text part of `messages[index]`. If no text part exists, mark
-// the last content part regardless of type — that's the breakpoint position
+// the last cacheable content part — that's the breakpoint position
 // in tool-result-only messages too.
 const markMessageAt = (messages, index, hint, budget) => {
     if (index < 0 || index >= messages.length)
@@ -104,12 +105,12 @@ const markMessageAt = (messages, index, hint, budget) => {
     if (target.content.length === 0)
         return messages;
     const lastTextIndex = target.content.findLastIndex((part) => part.type === "text");
-    const markAt = lastTextIndex >= 0 ? lastTextIndex : target.content.length - 1;
+    const markAt = lastTextIndex >= 0 ? lastTextIndex : target.content.findLastIndex(isCacheablePart);
     const existing = target.content[markAt];
-    if (("cache" in existing && existing.cache) || budget.remaining === 0)
+    if (!existing || !isCacheablePart(existing) || existing.cache || budget.remaining === 0)
         return messages;
     budget.remaining -= 1;
-    const nextContent = target.content.map((part, i) => (i === markAt ? { ...part, cache: hint } : part));
+    const nextContent = target.content.map((part, i) => (i === markAt ? { ...existing, cache: hint } : part));
     const next = new Message({ ...target, content: nextContent });
     // Single pass over `messages`, substituting the one updated entry. Long
     // conversations call this on every request, so avoid `.map()` here — its
@@ -141,7 +142,7 @@ const markMessages = (messages, strategy, hint, budget) => {
 const countHints = (request) => countToolHints(request.tools) +
     request.system.reduce((count, part) => count + (part.cache === undefined ? 0 : 1), 0) +
     request.messages.reduce((count, message) => count +
-        message.content.reduce((contentCount, part) => contentCount + ("cache" in part && part.cache !== undefined ? 1 : 0), 0), 0);
+        message.content.reduce((contentCount, part) => contentCount + (isCacheablePart(part) && part.cache !== undefined ? 1 : 0), 0), 0);
 export const applyCachePolicy = (request) => {
     const policy = selectPolicy(request);
     if (!policy.tools && !policy.system && !policy.messages)

package/dist/experimental/evaluation.d.ts

@@ -101,10 +101,10 @@ export type AnswersFor<Questions extends EvaluationQuestions> = {
 export type EvaluationOptions = Record<string, unknown>;
 export interface EvaluationRoute<Options extends EvaluationOptions = EvaluationOptions> {
     readonly id: string;
-    readonly evaluate: (request: EvaluationRequestFor<Options>, execute: Execute) => Effect.Effect<EvaluationResponse, AIError>;
+    evaluate(request: EvaluationRequestFor<Options>, execute: Execute): Effect.Effect<EvaluationResponse, AIError>;
 }
 export declare class EvaluationModel<Options extends EvaluationOptions = EvaluationOptions> {
-    protected readonly _Options: (options: Options) => Options;
+    protected readonly _Options: Options;
     readonly id: ModelID;
     readonly provider: ProviderID;
     readonly route: EvaluationRoute<Options>;
@@ -193,12 +193,12 @@ export type EvaluationRequestFor<Options extends EvaluationOptions = EvaluationO
     readonly questions: Questions;
     readonly options?: Options;
 };
-export type EvaluationRequestInput<Model extends object = EvaluationModel, Questions extends EvaluationQuestions = EvaluationQuestions> = Omit<ConstructorParameters<typeof EvaluationRequest>[0], "model" | "questions" | "options" | "http"> & {
+export type EvaluationRequestInput<Model extends EvaluationModel = EvaluationModel, Questions extends EvaluationQuestions = EvaluationQuestions> = Omit<ConstructorParameters<typeof EvaluationRequest>[0], "model" | "questions" | "options" | "http"> & {
     readonly model: Model;
     readonly questions: Questions;
     readonly options?: NoInfer<EvaluationModelOptions<Model>>;
     readonly http?: HttpOptions.Input;
-} & (Model extends EvaluationModel<EvaluationModelOptions<Model>> ? unknown : never);
+};
 declare const EvaluationRounding_base: Schema.Class<EvaluationRounding, Schema.Struct<{
     readonly probabilityDecimals: Schema.optional<Schema.Int>;
     readonly scoreDecimals: Schema.optional<Schema.Int>;
@@ -230,9 +230,10 @@ export declare class EvaluationResponse extends EvaluationResponse_base {
 export type EvaluationResponseFor<Questions extends EvaluationQuestions> = Omit<EvaluationResponse, "answers"> & {
     readonly answers: AnswersFor<Questions>;
 };
-export declare function request<const Model extends object, const Questions extends EvaluationQuestions>(input: EvaluationRequestInput<Model, Questions>): EvaluationRequestFor<EvaluationModelOptions<Model>, Questions>;
+export declare function request<const Model extends EvaluationModel, const Questions extends EvaluationQuestions>(input: EvaluationRequestInput<Model, Questions>): EvaluationRequestFor<EvaluationModelOptions<Model>, Questions>;
 export declare function request(input: EvaluationRequest): EvaluationRequest;
-export declare function run<const Model extends object, const Questions extends EvaluationQuestions>(input: EvaluationRequestInput<Model, Questions>): Effect.Effect<EvaluationResponseFor<Questions>, AIError, Service>;
+export declare function request(input: EvaluationRequest | EvaluationRequestInput): EvaluationRequest;
+export declare function run<const Model extends EvaluationModel, const Questions extends EvaluationQuestions>(input: EvaluationRequestInput<Model, Questions>): Effect.Effect<EvaluationResponseFor<Questions>, AIError, Service>;
 export declare function run(input: EvaluationRequest): Effect.Effect<EvaluationResponse, AIError, Service>;
 export declare const Evaluation: {
     readonly request: typeof request;

package/dist/experimental/evaluation.js

@@ -95,20 +95,19 @@ export function request(input) {
         return input;
     return new EvaluationRequest({
         ...input,
-        model: input.model,
         http: HttpOptions.make(input.http),
     });
 }
 export function run(input) {
     return Effect.try({
-        try: () => (input instanceof EvaluationRequest ? input : request(input)),
+        try: () => request(input),
         catch: (cause) => new AIError({
             reason: new InvalidRequestError({
                 message: cause instanceof Error ? cause.message : String(cause),
                 cause,
             }),
         }),
-    }).pipe(Effect.flatMap((request) => EvaluationClient.evaluate(request)));
+    }).pipe(Effect.flatMap(EvaluationClient.evaluate));
 }
 export const Evaluation = {
     request,

package/dist/experimental/realtime.d.ts

@@ -7,6 +7,7 @@ export type RealtimeTransportInput = {
 } | {
     readonly type: "websocket";
 };
+export type RealtimeTransportType = RealtimeTransportInput["type"];
 export type RealtimeTransport = {
     readonly type: "webrtc";
     readonly sdp: string;
@@ -23,25 +24,83 @@ export interface RealtimeConnectInput {
     readonly session?: RealtimeSession;
     readonly transport: RealtimeTransportInput;
 }
+export declare const engines: readonly [{
+    readonly family: "gpt-live";
+    readonly model: "gpt-live-1";
+    readonly id: "openai-live";
+    readonly provider: "openai";
+    readonly transports: readonly ["webrtc"];
+}, {
+    readonly family: "gpt-realtime";
+    readonly model: "gpt-realtime-2.1";
+    readonly id: "openai-realtime";
+    readonly provider: "openai";
+    readonly transports: readonly ["webrtc", "websocket"];
+}, {
+    readonly family: "grok-voice";
+    readonly model: "grok-voice-3.0";
+    readonly id: "xai-realtime";
+    readonly provider: "xai";
+    readonly transports: readonly ["websocket"];
+}, {
+    readonly family: "gemini-3.8-live";
+    readonly model: "gemini-3.8-live";
+    readonly id: "gemini-live";
+    readonly provider: "google";
+    readonly transports: readonly ["websocket"];
+}];
 export declare const engine: (model: string) => {
     readonly family: "gpt-live";
+    readonly model: "gpt-live-1";
     readonly id: "openai-live";
     readonly provider: "openai";
+    readonly transports: readonly ["webrtc"];
 } | {
     readonly family: "gpt-realtime";
+    readonly model: "gpt-realtime-2.1";
     readonly id: "openai-realtime";
     readonly provider: "openai";
+    readonly transports: readonly ["webrtc", "websocket"];
 } | {
     readonly family: "grok-voice";
+    readonly model: "grok-voice-3.0";
     readonly id: "xai-realtime";
     readonly provider: "xai";
+    readonly transports: readonly ["websocket"];
 } | {
     readonly family: "gemini-3.8-live";
+    readonly model: "gemini-3.8-live";
     readonly id: "gemini-live";
     readonly provider: "google";
+    readonly transports: readonly ["websocket"];
 } | undefined;
 export declare const connect: (input: RealtimeConnectInput) => Effect.Effect<RealtimeTransport, AIError, import("../route/executor-service.js").RequestExecutorService>;
 export declare const Realtime: {
+    readonly engines: readonly [{
+        readonly family: "gpt-live";
+        readonly model: "gpt-live-1";
+        readonly id: "openai-live";
+        readonly provider: "openai";
+        readonly transports: readonly ["webrtc"];
+    }, {
+        readonly family: "gpt-realtime";
+        readonly model: "gpt-realtime-2.1";
+        readonly id: "openai-realtime";
+        readonly provider: "openai";
+        readonly transports: readonly ["webrtc", "websocket"];
+    }, {
+        readonly family: "grok-voice";
+        readonly model: "grok-voice-3.0";
+        readonly id: "xai-realtime";
+        readonly provider: "xai";
+        readonly transports: readonly ["websocket"];
+    }, {
+        readonly family: "gemini-3.8-live";
+        readonly model: "gemini-3.8-live";
+        readonly id: "gemini-live";
+        readonly provider: "google";
+        readonly transports: readonly ["websocket"];
+    }];
     readonly engine: typeof engine;
     readonly connect: (input: RealtimeConnectInput) => Effect.Effect<RealtimeTransport, AIError, import("../route/executor-service.js").RequestExecutorService>;
 };

package/dist/experimental/realtime.js

@@ -1,16 +1,28 @@
 import { Clock, Effect, Redacted, Schema } from "effect";
 import { HttpClientRequest } from "effect/http";
 import { RequestExecutor } from "../route/executor.js";
-import { AIError, HttpContext, InvalidProviderOutputError, InvalidRequestError } from "../schema/index.js";
+import { AIError, InvalidProviderOutputError, InvalidRequestError } from "../schema/index.js";
 import { encodeJson } from "../utils/json.js";
 const OPENAI_BASE_URL = "https://api.openai.com/v1";
 const XAI_BASE_URL = "https://api.x.ai/v1";
 const GOOGLE_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
-const engines = [
-    { family: "gpt-live", id: "openai-live", provider: "openai" },
-    { family: "gpt-realtime", id: "openai-realtime", provider: "openai" },
-    { family: "grok-voice", id: "xai-realtime", provider: "xai" },
-    { family: "gemini-3.8-live", id: "gemini-live", provider: "google" },
+export const engines = [
+    { family: "gpt-live", model: "gpt-live-1", id: "openai-live", provider: "openai", transports: ["webrtc"] },
+    {
+        family: "gpt-realtime",
+        model: "gpt-realtime-2.1",
+        id: "openai-realtime",
+        provider: "openai",
+        transports: ["webrtc", "websocket"],
+    },
+    { family: "grok-voice", model: "grok-voice-3.0", id: "xai-realtime", provider: "xai", transports: ["websocket"] },
+    {
+        family: "gemini-3.8-live",
+        model: "gemini-3.8-live",
+        id: "gemini-live",
+        provider: "google",
+        transports: ["websocket"],
+    },
 ];
 // Matches the bare family name (`gpt-realtime`) and its versions (`gpt-realtime-2.1`, `gpt-realtime-mini`).
 export const engine = (model) => engines.find((item) => model === item.family || model.startsWith(`${item.family}-`));
@@ -18,17 +30,20 @@ export const connect = Effect.fn("Realtime.connect")(function* (input) {
     const resolved = engine(input.model);
     if (!resolved)
         return yield* invalidRequest(`Unsupported voice model: ${input.model}`);
+    if (!resolved.transports.some((type) => type === input.transport.type))
+        return yield* invalidRequest(`${input.model} only supports ${resolved.transports.join(", ")} transport`);
     const session = { ...input.session, model: input.model };
     switch (resolved.id) {
         case "openai-live": {
-            if (input.transport.type !== "webrtc")
-                return yield* invalidRequest("OpenAI GPT-Live only supports WebRTC transport");
             const data = yield* post(resolved.id, `${OPENAI_BASE_URL}/live/sessions`, input.apiKey, { session, transport: input.transport }, LiveSessionResponse);
             return { type: "webrtc", sdp: data.transport.sdp };
         }
         case "openai-realtime": {
             if (input.transport.type === "websocket")
-                return yield* clientSecret(resolved.id, OPENAI_BASE_URL, input.model, input.apiKey, session);
+                return yield* clientSecret(resolved.id, OPENAI_BASE_URL, input.model, input.apiKey, {
+                    expires_after: { anchor: "created_at", seconds: 60 },
+                    session,
+                });
             const form = new FormData();
             form.append("sdp", input.transport.sdp);
             form.append("session", encodeJson(session));
@@ -36,14 +51,11 @@ export const connect = Effect.fn("Realtime.connect")(function* (input) {
             const sdp = yield* post(resolved.id, `${OPENAI_BASE_URL}/realtime/calls${query}`, input.apiKey, form, Schema.String);
             return { type: "webrtc", sdp };
         }
-        case "xai-realtime": {
-            if (input.transport.type !== "websocket")
-                return yield* invalidRequest("xAI Grok Voice only supports WebSocket transport");
-            return yield* clientSecret(resolved.id, XAI_BASE_URL, input.model, input.apiKey);
-        }
+        case "xai-realtime":
+            return yield* clientSecret(resolved.id, XAI_BASE_URL, input.model, input.apiKey, {
+                expires_after: { seconds: 60 },
+            });
         case "gemini-live": {
-            if (input.transport.type !== "websocket")
-                return yield* invalidRequest("Google Gemini Live only supports WebSocket transport");
             const now = yield* Clock.currentTimeMillis;
             const expiresAt = now + 60_000;
             const data = yield* post(resolved.id, `${GOOGLE_BASE_URL}/auth_tokens`, input.apiKey, {
@@ -62,6 +74,7 @@ export const connect = Effect.fn("Realtime.connect")(function* (input) {
     }
 });
 export const Realtime = {
+    engines,
     engine,
     connect,
 };
@@ -69,7 +82,7 @@ const LiveSessionResponse = Schema.fromJsonString(Schema.Struct({
     transport: Schema.Struct({ sdp: Schema.String }),
 }));
 // xAI's ephemeral-token docs (https://docs.x.ai/developers/model-capabilities/audio/ephemeral-tokens)
-// document the request body (`{ expires_after: { seconds } }`) but not the response payload; we assume
+// document the request body (`{ expires_after: { seconds } }`, no `anchor` or `session`) but not the response payload; we assume
 // it mirrors OpenAI's `{ value, expires_at }` response shape.
 const ClientSecretResponse = Schema.fromJsonString(Schema.Struct({
     value: Schema.String,
@@ -86,12 +99,12 @@ const post = (route, url, apiKey, body, response, authHeader) => Effect.gen(func
         : HttpClientRequest.bearerToken(apiKey), body instanceof FormData
         ? HttpClientRequest.bodyFormData(body)
         : HttpClientRequest.bodyText(encodeJson(body), "application/json")));
-    const http = new HttpContext({ url: res.request.url, status: res.status, headers: res.headers });
+    const http = RequestExecutor.responseHttp(res);
     const fail = (message, cause, raw) => new AIError({ reason: new InvalidProviderOutputError({ route, message, body: raw, http, cause }) });
     const text = yield* res.text.pipe(Effect.mapError((cause) => fail(`Failed to read ${route} response`, cause)));
     return yield* Schema.decodeEffect(response)(text).pipe(Effect.mapError((cause) => fail(`${route} returned an invalid response`, cause, text)));
 });
-const clientSecret = (route, baseURL, model, apiKey, session) => post(route, `${baseURL}/realtime/client_secrets`, apiKey, { expires_after: { seconds: 60 }, session }, ClientSecretResponse).pipe(Effect.map((data) => ({
+const clientSecret = (route, baseURL, model, apiKey, body) => post(route, `${baseURL}/realtime/client_secrets`, apiKey, body, ClientSecretResponse).pipe(Effect.map((data) => ({
     type: "websocket",
     url: `${baseURL.replace(/^http/, "ws")}/realtime?model=${encodeURIComponent(model)}`,
     token: data.value,

package/dist/experimental/system-one.js

@@ -2,7 +2,9 @@ import { Effect, Schema } from "effect";
 import { Headers, HttpClientRequest } from "effect/http";
 import { ChoiceQuestion, EvaluationInput, EvaluationModel, EvaluationResponse, EvaluationRounding, ScoreQuestion, } from "./evaluation.js";
 import { Auth } from "../route/auth.js";
-import { AIError, HttpContext, HttpOptions, InvalidProviderOutputError, InvalidRequestError, ModelID, Usage, mergeJsonRecords, } from "../schema/index.js";
+import { RequestExecutor } from "../route/executor.js";
+import { JsonObject, ProviderShared } from "../protocols/shared.js";
+import { AIError, HttpOptions, InvalidProviderOutputError, InvalidRequestError, ModelID, ProviderMetadata, Usage, mergeJsonRecords, } from "../schema/index.js";
 const Noul = Schema.Struct({
     type: Schema.Literal("noul"),
     instructions: EvaluationInput,
@@ -24,7 +26,7 @@ const Request = Schema.StructWithRest(Schema.Struct({
     model: Schema.String,
     state: EvaluationInput,
     questions: Schema.Record(Schema.String, Question),
-}), [Schema.Record(Schema.String, Schema.Any)]);
+}), [JsonObject]);
 const Probability = Schema.Number.check(Schema.isBetween({ minimum: 0, maximum: 1 }));
 const NoulAnswer = Schema.Struct({ type: Schema.Literal("noul"), noul: Probability });
 const Choice = Schema.Struct({
@@ -44,14 +46,14 @@ const Answer = Schema.Union([NoulAnswer, Choice, Score]).pipe(Schema.toTaggedUni
 const NativeUsage = Schema.StructWithRest(Schema.Struct({
     input_tokens: Schema.optional(Schema.Number),
     output_tokens: Schema.optional(Schema.Number),
-}), [Schema.Record(Schema.String, Schema.Unknown)]);
+}), [JsonObject]);
 const Response = Schema.Struct({
     model: Schema.String,
     answers: Schema.Record(Schema.String, Answer),
     usage: Schema.optional(NativeUsage),
     id: Schema.optional(Schema.String),
     provider: Schema.optional(Schema.String),
-    provider_metadata: Schema.optional(Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Unknown))),
+    provider_metadata: Schema.optional(ProviderMetadata),
 });
 export const model = (cfg) => EvaluationModel.make({
     id: cfg.id,
@@ -76,7 +78,7 @@ export const model = (cfg) => EvaluationModel.make({
                 headers: Headers.fromInput({ ...cfg.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 http = RequestExecutor.responseHttp(res);
             const fail = (message, cause, body) => new AIError({ reason: new InvalidProviderOutputError({ route: "system-one", message, body, http, cause }) });
             const text = yield* res.text.pipe(Effect.mapError((cause) => fail("Failed to read the System One response", cause)));
             const data = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Response))(text).pipe(Effect.mapError((cause) => fail("System One returned an invalid response", cause, text)));
@@ -120,9 +122,7 @@ export const model = (cfg) => EvaluationModel.make({
                     ? new Usage({
                         inputTokens: data.usage.input_tokens,
                         outputTokens: data.usage.output_tokens,
-                        totalTokens: data.usage.input_tokens === undefined && data.usage.output_tokens === undefined
-                            ? undefined
-                            : (data.usage.input_tokens ?? 0) + (data.usage.output_tokens ?? 0),
+                        totalTokens: ProviderShared.totalTokens(data.usage.input_tokens, data.usage.output_tokens, undefined),
                         providerMetadata: { [cfg.providerMetadataKey]: data.usage },
                     })
                     : undefined,

package/dist/experimental.d.ts

@@ -2,4 +2,4 @@ export { EvaluationClient } from "./experimental/evaluation-client.js";
 export { BooleanAnswer, BooleanQuestion, ChoiceAnswer, ChoiceQuestion, Evaluation, EvaluationAnswer, EvaluationInput, EvaluationModel, EvaluationModelSchema, EvaluationQuestion, EvaluationRequest, EvaluationResponse, EvaluationRounding, ScoreAnswer, ScoreQuestion, } from "./experimental/evaluation.js";
 export type { AnswerFor, AnswersFor, EvaluationModelOptions, EvaluationOptions, EvaluationQuestions, EvaluationRequestFor, EvaluationRequestInput, EvaluationResponseFor, EvaluationRoute, } from "./experimental/evaluation.js";
 export { Realtime } from "./experimental/realtime.js";
-export type { RealtimeConnectInput, RealtimeSession, RealtimeTransport, RealtimeTransportInput, } from "./experimental/realtime.js";
+export type { RealtimeConnectInput, RealtimeSession, RealtimeTransport, RealtimeTransportInput, RealtimeTransportType, } from "./experimental/realtime.js";

package/dist/generation.js

@@ -110,6 +110,6 @@ const within = (effect, id, timeout, deadline) => Clock.currentTimeMillis.pipe(E
 const timeoutError = (id, timeout) => new AIError({
     reason: new TimeoutError({
         message: `Generation ${id} did not finish within ${Duration.format(timeout)}`,
-        timeoutMs: Duration.toMillis(timeout),
+        timeoutMs: Math.min(Number.MAX_SAFE_INTEGER, Math.max(0, Math.ceil(Duration.toMillis(timeout)))),
     }),
 });

package/dist/image-client.d.ts

@@ -57,7 +57,9 @@ export declare const ImageClient: {
         } | undefined;
     } | import("./generation.js").Observation, import("./index.js").AIError, ImageClientService>;
     readonly start: (request: ImageRequestFor) => import("effect/Effect").Effect<import("./generation.js").Generation<ImageResponse>, import("./index.js").AIError, ImageClientService>;
-    readonly resume: (model: import("./image.js").ImageModel<import("./media-model.js").MediaModel.Options>, token: unknown) => import("effect/Effect").Effect<import("./generation.js").Generation<ImageResponse>, import("./index.js").AIError, ImageClientService>;
+    readonly resume: (model: import("./image.js").ImageModel<{
+        readonly [x: string]: unknown;
+    }>, token: unknown) => import("effect/Effect").Effect<import("./generation.js").Generation<ImageResponse>, import("./index.js").AIError, ImageClientService>;
     readonly Service: typeof ImageClientService;
 };
 export {};

package/dist/image.d.ts

@@ -14,14 +14,22 @@ export declare class ImageModel<Options extends ImageOptions = ImageOptions> ext
     static fromRoute<Options extends ImageOptions, Frame, State>(route: MediaModel.StreamRouteInput<ImageRequestFor<Options>, ImageEvent, Frame, State>, input: MediaRoute.ModelInput): ImageModel<Options>;
     static fromRoute<Options extends ImageOptions, Token>(route: MediaModel.QueuedRouteInput<ImageRequestFor<Options>, ImageResponse, Token>, input: MediaRoute.ModelInput): ImageModel<Options>;
 }
-export declare const ImageModelSchema: Schema.declare<ImageModel<MediaModel.Options>, ImageModel<MediaModel.Options>>;
+export declare const ImageModelSchema: Schema.declare<ImageModel<{
+    readonly [x: string]: unknown;
+}>, ImageModel<{
+    readonly [x: string]: unknown;
+}>>;
 export type ImageSize = `${number}x${number}`;
 export declare const ImageSize: Schema.declare<`${number}x${number}`, `${number}x${number}`>;
 export type ImageAspectRatio = Media.AspectRatio;
 export declare const ImageAspectRatio: Schema.declare<`${number}:${number}`, `${number}:${number}`>;
 export type ImageFormat = OpenString<"png" | "jpeg" | "webp">;
 declare const ImageRequest_base: Schema.Class<ImageRequest, Schema.Struct<{
-    readonly model: Schema.declare<ImageModel<MediaModel.Options>, ImageModel<MediaModel.Options>>;
+    readonly model: Schema.declare<ImageModel<{
+        readonly [x: string]: unknown;
+    }>, ImageModel<{
+        readonly [x: string]: unknown;
+    }>>;
     readonly prompt: Schema.String;
     /** Edit sources or style/subject references, in order. */
     readonly images: Schema.optional<Schema.$Array<Schema.decodeTo<Schema.declare<Media.Asset, Media.Asset>, Schema.Struct<{

package/dist/image.js

@@ -3,7 +3,7 @@ import { Generation, ProgressEvent, QueuedEvent } from "./generation.js";
 import { Media } from "./media.js";
 import { MediaModel, composeRoute, tryRequest } from "./media-model.js";
 import { MediaRoute } from "./route/media.js";
-import { AIError, HttpOptions, MediaUsage, ProviderMetadata } from "./schema/index.js";
+import { AIError, HttpOptions, MediaUsage, ProviderMetadata, ProviderOptions, } from "./schema/index.js";
 import { ImageClient, Service } from "./image-client.js";
 export class ImageModel extends MediaModel {
     static fromRoute(route, input) {
@@ -32,7 +32,7 @@ export class ImageRequest extends Schema.Class("Image.Request")({
     aspectRatio: Schema.optional(ImageAspectRatio),
     seed: Schema.optional(Schema.Number),
     format: Schema.optional(Schema.String),
-    providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    providerOptions: Schema.optional(ProviderOptions),
     http: Schema.optional(HttpOptions),
 }) {
 }

package/dist/llm.d.ts

@@ -14,10 +14,8 @@ export type RequestInput<SelectedLanguageModel extends LanguageModel = LanguageM
     readonly providerOptions?: NoInfer<LanguageModelProviderOptions<SelectedLanguageModel>>;
     readonly http?: HttpOptions.Input;
 };
-export declare function generate<const Model extends LanguageModel>(input: RequestInput<Model>, options?: StreamOptions): Effect.Effect<LLMResponse, AIError, Service>;
-export declare function generate(input: LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError, Service>;
-export declare function stream<const Model extends LanguageModel>(input: RequestInput<Model>, options?: StreamOptions): Stream.Stream<LLMEvent, AIError, Service>;
-export declare function stream(input: LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, AIError, Service>;
+export declare function generate<const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: StreamOptions): Effect.Effect<LLMResponse, AIError, Service>;
+export declare function stream<const Model extends LanguageModel>(input: RequestInput<Model> | LLMRequest, options?: StreamOptions): Stream.Stream<LLMEvent, AIError, Service>;
 export declare const request: <const SelectedLanguageModel extends LanguageModel>(input: RequestInput<SelectedLanguageModel>) => LLMRequest<SelectedLanguageModel>;
 type GenerateObjectBase<SelectedLanguageModel extends LanguageModel = LanguageModel> = Omit<RequestInput<SelectedLanguageModel>, "tools" | "toolChoice">;
 export declare class GenerateObjectResponse<T> {

package/dist/llm.js

@@ -46,8 +46,8 @@ const runGenerateObject = Effect.fn("LLM.generateObject")(function* (options, to
         toolChoice: ToolChoice.named(GENERATE_OBJECT_TOOL_NAME),
     });
     const response = yield* LLMClient.generate(generateRequest);
-    const call = response.toolCalls.find((event) => LLMEvent.is.toolCall(event) && event.name === GENERATE_OBJECT_TOOL_NAME);
-    if (!call || !LLMEvent.is.toolCall(call))
+    const call = response.toolCalls.find((event) => event.name === GENERATE_OBJECT_TOOL_NAME);
+    if (!call)
         return yield* new AIError({
             reason: new InvalidProviderOutputError({
                 message: `generateObject: model did not call the forced \`${GENERATE_OBJECT_TOOL_NAME}\` tool`,

package/dist/media-model.d.ts

@@ -2,7 +2,7 @@ import { Effect } from "effect";
 import { Endpoint } from "./route/endpoint.js";
 import { MediaRoute } from "./route/media.js";
 import type { MediaProtocol } from "./route/media-protocol.js";
-import { AIError, HttpOptions, ModelID, ProviderID } from "./schema/index.js";
+import { AIError, HttpOptions, ModelID, ProviderID, type ProviderOptions } from "./schema/index.js";
 /**
  * What every media model carries: ids, the configured route, and deployment `http` overlays. Modality classes
  * (`ImageModel`, `VideoModel`, `SpeechModel`, `TranscriptionModel`) extend it with their route type and a nominal
@@ -17,7 +17,7 @@ export declare class MediaModel<Route, Options> {
     constructor(input: MediaModel.Input<Route>);
 }
 export declare namespace MediaModel {
-    type Options = Record<string, unknown>;
+    type Options = ProviderOptions;
     interface Input<Route> {
         readonly id: string | ModelID;
         readonly provider: string | ProviderID;

package/dist/media-model.js

@@ -1,7 +1,7 @@
 import { Effect } from "effect";
 import { Endpoint } from "./route/endpoint.js";
 import { MediaRoute } from "./route/media.js";
-import { AIError, HttpOptions, InvalidRequestError, ModelID, ProviderID } from "./schema/index.js";
+import { AIError, HttpOptions, InvalidRequestError, ModelID, ProviderID, } from "./schema/index.js";
 /**
  * What every media model carries: ids, the configured route, and deployment `http` overlays. Modality classes
  * (`ImageModel`, `VideoModel`, `SpeechModel`, `TranscriptionModel`) extend it with their route type and a nominal

package/dist/media.js

@@ -3,9 +3,9 @@ import { Effect, FileSystem, Schema, SchemaGetter } from "effect";
 import { Base64 } from "effect/encoding";
 import { HttpClientRequest } from "effect/http";
 import { ProviderID } from "./schema/ids.js";
-import { AIError, HttpContext, InvalidProviderOutputError, InvalidRequestError } from "./schema/errors.js";
+import { AIError, InvalidProviderOutputError, InvalidRequestError } from "./schema/errors.js";
 import { ProviderMetadata } from "./schema/options.js";
-import { Service } from "./route/executor-service.js";
+import { responseHttp, Service } from "./route/executor-service.js";
 import { detectMediaType, fileMediaType } from "./utils/media-type.js";
 export { detectMediaType } from "./utils/media-type.js";
 const OCTET_STREAM = "application/octet-stream";
@@ -183,7 +183,7 @@ const download = Effect.fn("Media.download")(function* (source, headers) {
     const buffer = yield* response.arrayBuffer.pipe(Effect.mapError((cause) => new AIError({
         reason: new InvalidProviderOutputError({
             message: `Failed to read media from ${source.url}`,
-            http: new HttpContext({ url: response.request.url, status: response.status, headers: response.headers }),
+            http: responseHttp(response),
             cause,
         }),
     })));

package/dist/promise.d.ts

@@ -5,7 +5,7 @@ import { type ImageModel, type ImageRequest, type ImageRequestInput } from "./im
 import { LLM } from "./index.js";
 import { Media } from "./media.js";
 import { RequestExecutor } from "./route/executor.js";
-import { LanguageModel, LLMRequest } from "./schema/index.js";
+import { LanguageModel, type LLMRequest } from "./schema/index.js";
 import type { RequestInput } from "./llm.js";
 import { type SpeechModel, type SpeechRequest, type SpeechRequestInput } from "./speech.js";
 import { type TranscriptionModel, type TranscriptionRequest, type TranscriptionRequestInput } from "./transcription.js";

package/dist/promise.js

@@ -3,9 +3,8 @@ import { AIClient } from "./ai-client.js";
 import { Image } from "./image.js";
 import { LLM } from "./index.js";
 import { Media } from "./media.js";
-import { tryRequest } from "./media-model.js";
 import { RequestExecutor } from "./route/executor.js";
-import { AIError, InvalidRequestError, LanguageModel, LLMRequest } from "./schema/index.js";
+import { AIError, InvalidRequestError, LanguageModel } from "./schema/index.js";
 import { Speech } from "./speech.js";
 import { Transcription, } from "./transcription.js";
 import { fileMediaType } from "./utils/media-type.js";
@@ -36,7 +35,6 @@ export const make = (options = {}) => {
         refresh: (options) => run(generation.refresh(), options).then(handle),
         cancel: (options) => run(generation.cancel(), options),
     });
-    const llmRequest = (input) => input instanceof LLMRequest ? Effect.succeed(input) : tryRequest(() => LLM.request(input));
     return {
         run,
         /** Decoded asset bytes, downloading `url` sources through the executor. */
@@ -65,8 +63,8 @@ export const make = (options = {}) => {
         },
         llm: {
             request: LLM.request,
-            generate: (input, options) => run(Effect.flatMap(llmRequest(input), LLM.generate), options),
-            stream: (input, options) => iterate(Stream.unwrap(Effect.map(llmRequest(input), LLM.stream)), options),
+            generate: (input, options) => run(LLM.generate(input), options),
+            stream: (input, options) => iterate(LLM.stream(input), options),
         },
         image: {
             request: Image.request,

package/dist/protocols/alibaba-chat.d.ts

@@ -10,19 +10,19 @@ declare const Options: Schema.Struct<{
     readonly preserveThinking: Schema.optional<Schema.Boolean>;
     readonly clearThinking: Schema.optional<Schema.Boolean>;
     readonly thinking: Schema.optional<Schema.Struct<{
-        readonly type: Schema.declare<"adaptive" | "disabled" | (string & {}), "adaptive" | "disabled" | (string & {})>;
+        readonly type: Schema.declare<import("../schema/options.js").OpenString<"adaptive" | "disabled">, import("../schema/options.js").OpenString<"adaptive" | "disabled">>;
     }>>;
     readonly toolStream: Schema.optional<Schema.Boolean>;
     readonly parallelToolCalls: Schema.optional<Schema.Boolean>;
     readonly repetitionPenalty: Schema.optional<Schema.Number>;
     readonly responseFormat: Schema.optional<Schema.Struct<{
-        readonly type: Schema.declare<"json_object" | "json_schema" | "text" | (string & {}), "json_object" | "json_schema" | "text" | (string & {})>;
+        readonly type: Schema.declare<import("../schema/options.js").OpenString<"json_object" | "json_schema" | "text">, import("../schema/options.js").OpenString<"json_object" | "json_schema" | "text">>;
         readonly json_schema: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
     }>>;
     readonly enableSearch: Schema.optional<Schema.Boolean>;
     readonly searchOptions: Schema.optional<Schema.Struct<{
         readonly forced_search: Schema.optional<Schema.Boolean>;
-        readonly search_strategy: Schema.optional<Schema.declare<"agent" | "agent_max" | "max" | "turbo" | (string & {}), "agent" | "agent_max" | "max" | "turbo" | (string & {})>>;
+        readonly search_strategy: Schema.optional<Schema.declare<import("../schema/options.js").OpenString<"agent" | "agent_max" | "max" | "turbo">, import("../schema/options.js").OpenString<"agent" | "agent_max" | "max" | "turbo">>>;
         readonly enable_search_extension: Schema.optional<Schema.Boolean>;
     }>>;
 }>;
@@ -159,13 +159,13 @@ export declare const protocol: Protocol<{
     readonly preserve_thinking?: boolean | undefined;
     readonly clear_thinking?: boolean | undefined;
     readonly thinking?: {
-        readonly type: "adaptive" | "disabled" | (string & {});
+        readonly type: import("../schema/options.js").OpenString<"adaptive" | "disabled">;
     } | undefined;
     readonly parallel_tool_calls?: boolean | undefined;
     readonly repetition_penalty?: number | undefined;
     readonly top_k?: number | undefined;
     readonly response_format?: {
-        readonly type: "json_object" | "json_schema" | "text" | (string & {});
+        readonly type: import("../schema/options.js").OpenString<"json_object" | "json_schema" | "text">;
         readonly json_schema?: {
             readonly [x: string]: unknown;
         } | undefined;
@@ -173,7 +173,7 @@ export declare const protocol: Protocol<{
     readonly enable_search?: boolean | undefined;
     readonly search_options?: {
         readonly forced_search?: boolean | undefined;
-        readonly search_strategy?: "agent" | "agent_max" | "max" | "turbo" | (string & {}) | undefined;
+        readonly search_strategy?: import("../schema/options.js").OpenString<"agent" | "agent_max" | "max" | "turbo"> | undefined;
         readonly enable_search_extension?: boolean | undefined;
     } | undefined;
 }, string, "[DONE]" | {

package/dist/protocols/alibaba-chat.js

@@ -11,19 +11,19 @@ const Options = Schema.Struct({
     preserveThinking: Schema.optional(Schema.Boolean),
     clearThinking: Schema.optional(Schema.Boolean),
     thinking: Schema.optional(Schema.Struct({
-        type: Schema.declare(Schema.is(Schema.String)),
+        type: ProviderShared.knownString(),
     })),
     toolStream: Schema.optional(Schema.Boolean),
     parallelToolCalls: Schema.optional(Schema.Boolean),
     repetitionPenalty: Schema.optional(Schema.Number),
     responseFormat: Schema.optional(Schema.Struct({
-        type: Schema.declare(Schema.is(Schema.String)),
+        type: ProviderShared.knownString(),
         json_schema: Schema.optional(JsonObject),
     })),
     enableSearch: Schema.optional(Schema.Boolean),
     searchOptions: Schema.optional(Schema.Struct({
         forced_search: Schema.optional(Schema.Boolean),
-        search_strategy: Schema.optional(Schema.declare(Schema.is(Schema.String))),
+        search_strategy: Schema.optional(ProviderShared.knownString()),
         enable_search_extension: Schema.optional(Schema.Boolean),
     })),
 });