@opencode/ai 2.0.15 → 2.0.16

package/dist/speech.js

@@ -0,0 +1,119 @@
+import { Effect, Schema, Stream } from "effect";
+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 make(input) {
+        return new SpeechModel(input);
+    }
+    /** Compose a streaming speech protocol with its canonical path into a model for one deployment. */
+    static fromRoute(route, input) {
+        return new SpeechModel({
+            id: input.id,
+            provider: route.provider,
+            http: input.http,
+            route: composeRoute((composition) => MediaRoute.stream({ ...composition, collect: collectResponse }), route, input),
+        });
+    }
+}
+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([SpeechAudioDeltaEvent, SpeechTimestampsEvent, SpeechFinishEvent]).pipe(Schema.toTaggedUnion("type"));
+export const SpeechEvent = Object.assign(speechEventTagged, {
+    is: {
+        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: input.http === undefined ? undefined : 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/transcription-client.d.ts

@@ -0,0 +1,28 @@
+import { Context, Effect, Layer, Stream } from "effect";
+import type { AwaitOptions, Generation } from "./generation.js";
+import { RequestExecutor } from "./route/executor.js";
+import type { AIError } from "./schema/index.js";
+import { type TranscriptionEvent, type TranscriptionModel, type TranscriptionOptions, type TranscriptionRequestFor, type TranscriptionResponse } from "./transcription.js";
+export interface Interface {
+    readonly generate: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<TranscriptionResponse, AIError>;
+    readonly stream: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<TranscriptionEvent, AIError>;
+    readonly start: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>) => Effect.Effect<Generation<TranscriptionResponse>, AIError>;
+    readonly resume: <Options extends TranscriptionOptions>(model: TranscriptionModel<Options>, token: unknown) => Effect.Effect<Generation<TranscriptionResponse>, AIError>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/TranscriptionClient", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const generate: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<TranscriptionResponse, AIError, Service>;
+export declare const stream: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<TranscriptionEvent, AIError, Service>;
+export declare const start: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>) => Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;
+export declare const resume: <Options extends TranscriptionOptions>(model: TranscriptionModel<Options>, token: unknown) => Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;
+export declare const layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+export declare const TranscriptionClient: {
+    readonly Service: typeof Service;
+    readonly layer: Layer.Layer<Service, never, RequestExecutor.Service>;
+    readonly generate: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>, options?: AwaitOptions) => Effect.Effect<TranscriptionResponse, AIError, Service>;
+    readonly stream: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>, options?: AwaitOptions) => Stream.Stream<TranscriptionEvent, AIError, Service>;
+    readonly start: <Options extends TranscriptionOptions>(request: TranscriptionRequestFor<Options>) => Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;
+    readonly resume: <Options extends TranscriptionOptions>(model: TranscriptionModel<Options>, token: unknown) => Effect.Effect<Generation<TranscriptionResponse>, AIError, Service>;
+};
+export {};

package/dist/transcription-client.js

@@ -0,0 +1,44 @@
+import { Context, Effect, Layer, Stream } from "effect";
+import { RequestExecutor } from "./route/executor.js";
+import { MediaRoute } from "./route/media.js";
+import { responseEvents, } from "./transcription.js";
+export class Service extends Context.Service()("@opencode/TranscriptionClient") {
+}
+export const generate = (request, options) => Effect.gen(function* () {
+    const client = yield* Service;
+    return yield* client.generate(request, options);
+});
+export const stream = (request, options) => Stream.unwrap(Effect.gen(function* () {
+    const client = yield* Service;
+    return client.stream(request, options);
+}));
+export const start = (request) => Effect.gen(function* () {
+    const client = yield* Service;
+    return yield* client.start(request);
+});
+export const resume = (model, token) => Effect.gen(function* () {
+    const client = yield* Service;
+    return yield* client.resume(model, token);
+});
+export const layer = Layer.effect(Service, Effect.gen(function* () {
+    const executor = yield* RequestExecutor.Service;
+    const dispatch = MediaRoute.dispatch({
+        modality: "transcription",
+        execute: executor.execute,
+        responseEvents,
+    });
+    return Service.of({
+        start: (request) => dispatch.start(request.model.route, request),
+        resume: (model, token) => dispatch.resume(model.route, model, token),
+        generate: (request, options) => dispatch.generate(request.model.route, request, options),
+        stream: (request, options) => dispatch.stream(request.model.route, request, options),
+    });
+}));
+export const TranscriptionClient = {
+    Service,
+    layer,
+    generate,
+    stream,
+    start,
+    resume,
+};