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

package/dist/protocols/google-transcription.js

@@ -0,0 +1,138 @@
+import { Effect, Schema, SchemaGetter } from "effect";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { TranscriptionFinishEvent, TranscriptionModel, TranscriptionSegmentEvent, TranscriptionTextDeltaEvent, } from "../transcription.js";
+import { ProviderShared } from "./shared.js";
+import { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
+const ADAPTER = "google-transcription";
+const NAME = "Google Transcription";
+const PROVIDER = ProviderID.make("google");
+export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+// ---------------------------------------------------------------------------
+// 3. Streaming event schema
+// ---------------------------------------------------------------------------
+const Seconds = Schema.String.check(Schema.isPattern(/^\d+(\.\d+)?s$/)).pipe(Schema.decodeTo(Schema.Number, {
+    decode: SchemaGetter.transform((value) => Number.parseFloat(value)),
+    encode: SchemaGetter.transform((value) => `${value}s`),
+}));
+const AudioTranscription = Schema.Struct({
+    text: Schema.String,
+    speakerLabel: Schema.optional(Schema.String),
+    words: Schema.optional(Schema.Array(Schema.Struct({
+        word: Schema.String,
+        startOffset: Seconds,
+        endOffset: Seconds,
+        speakerLabel: Schema.optional(Schema.String),
+    }))),
+});
+const decodeChunk = MediaProtocol.decodeFrame(ADAPTER, NAME, GeminiGenerateContent.chunk(Schema.Struct({ audioTranscription: Schema.optional(AudioTranscription) })));
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const fromRequest = Effect.fn("GoogleTranscription.fromRequest")(function* (request) {
+    // General Gemini models ignore `audioTranscriptionConfig` and answer the audio conversationally.
+    if (!request.model.id.includes("transcribe"))
+        return yield* ProviderShared.unsupportedOperation({
+            operation: "transcription.model",
+            provider: PROVIDER,
+            route: ADAPTER,
+            message: `${request.model.id} is not a transcription model; use a transcribe model such as gemini-3.5-transcribe`,
+        });
+    return MediaProtocol.json(mergeJsonRecords({
+        contents: [{ role: "user", parts: [yield* GeminiGenerateContent.mediaPart(ADAPTER, request.audio)] }],
+        generationConfig: mergeJsonRecords({
+            audioTranscriptionConfig: {
+                languageCodes: request.language === undefined ? undefined : [request.language],
+                // Parts carry no offsets of their own, so segment times come from word offsets.
+                wordTimestamp: request.diarize === true || request.timestamps === "word" || request.timestamps === "segment"
+                    ? true
+                    : undefined,
+                diarization: request.diarize === true ? true : undefined,
+            },
+        }, request.providerOptions),
+    }, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Stream parsing
+// ---------------------------------------------------------------------------
+const turn = (part) => {
+    const words = (part.words ?? []).map((word) => ({
+        text: word.word,
+        startSeconds: word.startOffset,
+        endSeconds: word.endOffset,
+        speaker: word.speakerLabel ?? part.speakerLabel,
+    }));
+    const first = words[0];
+    const last = words.at(-1);
+    return {
+        text: part.text,
+        words,
+        segment: first === undefined || last === undefined
+            ? undefined
+            : {
+                text: part.text,
+                startSeconds: first.startSeconds,
+                endSeconds: last.endSeconds,
+                speaker: part.speakerLabel,
+            },
+    };
+};
+const step = Effect.fn("GoogleTranscription.step")(function* (state, frame) {
+    const chunk = yield* decodeChunk(frame);
+    const blocked = GeminiGenerateContent.blocked(NAME, chunk, frame);
+    if (blocked !== undefined)
+        return yield* blocked;
+    const turns = (chunk.candidates?.[0]?.content?.parts ?? []).flatMap((part) => part.audioTranscription === undefined ? [] : [turn(part.audioTranscription)]);
+    const segments = turns.flatMap((item) => (item.segment === undefined ? [] : [item.segment]));
+    state.words.push(...turns.flatMap((item) => item.words));
+    state.segments.push(...segments);
+    // Each part is one whole speaker turn without surrounding whitespace, so turns join with a space.
+    const text = turns
+        .map((item) => item.text)
+        .filter((item) => item.length > 0)
+        .join(" ");
+    const delta = text.length === 0 || state.text.length === 0 ? text : ` ${text}`;
+    const events = [
+        ...(delta.length === 0 ? [] : [TranscriptionTextDeltaEvent.make({ delta })]),
+        ...segments.map((segment) => TranscriptionSegmentEvent.make({ segment })),
+    ];
+    return [{ ...GeminiGenerateContent.track(state, chunk), text: state.text + delta }, events];
+});
+const finish = (state) => {
+    if (state.finishReason === undefined)
+        return Effect.fail(MediaProtocol.incomplete(ADAPTER));
+    return Effect.succeed([
+        TranscriptionFinishEvent.make({
+            text: state.text,
+            segments: state.segments.length === 0 ? undefined : state.segments,
+            words: state.words.length === 0 ? undefined : state.words,
+            usage: GeminiGenerateContent.usage(state.usage),
+            providerMetadata: GeminiGenerateContent.providerMetadata(state),
+        }),
+    ]);
+};
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.stream({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["prompt", "speakers"],
+    body: { from: fromRequest },
+    frames: (bytes, context) => GeminiGenerateContent.frames(bytes, context.request.mode),
+    initial: () => ({ text: "", segments: [], words: [] }),
+    step,
+    finish,
+});
+export const model = (input) => TranscriptionModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    path: ({ request }) => GeminiGenerateContent.path(request.model.id, request.mode),
+}, input);
+export const GoogleTranscription = {
+    protocol,
+    model,
+};

package/dist/protocols/openai-images.js

@@ -43,11 +43,6 @@ const nativeOptions = (options) => {
 };
 const isEdit = (request) => (request.images?.length ?? 0) > 0;
 const isInline = (asset) => asset.inline() !== undefined;
-const blob = (data, mediaType) => {
-    const buffer = new ArrayBuffer(data.byteLength);
-    new Uint8Array(buffer).set(data);
-    return new Blob([buffer], { type: mediaType });
-};
 const reference = (asset) => ProviderShared.mediaReference(asset, PROVIDER, NAME).pipe(Effect.map((item) => (item.type === "ref" ? { file_id: item.value } : { image_url: item.value })));
 const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request) {
     const images = request.images ?? [];
@@ -66,9 +61,9 @@ const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request) {
             form.append(key, typeof value === "string" ? value : ProviderShared.encodeJson(value));
         });
         const uploads = yield* Effect.forEach(images, (image) => MediaInput.inlineBytes(ADAPTER, image));
-        uploads.forEach((data, index) => form.append("image[]", blob(data, images[index].mediaType), `image-${index}`));
+        uploads.forEach((data, index) => form.append("image[]", MediaInput.blob(data, images[index].mediaType), `image-${index}`));
         if (mask !== undefined)
-            form.append("mask", blob(yield* MediaInput.inlineBytes(ADAPTER, mask), mask.mediaType), "mask");
+            form.append("mask", MediaInput.blob(yield* MediaInput.inlineBytes(ADAPTER, mask), mask.mediaType), "mask");
         return MediaProtocol.multipart(form);
     }
     const references = yield* Effect.forEach(images, reference);
