@opencode/ai 2.0.15 → 2.0.17

package/dist/transcription.js

@@ -0,0 +1,127 @@
+import { Effect, Schema, Stream } from "effect";
+import { Generation, 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 { TranscriptionClient, Service } from "./transcription-client.js";
+export class TranscriptionModel extends MediaModel {
+    static fromRoute(route, input) {
+        return new TranscriptionModel({
+            id: input.id,
+            provider: route.protocol.provider,
+            http: input.http,
+            route: composeRoute(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,
+    },
+});
+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: 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/json.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+export declare const Json: Schema.fromJsonString<Schema.Unknown>;
+export declare const decodeJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => unknown;
+export declare const encodeJson: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => string;

package/dist/utils/json.js

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+export const Json = Schema.fromJsonString(Schema.Unknown);
+export const decodeJson = Schema.decodeUnknownSync(Json);
+export const encodeJson = Schema.encodeSync(Json);

package/dist/utils/media-type.d.ts

@@ -3,4 +3,6 @@
  * `undefined` so callers can fall back to a provider-declared type or `application/octet-stream`.
  */
 export declare const detectMediaType: (bytes: Uint8Array) => string | undefined;
-export declare const extensionMediaType: (path: string) => string | undefined;
+/** Media type of a file's contents: sniffed magic bytes, then the path's extension. */
+export declare const fileMediaType: (bytes: Uint8Array, 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,28 @@ 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 extensionMediaType = (path) => EXTENSIONS[path.slice(path.lastIndexOf(".") + 1).toLowerCase()];
+/** Media type of a file's contents: sniffed magic bytes, then the path's extension. */
+export const fileMediaType = (bytes, path) => detectMediaType(bytes) ?? extensionMediaType(path);
+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,59 @@
+import { Context } from "effect";
+import { MediaClient } from "./media-client.js";
+import { type VideoEvent, type VideoRequestFor, type VideoResponse } from "./video.js";
+export type Interface = MediaClient.Interface<VideoRequestFor, VideoEvent, VideoResponse>;
+declare const VideoClientService_base: Context.ServiceClass<VideoClientService, "@opencode/VideoClient", Interface>;
+export declare class VideoClientService extends VideoClientService_base {
+}
+export declare const Service: typeof VideoClientService;
+export type Service = VideoClientService;
+export declare const VideoClient: {
+    readonly layer: import("effect/Layer").Layer<VideoClientService, never, import("./route/executor-service.js").RequestExecutorService>;
+    readonly generate: (request: VideoRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Effect").Effect<VideoResponse, import("./index.js").AIError, VideoClientService>;
+    readonly stream: (request: VideoRequestFor, options?: import("./generation.js").AwaitOptions) => import("effect/Stream").Stream<import("./generation.js").Observation | {
+        readonly type: "video";
+        readonly index: number;
+        readonly video: import("./media.js").Asset;
+    } | {
+        readonly type: "finish";
+        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, VideoClientService>;
+    readonly start: (request: VideoRequestFor) => import("effect/Effect").Effect<import("./generation.js").Generation<VideoResponse>, import("./index.js").AIError, VideoClientService>;
+    readonly resume: (model: import("./video.js").VideoModel<import("./media-model.js").MediaModel.Options>, token: unknown) => import("effect/Effect").Effect<import("./generation.js").Generation<VideoResponse>, import("./index.js").AIError, VideoClientService>;
+    readonly Service: typeof VideoClientService;
+};
+export {};

package/dist/video-client.js

@@ -0,0 +1,20 @@
+import { Context } from "effect";
+import { MediaClient } from "./media-client.js";
+import { VideoOutputEvent, VideoFinishEvent, } from "./video.js";
+export class VideoClientService extends Context.Service()("@opencode/VideoClient") {
+}
+export const Service = VideoClientService;
+export const VideoClient = {
+    Service,
+    ...MediaClient.make(Service, {
+        modality: "video",
+        responseEvents: (response) => [
+            ...response.videos.map((video, index) => VideoOutputEvent.make({ index, video })),
+            VideoFinishEvent.make({
+                usage: response.usage,
+                notices: response.notices,
+                providerMetadata: response.providerMetadata,
+            }),
+        ],
+    }),
+};