@opencode/ai 2.0.15 → 2.0.16

package/dist/transcription.js

@@ -0,0 +1,133 @@
+import { Effect, Schema, Stream } from "effect";
+import { Generation, ProgressEvent, QueuedEvent } from "./generation.js";
+import { Media } from "./media.js";
+import { MediaModel, composeAnyRoute, tryRequest } from "./media-model.js";
+import { MediaRoute } from "./route/media.js";
+import { AIError, HttpOptions, MediaUsage, ProviderMetadata } from "./schema/index.js";
+import { TranscriptionClient, Service } from "./transcription-client.js";
+export class TranscriptionModel extends MediaModel {
+    static make(input) {
+        return new TranscriptionModel(input);
+    }
+    static fromRoute(route, input) {
+        return new TranscriptionModel({
+            id: input.id,
+            provider: route.provider,
+            http: input.http,
+            route: composeAnyRoute(route, input, collectResponse),
+        });
+    }
+}
+export const TranscriptionModelSchema = Schema.declare((value) => value instanceof TranscriptionModel, { expected: "Transcription.Model" });
+// ---------------------------------------------------------------------------
+// Request
+// ---------------------------------------------------------------------------
+export const TranscriptionTimestamps = Schema.Literals(["none", "segment", "word"]);
+export class TranscriptionRequest extends Schema.Class("Transcription.Request")({
+    model: TranscriptionModelSchema,
+    audio: Media.AssetSchema,
+    language: Schema.optional(Schema.String),
+    prompt: Schema.optional(Schema.String),
+    /** Routes that cannot produce the requested granularity fail typed; routes may return more than asked. */
+    timestamps: Schema.optional(TranscriptionTimestamps),
+    diarize: Schema.optional(Schema.Boolean),
+    speakers: Schema.optional(Schema.Int),
+    providerOptions: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+    http: Schema.optional(HttpOptions),
+}) {
+}
+// ---------------------------------------------------------------------------
+// Response and events
+// ---------------------------------------------------------------------------
+/** Speaker labels are provider-native (`A`, `0`, `spk:0`, or a known speaker name). */
+export const TranscriptionSegment = Schema.Struct({
+    text: Schema.String,
+    startSeconds: Schema.Number,
+    endSeconds: Schema.Number,
+    speaker: Schema.optional(Schema.String),
+}).annotate({ identifier: "Transcription.Segment" });
+export const TranscriptionWord = Schema.Struct({
+    text: Schema.String,
+    startSeconds: Schema.Number,
+    endSeconds: Schema.Number,
+    speaker: Schema.optional(Schema.String),
+    confidence: Schema.optional(Schema.Number),
+}).annotate({ identifier: "Transcription.Word" });
+const transcriptFields = {
+    text: Schema.String,
+    segments: Schema.optional(Schema.Array(TranscriptionSegment)),
+    words: Schema.optional(Schema.Array(TranscriptionWord)),
+    /** Provider-native language as detected or echoed (`en`, `english`, `en_us`), lowercased but not normalized. */
+    language: Schema.optional(Schema.String),
+    durationSeconds: Schema.optional(Schema.Number),
+    usage: Schema.optional(MediaUsage),
+    notices: Schema.optional(Schema.Array(Media.Notice)),
+    providerMetadata: Schema.optional(ProviderMetadata),
+};
+export class TranscriptionResponse extends Schema.Class("Transcription.Response")(transcriptFields) {
+}
+export const TranscriptionTextDeltaEvent = Schema.Struct({
+    type: Schema.tag("text-delta"),
+    delta: Schema.String,
+}).annotate({ identifier: "Transcription.Event.TextDelta" });
+export const TranscriptionSegmentEvent = Schema.Struct({
+    type: Schema.tag("segment"),
+    segment: TranscriptionSegment,
+}).annotate({ identifier: "Transcription.Event.Segment" });
+export const TranscriptionFinishEvent = Schema.Struct({
+    type: Schema.tag("finish"),
+    ...transcriptFields,
+}).annotate({ identifier: "Transcription.Event.Finish" });
+const transcriptionEventTagged = Schema.Union([
+    QueuedEvent,
+    ProgressEvent,
+    TranscriptionTextDeltaEvent,
+    TranscriptionSegmentEvent,
+    TranscriptionFinishEvent,
+]).pipe(Schema.toTaggedUnion("type"));
+export const TranscriptionEvent = Object.assign(transcriptionEventTagged, {
+    is: {
+        generationQueued: transcriptionEventTagged.guards["generation-queued"],
+        generationProgress: transcriptionEventTagged.guards["generation-progress"],
+        textDelta: transcriptionEventTagged.guards["text-delta"],
+        segment: transcriptionEventTagged.guards.segment,
+        finish: transcriptionEventTagged.guards.finish,
+    },
+});
+export const responseEvents = (response) => [
+    TranscriptionFinishEvent.make({ ...response }),
+];
+const collectResponse = (events) => {
+    const finish = events.find(TranscriptionEvent.is.finish);
+    // Every transcription 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 transcription stream completed without a finish event"));
+    const { type: _type, ...transcript } = finish;
+    return Effect.succeed(new TranscriptionResponse(transcript));
+};
+export function request(input) {
+    if (input instanceof TranscriptionRequest)
+        return input;
+    return new TranscriptionRequest({
+        ...input,
+        http: input.http === undefined ? undefined : HttpOptions.make(input.http),
+    });
+}
+const requestEffect = (input) => tryRequest(() => request(input));
+export function generate(input, options) {
+    return requestEffect(input).pipe(Effect.flatMap((request) => TranscriptionClient.generate(request, options)));
+}
+export function stream(input, options) {
+    return Stream.unwrap(requestEffect(input).pipe(Effect.map((request) => TranscriptionClient.stream(request, options))));
+}
+export function start(input) {
+    return requestEffect(input).pipe(Effect.flatMap((request) => TranscriptionClient.start(request)));
+}
+export const resume = (model, token) => TranscriptionClient.resume(model, token);
+export const Transcription = {
+    request,
+    generate,
+    stream,
+    start,
+    resume,
+};

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

