@opencode/ai 2.0.31 → 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

@@ -0,0 +1,47 @@
+import { Effect, Redacted } from "effect";
+import { AIError } from "../schema/index.js";
+export type RealtimeTransportInput = {
+    readonly type: "webrtc";
+    readonly sdp: string;
+    readonly dcid?: number;
+} | {
+    readonly type: "websocket";
+};
+export type RealtimeTransport = {
+    readonly type: "webrtc";
+    readonly sdp: string;
+} | {
+    readonly type: "websocket";
+    readonly url: string;
+    readonly token: string;
+    readonly expiresAt: number;
+};
+export type RealtimeSession = Readonly<Record<string, unknown>>;
+export interface RealtimeConnectInput {
+    readonly model: string;
+    readonly apiKey: Redacted.Redacted;
+    readonly session?: RealtimeSession;
+    readonly transport: RealtimeTransportInput;
+}
+export declare const 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";
+} | {
+    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: typeof engine;
+    readonly connect: (input: RealtimeConnectInput) => Effect.Effect<RealtimeTransport, AIError, import("../route/executor-service.js").RequestExecutorService>;
+};

package/dist/experimental/realtime.js

@@ -0,0 +1,99 @@
+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}-`));
+export const connect = Effect.fn("Realtime.connect")(function* (input) {
+    const resolved = engine(input.model);
+    if (!resolved)
+        return yield* invalidRequest(`Unsupported voice model: ${input.model}`);
+    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);
+            const form = new FormData();
+            form.append("sdp", input.transport.sdp);
+            form.append("session", encodeJson(session));
+            const query = input.transport.dcid === undefined ? "" : `?dcid=${input.transport.dcid}`;
+            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 "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 = {
+    engine,
+    connect,
+};
+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
+// it mirrors OpenAI's `{ value, expires_at }` response shape.
+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, authHeader) => Effect.gen(function* () {
+    const executor = yield* RequestExecutor.Service;
+    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 });
+    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) => ({
+    type: "websocket",
+    url: `${baseURL.replace(/^http/, "ws")}/realtime?model=${encodeURIComponent(model)}`,
+    token: data.value,
+    expiresAt: data.expires_at,
+})));

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/experimental.d.ts

@@ -1,3 +1,5 @@
 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";

package/dist/experimental.js

@@ -1,2 +1,3 @@
 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 { Realtime } from "./experimental/realtime.js";

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;