@@ -84,6 +79,8 @@ const fromRequest = Effect.fn("OpenAIImages.fromRequest")(function* (request) {
 // 6. Response decoding
 // ---------------------------------------------------------------------------
 const requestedFormat = (body) => {
+    if (body.type === "binary")
+        return undefined;
     const value = body.type === "json" ? body.value.output_format : body.value.get("output_format");
     return typeof value === "string" ? value : undefined;
 };

package/dist/protocols/openai-transcription.d.ts

@@ -0,0 +1,207 @@
+import { Schema } from "effect";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { TranscriptionModel, type TranscriptionRequestFor, type TranscriptionSegment } from "../transcription.js";
+export declare const DEFAULT_BASE_URL = "https://api.openai.com/v1";
+export declare const PATH = "/audio/transcriptions";
+export type OpenAITranscriptionOptions = {
+    readonly chunking_strategy?: "auto" | {
+        readonly type: "server_vad";
+        readonly prefix_padding_ms?: number;
+        readonly silence_duration_ms?: number;
+        readonly threshold?: number;
+    };
+    readonly include?: ReadonlyArray<"logprobs">;
+    readonly keywords?: ReadonlyArray<string>;
+    readonly known_speaker_names?: ReadonlyArray<string>;
+    readonly known_speaker_references?: ReadonlyArray<string>;
+    readonly temperature?: number;
+} & Record<string, unknown>;
+export type Request = TranscriptionRequestFor<OpenAITranscriptionOptions>;
+declare const Transcript: Schema.Struct<{
+    text: Schema.String;
+    language: Schema.optional<Schema.String>;
+    languages: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly code: Schema.String;
+    }>>>;
+    duration: Schema.optional<Schema.Number>;
+    segments: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly text: Schema.String;
+        readonly start: Schema.Number;
+        readonly end: Schema.Number;
+        readonly speaker: Schema.optional<Schema.String>;
+    }>>>;
+    words: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly word: Schema.String;
+        readonly start: Schema.Number;
+        readonly end: Schema.Number;
+    }>>>;
+    usage: Schema.optional<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"tokens">;
+        readonly input_tokens: Schema.optional<Schema.Number>;
+        readonly output_tokens: Schema.optional<Schema.Number>;
+        readonly total_tokens: Schema.optional<Schema.Number>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"duration">;
+        readonly seconds: Schema.Number;
+    }>]>>;
+}>;
+type Transcript = Schema.Schema.Type<typeof Transcript>;
+type Frame = string | {
+    readonly document: string;
+};
+interface State {
+    readonly segments: Array<TranscriptionSegment>;
+    readonly transcript?: Transcript;
+}
+export declare const protocol: MediaProtocol.Streamed<Request, {
+    readonly id: string;
+    readonly type: "generation-queued";
+    readonly position?: number | undefined;
+} | {
+    readonly id: string;
+    readonly type: "generation-progress";
+    readonly progress?: number | undefined;
+} | {
+    readonly type: "text-delta";
+    readonly delta: string;
+} | {
+    readonly type: "segment";
+    readonly segment: {
+        readonly text: string;
+        readonly startSeconds: number;
+        readonly endSeconds: number;
+        readonly speaker?: string | undefined;
+    };
+} | {
+    readonly type: "finish";
+    readonly text: string;
+    readonly durationSeconds?: number | undefined;
+    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;
+    readonly language?: string | undefined;
+    readonly segments?: readonly {
+        readonly text: string;
+        readonly startSeconds: number;
+        readonly endSeconds: number;
+        readonly speaker?: string | undefined;
+    }[] | undefined;
+    readonly words?: readonly {
+        readonly text: string;
+        readonly startSeconds: number;
+        readonly endSeconds: number;
+        readonly speaker?: string | undefined;
+        readonly confidence?: number | undefined;
+    }[] | undefined;
+}, Frame, State>;
+export declare const model: (input: MediaRoute.ModelInput) => TranscriptionModel<OpenAITranscriptionOptions>;
+export declare const OpenAITranscription: {
+    readonly protocol: MediaProtocol.Streamed<Request, {
+        readonly id: string;
+        readonly type: "generation-queued";
+        readonly position?: number | undefined;
+    } | {
+        readonly id: string;
+        readonly type: "generation-progress";
+        readonly progress?: number | undefined;
+    } | {
+        readonly type: "text-delta";
+        readonly delta: string;
+    } | {
+        readonly type: "segment";
+        readonly segment: {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+            readonly speaker?: string | undefined;
+        };
+    } | {
+        readonly type: "finish";
+        readonly text: string;
+        readonly durationSeconds?: number | undefined;
+        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;
+        readonly language?: string | undefined;
+        readonly segments?: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+            readonly speaker?: string | undefined;
+        }[] | undefined;
+        readonly words?: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+            readonly speaker?: string | undefined;
+            readonly confidence?: number | undefined;
+        }[] | undefined;
+    }, Frame, State>;
+    readonly model: (input: MediaRoute.ModelInput) => TranscriptionModel<OpenAITranscriptionOptions>;
+};
+export {};

