@opencode/ai 2.0.32 → 2.1.0

package/dist/ai-client.d.ts

@@ -1,8 +1,8 @@
 import { Layer } from "effect";
 import { RequestExecutor } from "./route/executor.js";
 /** Every modality client over `executor`, which stays in the output so `asset.bytes()` and `Media.write` resolve. */
-export declare const layerWith: <E, R>(executor: Layer.Layer<RequestExecutor.Service, E, R>) => Layer.Layer<import("./route/executor-service.js").RequestExecutorService | import("./route/client.js").LLMClientService | import("./image-client.js").ImageClientService | import("./speech-client.js").SpeechClientService | import("./transcription-client.js").TranscriptionClientService | import("./video-client.js").VideoClientService, E, R>;
+export declare const layerWith: <E, R>(executor: Layer.Layer<RequestExecutor.Service, E, R>) => Layer.Layer<import("./image-client.js").ImageClientService | import("./route/client.js").LLMClientService | import("./route/executor-service.js").RequestExecutorService | import("./speech-client.js").SpeechClientService | import("./transcription-client.js").TranscriptionClientService | import("./video-client.js").VideoClientService, E, R>;
 /** Every modality client plus the executor over `RequestExecutor.fetchLayer`: the one layer most programs need. */
-export declare const layer: Layer.Layer<import("./route/executor-service.js").RequestExecutorService | import("./route/client.js").LLMClientService | import("./image-client.js").ImageClientService | import("./speech-client.js").SpeechClientService | import("./transcription-client.js").TranscriptionClientService | import("./video-client.js").VideoClientService, never, never>;
+export declare const layer: Layer.Layer<import("./image-client.js").ImageClientService | import("./route/client.js").LLMClientService | import("./route/executor-service.js").RequestExecutorService | import("./speech-client.js").SpeechClientService | import("./transcription-client.js").TranscriptionClientService | import("./video-client.js").VideoClientService, never, never>;
 export type Services = Layer.Success<typeof layer>;
 export * as AIClient from "./ai-client.js";

package/dist/experimental/evaluation-client.d.ts

@@ -16,6 +16,6 @@ export declare const EvaluationClient: {
     readonly Service: typeof Service;
     readonly layer: Layer.Layer<Service, never, import("../route/executor-service.js").RequestExecutorService>;
     readonly fetchLayer: Layer.Layer<import("../route/executor-service.js").RequestExecutorService | Service, never, never>;
-    readonly evaluate: <Options extends EvaluationOptions, const Questions extends EvaluationQuestions>(request: EvaluationRequestFor<Options, Questions>) => Effect.Effect<EvaluationResponseFor<Questions>, AIError, Service>;
+    readonly evaluate: typeof evaluate;
 };
 export {};

package/dist/experimental/evaluation.d.ts

@@ -7,9 +7,9 @@ export declare const ChoiceQuestion: Schema.Struct<{
     readonly type: Schema.Literal<"choice">;
     readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
     readonly criteria: Schema.refine<{
-        readonly [x: string]: string | {
+        readonly [x: string]: string | readonly Schema.Json[] | {
             readonly [x: string]: Schema.Json;
-        } | readonly Schema.Json[] | null;
+        } | null;
     }, Schema.$Record<Schema.String, Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>>;
 }>;
 export type ChoiceQuestion = Schema.Schema.Type<typeof ChoiceQuestion>;