@@ -4,3 +4,4 @@
  */
 export declare const detectMediaType: (bytes: Uint8Array) => string | undefined;
 export declare const extensionMediaType: (path: string) => string | undefined;
+export declare const mediaTypeExtension: (mediaType: string) => string | undefined;

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 = {
@@ -40,10 +45,26 @@ const EXTENSIONS = {
     mp4: "video/mp4",
     webm: "video/webm",
     mp3: "audio/mpeg",
+    m4a: "audio/mp4",
     wav: "audio/wav",
     ogg: "audio/ogg",
+    flac: "audio/flac",
+    aac: "audio/aac",
     txt: "text/plain",
     md: "text/markdown",
     csv: "text/csv",
 };
 export const extensionMediaType = (path) => EXTENSIONS[path.slice(path.lastIndexOf(".") + 1).toLowerCase()];
+const EXTENSION_ALIASES = {
+    "audio/mp3": "mp3",
+    "audio/m4a": "m4a",
+    "audio/x-m4a": "m4a",
+    "audio/webm": "webm",
+    "audio/wave": "wav",
+    "audio/x-wav": "wav",
+    "audio/x-flac": "flac",
+};
+export const mediaTypeExtension = (mediaType) => {
+    const type = mediaType.split(";", 1)[0].trim().toLowerCase();
+    return EXTENSION_ALIASES[type] ?? Object.entries(EXTENSIONS).find(([, known]) => known === type)?.[0];
+};

package/dist/video-client.d.ts

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

package/dist/video-client.js

@@ -0,0 +1,40 @@
+import { Context, Effect, Layer, Stream } from "effect";
+import { resultEvents } from "./generation.js";
+import { RequestExecutor } from "./route/executor.js";
+import { responseEvents, } from "./video.js";
+export class Service extends Context.Service()("@opencode/VideoClient") {
+}
+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 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 layer = Layer.effect(Service, Effect.gen(function* () {
+    const executor = yield* RequestExecutor.Service;
+    const start = (request) => request.model.route.start(request, executor.execute);
+    return Service.of({
+        start,
+        resume: (model, token) => model.route.resume(model, token, executor.execute),
+        generate: (request, options) => start(request).pipe(Effect.flatMap((generation) => generation.await(options))),
+        stream: (request, options) => Stream.unwrap(start(request).pipe(Effect.map((generation) => resultEvents(generation, responseEvents, options)))),
+    });
+}));
+export const VideoClient = {
+    Service,
+    layer,
+    start,
+    resume,
+    generate,
+    stream,
+};