@opencode/ai 2.0.15 → 2.0.17

package/dist/speech.js

@@ -0,0 +1,124 @@
+import { Effect, Schema, Stream } from "effect";
+import { 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 { SpeechClient, Service } from "./speech-client.js";
+export class SpeechModel extends MediaModel {
+    static fromRoute(route, input) {
+        return new SpeechModel({
+            id: input.id,
+            provider: route.protocol.provider,
+            http: input.http,
+            route: composeRoute(route, input, collectResponse),
+        });
+    }
+}
+export const SpeechModelSchema = Schema.declare((value) => value instanceof SpeechModel, {
+    expected: "Speech.Model",
+});
+// ---------------------------------------------------------------------------
+// Request
+// ---------------------------------------------------------------------------
+/** Provider-native: a name on OpenAI and Gemini, a voice id on ElevenLabs and Cartesia; `{ id }` is an OpenAI custom voice. */
+export const SpeechVoice = Schema.Union([Schema.String, Schema.Struct({ id: Schema.String })]).annotate({
+    identifier: "Speech.Voice",
+});
+/** Granularity is provider-native: characters on ElevenLabs, words on Cartesia. */
+export const SpeechTimestamp = Schema.Struct({
+    text: Schema.String,
+    startSeconds: Schema.Number,
+    endSeconds: Schema.Number,
+}).annotate({ identifier: "Speech.Timestamp" });
+export class SpeechRequest extends Schema.Class("Speech.Request")({
+    model: SpeechModelSchema,
+    text: Schema.String,
+    voice: Schema.optional(SpeechVoice),
+    format: Schema.optional(Schema.String),
+    speed: Schema.optional(Schema.Number),
+    language: Schema.optional(Schema.String),
+    instructions: Schema.optional(Schema.String),
+    timestamps: Schema.optional(Schema.Boolean),
+    providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    http: Schema.optional(HttpOptions),
+}) {
+}
+// ---------------------------------------------------------------------------
+// Response and events
+// ---------------------------------------------------------------------------
+export class SpeechResponse extends Schema.Class("Speech.Response")({
+    /** The complete audio. Headerless PCM carries `info.encoding`, `info.sampleRate`, and `info.channels`. */
+    audio: Media.AssetSchema,
+    timestamps: Schema.optional(Schema.Array(SpeechTimestamp)),
+    usage: Schema.optional(MediaUsage),
+    notices: Schema.optional(Schema.Array(Media.Notice)),
+    providerMetadata: Schema.optional(ProviderMetadata),
+}) {
+}
+export const SpeechAudioDeltaEvent = Schema.Struct({
+    type: Schema.tag("audio-delta"),
+    chunk: Schema.Uint8Array,
+}).annotate({ identifier: "Speech.Event.AudioDelta" });
+export const SpeechTimestampsEvent = Schema.Struct({
+    type: Schema.tag("timestamps"),
+    items: Schema.Array(SpeechTimestamp),
+}).annotate({ identifier: "Speech.Event.Timestamps" });
+/** `audio` is every `audio-delta` chunk concatenated, so the route holds the whole clip in memory until `finish`. */
+export const SpeechFinishEvent = Schema.Struct({
+    type: Schema.tag("finish"),
+    audio: Media.AssetSchema,
+    usage: Schema.optional(MediaUsage),
+    notices: Schema.optional(Schema.Array(Media.Notice)),
+    providerMetadata: Schema.optional(ProviderMetadata),
+}).annotate({ identifier: "Speech.Event.Finish" });
+const speechEventTagged = Schema.Union([
+    QueuedEvent,
+    ProgressEvent,
+    SpeechAudioDeltaEvent,
+    SpeechTimestampsEvent,
+    SpeechFinishEvent,
+]).pipe(Schema.toTaggedUnion("type"));
+export const SpeechEvent = Object.assign(speechEventTagged, {
+    is: {
+        generationQueued: speechEventTagged.guards["generation-queued"],
+        generationProgress: speechEventTagged.guards["generation-progress"],
+        audioDelta: speechEventTagged.guards["audio-delta"],
+        timestamps: speechEventTagged.guards.timestamps,
+        finish: speechEventTagged.guards.finish,
+    },
+});
+const collectResponse = (events) => {
+    const finish = events.find(SpeechEvent.is.finish);
+    // Every speech protocol's `finish` emits the terminal event or fails, so a completed stream always has one.
+    if (finish === undefined)
+        return Effect.die(new Error("The speech stream completed without a finish event"));
+    const timestamps = events.filter(SpeechEvent.is.timestamps).flatMap((event) => event.items);
+    return Effect.succeed(new SpeechResponse({
+        audio: finish.audio,
+        timestamps: timestamps.length === 0 ? undefined : timestamps,
+        usage: finish.usage,
+        notices: finish.notices,
+        providerMetadata: finish.providerMetadata,
+    }));
+};
+export function request(input) {
+    if (input instanceof SpeechRequest)
+        return input;
+    return new SpeechRequest({
+        ...input,
+        http: HttpOptions.make(input.http),
+    });
+}
+const requestEffect = (input) => tryRequest(() => request(input));
+export function generate(input) {
+    return requestEffect(input).pipe(Effect.flatMap((request) => SpeechClient.generate(request)));
+}
+export function stream(input) {
+    return Stream.unwrap(requestEffect(input).pipe(Effect.map((request) => SpeechClient.stream(request))));
+}
+export const Speech = {
+    request,
+    generate,
+    stream,
+};

package/dist/testing.d.ts

@@ -1743,11 +1743,11 @@ export declare const hangAfter: (...events: readonly LLMEvent[]) => Stream.Strea
     } | undefined;
 }, never, never>;
 /** Provides one shared implementation under the normal client and test-control tags. */