package/dist/protocols/openai-transcription.js

@@ -0,0 +1,190 @@
+import { Effect, Schema, Stream } from "effect";
+import { Framing } from "../route/framing.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { TranscriptionFinishEvent, TranscriptionModel, TranscriptionSegmentEvent, TranscriptionTextDeltaEvent, } from "../transcription.js";
+import { mediaTypeExtension } from "../utils/media-type.js";
+import { ProviderShared } from "./shared.js";
+import { MediaInput } from "./utils/media-input.js";
+const ADAPTER = "openai-transcription";
+const NAME = "OpenAI Transcription";
+const PROVIDER = ProviderID.make("openai");
+export const DEFAULT_BASE_URL = "https://api.openai.com/v1";
+export const PATH = "/audio/transcriptions";
+// ---------------------------------------------------------------------------
+// 3. Streaming event schema
+// ---------------------------------------------------------------------------
+const Segment = Schema.Struct({
+    text: Schema.String,
+    start: Schema.Number,
+    end: Schema.Number,
+    speaker: Schema.optional(Schema.String),
+});
+const Usage = Schema.Union([
+    Schema.Struct({
+        type: Schema.Literal("tokens"),
+        input_tokens: Schema.optional(Schema.Number),
+        output_tokens: Schema.optional(Schema.Number),
+        total_tokens: Schema.optional(Schema.Number),
+    }),
+    Schema.Struct({ type: Schema.Literal("duration"), seconds: Schema.Number }),
+]);
+const transcriptFields = {
+    text: Schema.String,
+    language: Schema.optional(Schema.String),
+    languages: Schema.optional(Schema.Array(Schema.Struct({ code: Schema.String }))),
+    duration: Schema.optional(Schema.Number),
+    segments: Schema.optional(Schema.Array(Segment)),
+    words: Schema.optional(Schema.Array(Schema.Struct({ word: Schema.String, start: Schema.Number, end: Schema.Number }))),
+    usage: Schema.optional(Usage),
+};
+const Event = Schema.Union([
+    Schema.Struct({ type: Schema.Literal("transcript.text.delta"), delta: Schema.String }),
+    Schema.Struct({ type: Schema.Literal("transcript.text.segment"), ...Segment.fields }),
+    Schema.Struct({ type: Schema.Literal("transcript.text.done"), ...transcriptFields }),
+]);
+const Transcript = Schema.Struct(transcriptFields);
+const decodeEvent = MediaProtocol.decodeFrame(ADAPTER, NAME, Event);
+const decodeTranscript = MediaProtocol.decodeFrame(ADAPTER, NAME, Transcript);
+const TRANSCRIBE = { stream: true, timestamps: [], diarize: false, languageField: "language" };
+const capabilities = (model) => {
+    if (model.startsWith("whisper"))
+        return { ...TRANSCRIBE, stream: false, timestamps: ["segment", "word"] };
+    if (model.includes("diarize"))
+        return { ...TRANSCRIBE, timestamps: ["segment"], diarize: true };
+    // `gpt-transcribe` replaces `language` with `languages[]` and rejects both together.
+    if (model.startsWith("gpt-transcribe"))
+        return { ...TRANSCRIBE, languageField: "languages" };
+    return TRANSCRIBE;
+};
+const unsupported = (operation, message) => Effect.fail(ProviderShared.unsupportedOperation({ operation, provider: PROVIDER, route: ADAPTER, message }));
+const validate = (request, model) => {
+    const id = request.model.id;
+    if (request.mode === "stream" && !model.stream)
+        return unsupported("media.stream", `${id} does not stream; use Transcription.generate`);
+    if (request.diarize === true && !model.diarize)
+        return unsupported("media.diarize", `${id} does not diarize; use gpt-4o-transcribe-diarize`);
+    if (request.prompt !== undefined && model.diarize)
+        return unsupported("media.prompt", `${id} does not accept a prompt`);
+    if (request.timestamps === undefined ||
+        request.timestamps === "none" ||
+        model.timestamps.includes(request.timestamps))
+        return Effect.void;
+    return unsupported("media.timestamps", `${id} does not return ${request.timestamps} timestamps`);
+};
+const RESERVED_FORM_FIELDS = new Set([
+    "file",
+    "model",
+    "prompt",
+    "language",
+    "response_format",
+    "timestamp_granularities",
+    "stream",
+]);
+const appendField = (form, key, value) => {
+    if (Array.isArray(value))
+        return value.forEach((item) => form.append(`${key}[]`, String(item)));
+    form.append(key, typeof value === "object" && value !== null ? ProviderShared.encodeJson(value) : String(value));
+};
+const fromRequest = Effect.fn("OpenAITranscription.fromRequest")(function* (request) {
+    const model = capabilities(request.model.id);
+    yield* validate(request, model);
+    // The API detects the audio format from the upload's filename extension.
+    const extension = mediaTypeExtension(request.audio.mediaType);
+    if (extension === undefined)
+        return yield* ProviderShared.invalidRequest(`${NAME} cannot name a ${request.audio.mediaType} upload; send mp3, mp4, m4a, wav, webm, ogg, or flac audio`);
+    const audio = yield* MediaInput.inlineBytes(ADAPTER, request.audio);
+    const responseFormat = model.diarize
+        ? "diarized_json"
+        : request.timestamps === undefined || request.timestamps === "none"
+            ? undefined
+            : "verbose_json";
+    const native = Object.entries(mergeJsonRecords(request.providerOptions, request.http?.body) ?? {}).filter(([key]) => !RESERVED_FORM_FIELDS.has(key));
+    const fields = mergeJsonRecords({
+        model: request.model.id,
+        language: model.languageField === "language" ? request.language : undefined,
+        languages: model.languageField === "languages" && request.language !== undefined ? [request.language] : undefined,
+        prompt: request.prompt,
+        response_format: responseFormat,
+        timestamp_granularities: responseFormat === "verbose_json" ? [request.timestamps] : undefined,
+        // Diarizing audio longer than 30 seconds requires a chunking strategy.
+        chunking_strategy: model.diarize ? "auto" : undefined,
+        stream: request.mode === "stream" ? true : undefined,
+    }, Object.fromEntries(native));
+    const form = new FormData();
+    form.append("file", MediaInput.blob(audio, request.audio.mediaType), `audio.${extension}`);
+    Object.entries(fields ?? {}).forEach(([key, value]) => appendField(form, key, value));
+    return MediaProtocol.multipart(form);
+});
+// ---------------------------------------------------------------------------
+// 6. Stream parsing
+// ---------------------------------------------------------------------------
+const segment = (value) => ({
+    text: value.text.trim(),
+    startSeconds: value.start,
+    endSeconds: value.end,
+    speaker: value.speaker,
+});
+const onEvent = Effect.fn("OpenAITranscription.onEvent")(function* (state, frame) {
+    const event = yield* decodeEvent(frame);
+    if (event.type === "transcript.text.done")
+        return [{ ...state, transcript: event }, []];
+    if (event.type === "transcript.text.delta")
+        return [state, event.delta.length === 0 ? [] : [TranscriptionTextDeltaEvent.make({ delta: event.delta })]];
+    const next = segment(event);
+    state.segments.push(next);
+    return [state, [TranscriptionSegmentEvent.make({ segment: next })]];
+});
+const step = (state, frame) => typeof frame === "string"
+    ? onEvent(state, frame)
+    : decodeTranscript(frame.document).pipe(Effect.map((transcript) => [{ ...state, transcript }, []]));
+const usage = (value) => {
+    if (value === undefined)
+        return undefined;
+    if (value.type === "duration")
+        return { type: "seconds", seconds: value.seconds };
+    return {
+        type: "tokens",
+        input: value.input_tokens,
+        output: value.output_tokens,
+        total: value.total_tokens,
+        details: { openai: value },
+    };
+};
+const finish = (state) => {
+    const transcript = state.transcript;
+    if (transcript === undefined)
+        return Effect.fail(MediaProtocol.incomplete(ADAPTER));
+    const segments = transcript.segments?.map(segment) ?? state.segments;
+    return Effect.succeed([
+        TranscriptionFinishEvent.make({
+            text: transcript.text,
+            segments: segments.length === 0 ? undefined : segments,
+            words: transcript.words?.map((word) => ({ text: word.word, startSeconds: word.start, endSeconds: word.end })),
+            language: (transcript.language ?? transcript.languages?.[0]?.code)?.toLowerCase(),
+            durationSeconds: transcript.duration,
+            usage: usage(transcript.usage),
+        }),
+    ]);
+};
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.stream({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["speakers"],
+    body: { from: fromRequest },
+    frames: (bytes, context) => context.request.mode === "stream"
+        ? Framing.sse.frame(bytes)
+        : Framing.document.frame(bytes).pipe(Stream.map((document) => ({ document }))),
+    initial: () => ({ segments: [] }),
+    step,
+    finish,
+});
+export const model = (input) => TranscriptionModel.fromRoute({ id: ADAPTER, provider: PROVIDER, protocol, baseURL: DEFAULT_BASE_URL, path: PATH }, input);
+export const OpenAITranscription = {
+    protocol,
+    model,
+};

