@opencode/ai 0.0.0-dev-20039 → 0.0.0-dev-20041

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

@@ -0,0 +1 @@
+export declare const concatBytes: (chunks: ReadonlyArray<Uint8Array>) => Uint8Array<ArrayBufferLike>;

package/dist/utils/bytes.js

@@ -0,0 +1,10 @@
+export const concatBytes = (chunks) => {
+    if (chunks.length === 1)
+        return chunks[0];
+    const bytes = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0));
+    chunks.reduce((offset, chunk) => {
+        bytes.set(chunk, offset);
+        return offset + chunk.length;
+    }, 0);
+    return bytes;
+};

package/dist/utils/media-type.js

@@ -24,10 +24,15 @@ export const detectMediaType = (bytes) => {
         return "video/mp4";
     if (startsWith(bytes, [0x1a, 0x45, 0xdf, 0xa3]))
         return "video/webm";
-    if (startsWith(bytes, [0x49, 0x44, 0x33]) || startsWith(bytes, [0xff, 0xfb]) || startsWith(bytes, [0xff, 0xf3]))
+    if (startsWith(bytes, [0x49, 0x44, 0x33]))
         return "audio/mpeg";
+    // An 11-bit frame sync; layer bits `00` mark AAC ADTS, any other layer is MPEG audio.
+    if (bytes.length >= 2 && bytes[0] === 0xff && (bytes[1] & 0xe0) === 0xe0)
+        return (bytes[1] & 0x06) === 0 ? "audio/aac" : "audio/mpeg";
     if (startsWith(bytes, [0x4f, 0x67, 0x67, 0x53]))
         return "audio/ogg";
+    if (startsWith(bytes, [0x66, 0x4c, 0x61, 0x43]))
+        return "audio/flac";
     return undefined;
 };
 const EXTENSIONS = {
@@ -42,6 +47,8 @@ const EXTENSIONS = {
     mp3: "audio/mpeg",
     wav: "audio/wav",
     ogg: "audio/ogg",
+    flac: "audio/flac",
+    aac: "audio/aac",
     txt: "text/plain",
     md: "text/markdown",
     csv: "text/csv",

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-20039",
+  "version": "0.0.0-dev-20041",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "0.0.0-dev-20039",
+    "@opencode/http-recorder": "0.0.0-dev-20041",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -44,7 +44,7 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "0.0.0-dev-20039",
+    "@opencode/schema": "0.0.0-dev-20041",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"