@opencode/ai 0.0.0-dev-20048 → 0.0.0-dev-20050

package/dist/transcription.js

@@ -0,0 +1,140 @@
+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 make(input) {
+        return new TranscriptionModel(input);
+    }
+    static fromRoute(route, input) {
+        const composed = isStreamInput(route)
+            ? composeRoute((composition) => MediaRoute.stream({ ...composition, collect: collectResponse }), route, input)
+            : isQueuedInput(route)
+                ? composeRoute(MediaRoute.queued, route, input)
+                : composeRoute(MediaRoute.inline, route, input);
+        return new TranscriptionModel({
+            id: input.id,
+            provider: route.provider,
+            http: input.http,
+            route: composed,
+        });
+    }
+}
+const isStreamInput = (route) => route.protocol.kind === "stream";
+const isQueuedInput = (route) => route.protocol.kind === "queued";
+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/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

@@ -45,6 +45,7 @@ const EXTENSIONS = {
     mp4: "video/mp4",
     webm: "video/webm",
     mp3: "audio/mpeg",
+    m4a: "audio/mp4",
     wav: "audio/wav",
     ogg: "audio/ogg",
     flac: "audio/flac",
@@ -54,3 +55,16 @@ const EXTENSIONS = {
     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

@@ -1,5 +1,5 @@
 import { Context, Effect, Layer, Stream } from "effect";
-import type { AwaitOptions, Generation } from "./generation.js";
+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";

package/dist/video-client.js

@@ -1,6 +1,7 @@
 import { Context, Effect, Layer, Stream } from "effect";
+import { resultEvents } from "./generation.js";
 import { RequestExecutor } from "./route/executor.js";
-import { isObservation, responseEvents, } from "./video.js";
+import { responseEvents, } from "./video.js";
 export class Service extends Context.Service()("@opencode/VideoClient") {
 }
 export const start = (request) => Effect.gen(function* () {
@@ -19,10 +20,6 @@ export const stream = (request, options) => Stream.unwrap(Effect.gen(function* (
     const client = yield* Service;
     return client.stream(request, options);
 }));
-/** Status observations until the first terminal one, then the fetched result expanded into events. */
-const events = (generation, options) => generation
-    .events(options)
-    .pipe(Stream.filter(isObservation), Stream.concat(Stream.fromIterableEffect(Effect.map(generation.result(), responseEvents))));
 export const layer = Layer.effect(Service, Effect.gen(function* () {
     const executor = yield* RequestExecutor.Service;
     const start = (request) => request.model.route.start(request, executor.execute);
@@ -30,7 +27,7 @@ export const layer = Layer.effect(Service, Effect.gen(function* () {
         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) => events(generation, options)))),
+        stream: (request, options) => Stream.unwrap(start(request).pipe(Effect.map((generation) => resultEvents(generation, responseEvents, options)))),
     });
 }));
 export const VideoClient = {

package/dist/video.d.ts

@@ -1,5 +1,5 @@
 import { Effect, Schema, Stream } from "effect";
-import { Generation, type AwaitOptions, type Event as GenerationEvent } from "./generation.js";
+import { Generation, type AwaitOptions } from "./generation.js";
 import { Media } from "./media.js";
 import { MediaModel } from "./media-model.js";
 import { MediaRoute } from "./route/media.js";
@@ -304,16 +304,6 @@ declare const VideoResponse_base: Schema.Class<VideoResponse, Schema.Struct<{
 export declare class VideoResponse extends VideoResponse_base {
     get video(): Media.Asset;
 }
-export declare const VideoQueuedEvent: Schema.Struct<{
-    readonly type: Schema.tag<"generation-queued">;
-    readonly id: Schema.String;
-    readonly position: Schema.optional<Schema.Number>;
-}>;
-export declare const VideoProgressEvent: Schema.Struct<{
-    readonly type: Schema.tag<"generation-progress">;
-    readonly id: Schema.String;
-    readonly progress: Schema.optional<Schema.Number>;
-}>;
 export declare const VideoOutputEvent: Schema.Struct<{
     readonly type: Schema.tag<"video">;
     readonly index: Schema.Number;
@@ -1349,10 +1339,6 @@ export declare const VideoEvent: Schema.Union<readonly [Schema.Struct<{
 export type VideoEvent = Schema.Schema.Type<typeof videoEventTagged>;
 /** A completed response expanded into the streaming event shape. */
 export declare const responseEvents: (response: VideoResponse) => ReadonlyArray<VideoEvent>;
-/** A status observation as a video event; the terminal observation is replaced by the result events, so `none`. */
-export declare const isObservation: (event: GenerationEvent) => event is Extract<VideoEvent, {
-    type: "generation-queued" | "generation-progress";
-}>;
 export declare function request<const Model extends VideoModel>(input: VideoRequestInput<Model>): VideoRequestFor<VideoModelOptions<Model>>;
 export declare function request(input: VideoRequest): VideoRequest;
 export declare function start<const Model extends VideoModel>(input: VideoRequestInput<Model>): Effect.Effect<Generation<VideoResponse>, AIError, Service>;

package/dist/video.js

@@ -1,5 +1,5 @@
 import { Effect, Schema, Stream } from "effect";
-import { Generation } from "./generation.js";
+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";
@@ -61,16 +61,6 @@ export class VideoResponse extends Schema.Class("Video.Response")({
         return this.videos[0];
     }
 }
-export const VideoQueuedEvent = Schema.Struct({
-    type: Schema.tag("generation-queued"),
-    id: Schema.String,
-    position: Schema.optional(Schema.Number),
-}).annotate({ identifier: "Video.Event.Queued" });
-export const VideoProgressEvent = Schema.Struct({
-    type: Schema.tag("generation-progress"),
-    id: Schema.String,
-    progress: Schema.optional(Schema.Number),
-}).annotate({ identifier: "Video.Event.Progress" });
 export const VideoOutputEvent = Schema.Struct({
     type: Schema.tag("video"),
     index: Schema.Number,
@@ -82,7 +72,7 @@ export const VideoFinishEvent = Schema.Struct({
     notices: Schema.optional(Schema.Array(Media.Notice)),
     providerMetadata: Schema.optional(ProviderMetadata),
 }).annotate({ identifier: "Video.Event.Finish" });
-const videoEventTagged = Schema.Union([VideoQueuedEvent, VideoProgressEvent, VideoOutputEvent, VideoFinishEvent]).pipe(Schema.toTaggedUnion("type"));
+const videoEventTagged = Schema.Union([QueuedEvent, ProgressEvent, VideoOutputEvent, VideoFinishEvent]).pipe(Schema.toTaggedUnion("type"));
 export const VideoEvent = Object.assign(videoEventTagged, {
     is: {
         generationQueued: videoEventTagged.guards["generation-queued"],
@@ -100,8 +90,6 @@ export const responseEvents = (response) => [
         providerMetadata: response.providerMetadata,
     }),
 ];
-/** A status observation as a video event; the terminal observation is replaced by the result events, so `none`. */
-export const isObservation = (event) => event.type !== "generation-finished";
 export function request(input) {
     if (input instanceof VideoRequest)
         return input;

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-20048",
+  "version": "0.0.0-dev-20050",
   "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-20048",
+    "@opencode/http-recorder": "0.0.0-dev-20050",
     "@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-20048",
+    "@opencode/schema": "0.0.0-dev-20050",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"