@@ -32,9 +32,9 @@ export declare const EvaluationQuestion: Schema.toTaggedUnion<"type", readonly [
     readonly type: Schema.Literal<"choice">;
     readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
     readonly criteria: Schema.refine<{
-        readonly [x: string]: string | {
+        readonly [x: string]: string | readonly Schema.Json[] | {
             readonly [x: string]: Schema.Json;
-        } | readonly Schema.Json[] | null;
+        } | null;
     }, Schema.$Record<Schema.String, Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>>;
 }>, Schema.Struct<{
     readonly type: Schema.Literal<"score">;
@@ -131,43 +131,43 @@ declare const EvaluationRequest_base: Schema.Class<EvaluationRequest, Schema.Str
     readonly questions: Schema.refine<{
         readonly [x: string]: {
             readonly type: "choice";
-            readonly instructions: string | {
+            readonly instructions: string | readonly Schema.Json[] | {
                 readonly [x: string]: Schema.Json;
-            } | readonly Schema.Json[];
+            };
             readonly criteria: {
-                readonly [x: string]: string | {
+                readonly [x: string]: string | readonly Schema.Json[] | {
                     readonly [x: string]: Schema.Json;
-                } | readonly Schema.Json[] | null;
+                } | null;
             };
         } | {
             readonly type: "score";
-            readonly instructions: string | {
+            readonly instructions: string | readonly Schema.Json[] | {
                 readonly [x: string]: Schema.Json;
-            } | readonly Schema.Json[];
-            readonly criteria: readonly (string | {
+            };
+            readonly criteria: readonly (string | readonly Schema.Json[] | {
                 readonly [x: string]: Schema.Json;
-            } | readonly Schema.Json[] | null)[];
+            } | null)[];
         } | {
             readonly type: "boolean";
-            readonly instructions: string | {
+            readonly instructions: string | readonly Schema.Json[] | {
                 readonly [x: string]: Schema.Json;
-            } | readonly Schema.Json[];
+            };
             readonly criteria?: {
-                readonly true?: string | {
+                readonly true?: string | readonly Schema.Json[] | {
                     readonly [x: string]: Schema.Json;
-                } | readonly Schema.Json[] | null | undefined;
-                readonly false?: string | {
+                } | null | undefined;
+                readonly false?: string | readonly Schema.Json[] | {
                     readonly [x: string]: Schema.Json;
-                } | readonly Schema.Json[] | null | undefined;
+                } | null | undefined;
             } | undefined;
         };
     }, Schema.$Record<Schema.String, Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
         readonly type: Schema.Literal<"choice">;
         readonly instructions: Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>;
         readonly criteria: Schema.refine<{
-            readonly [x: string]: string | {
+            readonly [x: string]: string | readonly Schema.Json[] | {
                 readonly [x: string]: Schema.Json;
-            } | readonly Schema.Json[] | null;
+            } | null;
         }, Schema.$Record<Schema.String, Schema.NullOr<Schema.Union<readonly [Schema.String, Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>, Schema.$Array<Schema.Codec<Schema.Json, Schema.Json, never, never>>]>>>>;
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"score">;

package/dist/experimental/realtime.d.ts

@@ -1,4 +1,4 @@
-import { Effect, type Redacted } from "effect";
+import { Effect, Redacted } from "effect";
 import { AIError } from "../schema/index.js";
 export type RealtimeTransportInput = {
     readonly type: "webrtc";
@@ -35,21 +35,13 @@ export declare const engine: (model: string) => {
     readonly family: "grok-voice";
     readonly id: "xai-realtime";
     readonly provider: "xai";
+} | {
+    readonly family: "gemini-3.8-live";
+    readonly id: "gemini-live";
+    readonly provider: "google";
 } | undefined;
 export declare const connect: (input: RealtimeConnectInput) => Effect.Effect<RealtimeTransport, AIError, import("../route/executor-service.js").RequestExecutorService>;
 export declare const Realtime: {
-    readonly engine: (model: string) => {
-        readonly family: "gpt-live";
-        readonly id: "openai-live";
-        readonly provider: "openai";
-    } | {
-        readonly family: "gpt-realtime";
-        readonly id: "openai-realtime";
-        readonly provider: "openai";
-    } | {
-        readonly family: "grok-voice";
-        readonly id: "xai-realtime";
-        readonly provider: "xai";
-    } | undefined;
+    readonly engine: typeof engine;
     readonly connect: (input: RealtimeConnectInput) => Effect.Effect<RealtimeTransport, AIError, import("../route/executor-service.js").RequestExecutorService>;
 };

package/dist/experimental/realtime.js

@@ -1,14 +1,16 @@
-import { Effect, Schema } from "effect";
+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 { 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" },
 ];
 // 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}-`));
@@ -39,6 +41,24 @@ export const connect = Effect.fn("Realtime.connect")(function* (input) {
                 return yield* invalidRequest("xAI Grok Voice only supports WebSocket transport");
             return yield* clientSecret(resolved.id, XAI_BASE_URL, input.model, input.apiKey);
         }
+        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, {
+                uses: 1,
+                expireTime: new Date(now + 30 * 60_000).toISOString(),
+                newSessionExpireTime: new Date(expiresAt).toISOString(),
+                bidiGenerateContentSetup: { ...input.session, model: `models/${input.model}` },
+            }, AuthTokenResponse, "x-goog-api-key");
+            return {
+                type: "websocket",
+                url: "wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContentConstrained",
+                token: data.name,
+                expiresAt: Math.floor(expiresAt / 1000),
+            };
+        }
     }
 });
 export const Realtime = {
@@ -55,10 +75,15 @@ const ClientSecretResponse = Schema.fromJsonString(Schema.Struct({
     value: Schema.String,
     expires_at: Schema.Number,
 }));
+const AuthTokenResponse = Schema.fromJsonString(Schema.Struct({
+    name: Schema.String,
+}));
 const invalidRequest = (message) => new AIError({ reason: new InvalidRequestError({ message }) });
-const post = (route, url, apiKey, body, response) => Effect.gen(function* () {
+const post = (route, url, apiKey, body, response, authHeader) => Effect.gen(function* () {
     const executor = yield* RequestExecutor.Service;
-    const res = yield* executor.execute(HttpClientRequest.post(url).pipe(HttpClientRequest.bearerToken(apiKey), body instanceof FormData
+    const res = yield* executor.execute(HttpClientRequest.post(url).pipe(authHeader
+        ? HttpClientRequest.setHeader(authHeader, Redacted.value(apiKey))
+        : 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 });

package/dist/experimental/system-one.d.ts

@@ -12,5 +12,5 @@ export interface ModelInput {
 }
 export declare const model: <Options extends EvaluationOptions = EvaluationOptions>(cfg: ModelInput) => EvaluationModel<Options>;
 export declare const SystemOne: {
-    readonly model: <Options extends EvaluationOptions = EvaluationOptions>(cfg: ModelInput) => EvaluationModel<Options>;
+    readonly model: typeof model;
 };

package/dist/image-client.d.ts

@@ -10,7 +10,7 @@ export type Service = ImageClientService;
 export declare const ImageClient: {
     readonly layer: import("effect/Layer").Layer<ImageClientService, never, import("./route/executor-service.js").RequestExecutorService>;
     readonly generate: (request: ImageRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Effect").Effect<ImageResponse, import("./index.js").AIError, ImageClientService>;
-    readonly stream: (request: ImageRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Stream").Stream<import("./generation.js").Observation | {
+    readonly stream: (request: ImageRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Stream").Stream<{
         readonly type: "image-partial";
         readonly index: number;
         readonly image: import("./media.js").Asset;
@@ -20,11 +20,6 @@ export declare const ImageClient: {
         readonly image: import("./media.js").Asset;
     } | {
         readonly type: "finish";
-        readonly providerMetadata?: {
-            readonly [x: string]: {
-                readonly [x: string]: unknown;
-            };
-        } | undefined;
         readonly usage?: {
             readonly type: "tokens";
             readonly input?: number | undefined;
@@ -47,7 +42,7 @@ export declare const ImageClient: {
             readonly seconds: number;
         } | undefined;
         readonly notices?: readonly {
-            readonly type: "other" | "moderated" | "filtered";
+            readonly type: "filtered" | "moderated" | "other";
             readonly message: string;
             readonly providerMetadata?: {
                 readonly [x: string]: {
@@ -55,7 +50,12 @@ export declare const ImageClient: {
                 };
             } | undefined;
         }[] | undefined;
-    }, import("./index.js").AIError, ImageClientService>;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | 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 Service: typeof ImageClientService;