package/dist/protocols/utils/gemini-generate-content.d.ts

@@ -0,0 +1,65 @@
+import { Effect, Schema, type Stream } from "effect";
+import type { Media } from "../../media.js";
+import type { MediaProtocol } from "../../route/media-protocol.js";
+import { AIError, type MediaUsage, type ProviderMetadata } from "../../schema/index.js";
+declare const UsageMetadata: Schema.Struct<{
+    readonly promptTokenCount: Schema.optional<Schema.Number>;
+    readonly candidatesTokenCount: Schema.optional<Schema.Number>;
+    readonly totalTokenCount: Schema.optional<Schema.Number>;
+}>;
+type UsageMetadata = Schema.Schema.Type<typeof UsageMetadata>;
+export declare const chunk: <const Part extends Schema.Top>(part: Part) => Schema.Struct<{
+    readonly candidates: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly content: Schema.optional<Schema.Struct<{
+            readonly parts: Schema.optional<Schema.$Array<Part>>;
+        }>>;
+        readonly finishReason: Schema.optional<Schema.String>;
+    }>>>;
+    readonly promptFeedback: Schema.optional<Schema.Struct<{
+        readonly blockReason: Schema.optional<Schema.String>;
+        readonly blockReasonMessage: Schema.optional<Schema.String>;
+    }>>;
+    readonly usageMetadata: Schema.optional<Schema.Struct<{
+        readonly promptTokenCount: Schema.optional<Schema.Number>;
+        readonly candidatesTokenCount: Schema.optional<Schema.Number>;
+        readonly totalTokenCount: Schema.optional<Schema.Number>;
+    }>>;
+    readonly modelVersion: Schema.optional<Schema.String>;
+    readonly responseId: Schema.optional<Schema.String>;
+}>;
+interface Chunk {
+    readonly candidates?: ReadonlyArray<{
+        readonly finishReason?: string;
+    }>;
+    readonly promptFeedback?: {
+        readonly blockReason?: string;
+        readonly blockReasonMessage?: string;
+    };
+    readonly usageMetadata?: UsageMetadata;
+    readonly modelVersion?: string;
+    readonly responseId?: string;
+}
+export interface Metadata {
+    readonly usage?: UsageMetadata;
+    readonly finishReason?: string;
+    readonly modelVersion?: string;
+    readonly responseId?: string;
+}
+export declare const track: <State extends Metadata>(state: State, chunk: Chunk) => State;
+export declare const blocked: (name: string, chunk: Chunk, frame: string) => AIError | undefined;
+export declare const usage: (usage: UsageMetadata | undefined) => MediaUsage | undefined;
+export declare const providerMetadata: (state: Metadata) => ProviderMetadata;
+export declare const path: (model: string, mode: MediaProtocol.Mode) => string;
+export declare const frames: (bytes: Stream.Stream<Uint8Array, AIError>, mode: MediaProtocol.Mode) => Stream.Stream<string, AIError, never>;
+export declare const mediaPart: (route: string, asset: Media.Asset) => Effect.Effect<{
+    readonly fileData: {
+        readonly mimeType: string;
+        readonly fileUri: string;
+    };
+} | {
+    readonly inlineData: {
+        readonly mimeType: string;
+        readonly data: string;
+    };
+}, AIError>;
+export * as GeminiGenerateContent from "./gemini-generate-content.js";