-export declare const testLayer: (options?: LayerOptions) => Layer.Layer<import("./route/client.js").Service | Test, never, never>;
+export declare const testLayer: (options?: LayerOptions) => Layer.Layer<import("./route/client.js").LLMClientService | Test, never, never>;
 /** @deprecated Use testLayer; retained for published callers of the legacy control interface. */
 export declare const layer: (options?: LayerOptions) => Layer.Layer<Service, never, never>;
 /** @deprecated testLayer provides LLMClient.Service directly. */
-export declare const clientLayer: Layer.Layer<import("./route/client.js").Service, never, Service>;
+export declare const clientLayer: Layer.Layer<import("./route/client.js").LLMClientService, never, Service>;
 export declare const push: (...responses: readonly Response[]) => Effect.Effect<void, never, Service>;
 export declare const always: (response: Response) => Effect.Effect<void, never, Service>;
 export declare const wait: (count: number) => Effect.Effect<void, never, Service>;

package/dist/transcription-client.d.ts

@@ -0,0 +1,82 @@
+import { Context } from "effect";
+import { MediaClient } from "./media-client.js";
+import { type TranscriptionEvent, type TranscriptionRequestFor, type TranscriptionResponse } from "./transcription.js";
+export type Interface = MediaClient.Interface<TranscriptionRequestFor, TranscriptionEvent, TranscriptionResponse>;
+declare const TranscriptionClientService_base: Context.ServiceClass<TranscriptionClientService, "@opencode/TranscriptionClient", Interface>;
+export declare class TranscriptionClientService extends TranscriptionClientService_base {
+}
+export declare const Service: typeof TranscriptionClientService;
+export type Service = TranscriptionClientService;
+export declare const TranscriptionClient: {
+    readonly layer: import("effect/Layer").Layer<TranscriptionClientService, never, import("./route/executor-service.js").RequestExecutorService>;
+    readonly generate: (request: TranscriptionRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Effect").Effect<TranscriptionResponse, import("./index.js").AIError, TranscriptionClientService>;
+    readonly stream: (request: TranscriptionRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Stream").Stream<import("./generation.js").Observation | {
+        readonly type: "text-delta";
+        readonly delta: string;
+    } | {
+        readonly type: "segment";
+        readonly segment: {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+            readonly speaker?: string | undefined;
+        };
+    } | {
+        readonly type: "finish";
+        readonly text: string;
+        readonly durationSeconds?: number | undefined;
+        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;
+        readonly language?: string | undefined;
+        readonly segments?: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+            readonly speaker?: string | undefined;
+        }[] | undefined;
+        readonly words?: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+            readonly speaker?: string | undefined;
+            readonly confidence?: number | undefined;
+        }[] | undefined;
+    }, import("./index.js").AIError, TranscriptionClientService>;
+    readonly start: (request: TranscriptionRequestFor) => import("effect/Effect").Effect<import("./generation.js").Generation<TranscriptionResponse>, import("./index.js").AIError, TranscriptionClientService>;
+    readonly resume: (model: import("./transcription.js").TranscriptionModel<import("./media-model.js").MediaModel.Options>, token: unknown) => import("effect/Effect").Effect<import("./generation.js").Generation<TranscriptionResponse>, import("./index.js").AIError, TranscriptionClientService>;
+    readonly Service: typeof TranscriptionClientService;
+};
+export {};

package/dist/transcription-client.js

@@ -0,0 +1,13 @@
+import { Context } from "effect";
+import { MediaClient } from "./media-client.js";
+import { TranscriptionFinishEvent, } from "./transcription.js";
+export class TranscriptionClientService extends Context.Service()("@opencode/TranscriptionClient") {
+}
+export const Service = TranscriptionClientService;
+export const TranscriptionClient = {
+    Service,
+    ...MediaClient.make(Service, {
+        modality: "transcription",
+        responseEvents: (response) => [TranscriptionFinishEvent.make({ ...response })],
+    }),
+};