@opencode/ai 2.0.15 → 2.0.17

package/dist/schema/options.js

@@ -39,8 +39,12 @@ export class HttpOptions extends Schema.Class("AI.HttpOptions")({
 }) {
 }
 (function (HttpOptions) {
-    /** Normalize HTTP option input into the canonical `HttpOptions` class. */
-    HttpOptions.make = (input) => (input instanceof HttpOptions ? input : new HttpOptions(input));
+    function make(input) {
+        if (input === undefined || input instanceof HttpOptions)
+            return input;
+        return new HttpOptions(input);
+    }
+    HttpOptions.make = make;
 })(HttpOptions || (HttpOptions = {}));
 export const mergeHttpOptions = (...items) => {
     const body = mergeJsonRecords(...items.map((item) => item?.body));
@@ -93,16 +97,17 @@ export class LanguageModelDefaults extends Schema.Class("LLM.LanguageModelDefaul
         return new LanguageModelDefaults({
             generation: input.generation === undefined ? undefined : GenerationOptions.make(input.generation),
             providerOptions: input.providerOptions,
-            http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+            http: HttpOptions.make(input.http),
         });
     };
 })(LanguageModelDefaults || (LanguageModelDefaults = {}));
 export const ReasoningEfforts = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
 export const ReasoningEffort = Schema.declare((value) => typeof value === "string", { title: "ReasoningEffort" });
-export const LanguageModelToolSchemaCompatibility = Schema.Literals(["gemini", "moonshot"]);
+/** Tool schema sanitizer for a model family. `none` opts out of the protocol and model-name defaults. */
+export const LanguageModelSanitizerCompatibility = Schema.Literals(["gemini", "moonshot", "none"]);
 export const LanguageModelMaxTokensFieldCompatibility = Schema.Literals(["max_completion_tokens", "max_tokens"]);
 export class LanguageModelCompatibility extends Schema.Class("LLM.LanguageModelCompatibility")({
-    toolSchema: Schema.optional(LanguageModelToolSchemaCompatibility),
+    sanitizer: Schema.optional(LanguageModelSanitizerCompatibility),
     reasoningField: Schema.optional(Schema.String),
     /** Require every assistant message to include its reasoning field, even when empty. */
     requireReasoning: Schema.optional(Schema.Boolean),

package/dist/speech-client.d.ts

@@ -0,0 +1,66 @@
+import { Context } from "effect";
+import { MediaClient } from "./media-client.js";
+import { type SpeechEvent, type SpeechRequestFor, type SpeechResponse } from "./speech.js";
+export type Interface = MediaClient.Interface<SpeechRequestFor, SpeechEvent, SpeechResponse>;
+declare const SpeechClientService_base: Context.ServiceClass<SpeechClientService, "@opencode/SpeechClient", Interface>;
+export declare class SpeechClientService extends SpeechClientService_base {
+}
+export declare const Service: typeof SpeechClientService;
+export type Service = SpeechClientService;
+export declare const SpeechClient: {
+    readonly layer: import("effect/Layer").Layer<SpeechClientService, never, import("./route/executor-service.js").RequestExecutorService>;
+    readonly generate: (request: SpeechRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Effect").Effect<SpeechResponse, import("./index.js").AIError, SpeechClientService>;
+    readonly stream: (request: SpeechRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Stream").Stream<import("./generation.js").Observation | {
+        readonly type: "audio-delta";
+        readonly chunk: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly type: "timestamps";
+        readonly items: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+        }[];
+    } | {
+        readonly type: "finish";
+        readonly audio: import("./media.js").Asset;
+        readonly providerMetadata?: {
+            readonly [x: string]: {
+                readonly [x: string]: unknown;
+            };
+        } | undefined;
+        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;
+        } | {
+            readonly type: "characters";
+            readonly characters: number;
+        } | {
+            readonly type: "credits";
+            readonly credits: number;
+        } | {
+            readonly type: "compute";
+            readonly seconds: number;
+        } | undefined;
+        readonly notices?: readonly {
+            readonly type: "other" | "moderated" | "filtered";
+            readonly message: string;
+            readonly providerMetadata?: {
+                readonly [x: string]: {
+                    readonly [x: string]: unknown;
+                };
+            } | undefined;
+        }[] | undefined;
+    }, import("./index.js").AIError, SpeechClientService>;
+    readonly start: (request: SpeechRequestFor) => import("effect/Effect").Effect<import("./generation.js").Generation<SpeechResponse>, import("./index.js").AIError, SpeechClientService>;
+    readonly resume: (model: import("./speech.js").SpeechModel<import("./media-model.js").MediaModel.Options>, token: unknown) => import("effect/Effect").Effect<import("./generation.js").Generation<SpeechResponse>, import("./index.js").AIError, SpeechClientService>;
+    readonly Service: typeof SpeechClientService;
+};
+export {};

package/dist/speech-client.js

@@ -0,0 +1,21 @@
+import { Context } from "effect";
+import { MediaClient } from "./media-client.js";
+import { SpeechTimestampsEvent, SpeechFinishEvent, } from "./speech.js";
+export class SpeechClientService extends Context.Service()("@opencode/SpeechClient") {
+}
+export const Service = SpeechClientService;
+export const SpeechClient = {
+    Service,
+    ...MediaClient.make(Service, {
+        modality: "speech",
+        responseEvents: (response) => [
+            ...(response.timestamps === undefined ? [] : [SpeechTimestampsEvent.make({ items: response.timestamps })]),
+            SpeechFinishEvent.make({
+                audio: response.audio,
+                usage: response.usage,
+                notices: response.notices,
+                providerMetadata: response.providerMetadata,
+            }),
+        ],
+    }),
+};