@opencode/ai 2.1.2 → 2.1.4

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

@@ -1,5 +1,6 @@
 import { Effect, Schema } from "effect";
-import { AIError, HttpOptions, InvalidRequestError, ModelID, ProviderID, ProviderMetadata, Usage, } from "../schema/index.js";
+import { tryRequest } from "../media-model.js";
+import { AIError, HttpOptions, ModelID, ProviderID, ProviderMetadata, Usage, } from "../schema/index.js";
 import { EvaluationClient, Service } from "./evaluation-client.js";
 export const EvaluationInput = Schema.Union([Schema.String, Schema.JsonObject, Schema.Array(Schema.Json)]);
 const EvaluationCriterion = Schema.NullOr(EvaluationInput);
@@ -95,20 +96,11 @@ 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)),
-        catch: (cause) => new AIError({
-            reason: new InvalidRequestError({
-                message: cause instanceof Error ? cause.message : String(cause),
-                cause,
-            }),
-        }),
-    }).pipe(Effect.flatMap((request) => EvaluationClient.evaluate(request)));
+    return tryRequest(() => request(input)).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

@@ -6,11 +6,23 @@ 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,11 +30,11 @@ 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 };
         }
@@ -39,16 +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");
+        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, {
@@ -67,6 +74,7 @@ export const connect = Effect.fn("Realtime.connect")(function* (input) {
     }
 });
 export const Realtime = {
+    engines,
     engine,
     connect,
 };

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

@@ -21,14 +21,6 @@ export declare const ImageClient: {
     } | {
         readonly type: "finish";
         readonly usage?: {
-            readonly type: "tokens";
-            readonly input?: number | undefined;
-            readonly output?: number | undefined;
-            readonly total?: number | undefined;
-            readonly details?: {
-                readonly [x: string]: unknown;
-            } | undefined;
-        } | {
             readonly type: "seconds";
             readonly seconds: number;
         } | {
@@ -40,6 +32,14 @@ export declare const ImageClient: {
         } | {
             readonly type: "compute";
             readonly seconds: number;
+        } | {
+            readonly type: "tokens";
+            readonly input?: number | undefined;
+            readonly output?: number | undefined;
+            readonly total?: number | undefined;
+            readonly details?: {
+                readonly [x: string]: unknown;
+            } | undefined;
         } | undefined;
         readonly notices?: readonly {
             readonly type: "filtered" | "moderated" | "other";
@@ -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 {};