@opencode/ai 2.0.15 → 2.0.17

package/dist/protocols/google-speech.d.ts

@@ -0,0 +1,146 @@
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { SpeechModel, type SpeechRequestFor } from "../speech.js";
+import { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
+import { SpeechStream } from "./utils/speech-stream.js";
+export declare const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+/** Style is directed in the text itself, and `speechConfig.multiSpeakerVoiceConfig` excludes `voice`. */
+export type GoogleSpeechOptions = {
+    readonly temperature?: number;
+    readonly seed?: number;
+    readonly speechConfig?: {
+        readonly multiSpeakerVoiceConfig?: {
+            readonly speakerVoiceConfigs: ReadonlyArray<{
+                readonly speaker: string;
+                readonly voiceConfig: {
+                    readonly prebuiltVoiceConfig: {
+                        readonly voiceName: string;
+                    };
+                };
+            }>;
+        };
+    };
+} & Record<string, unknown>;
+export type Request = SpeechRequestFor<GoogleSpeechOptions>;
+interface State extends SpeechStream.Audio, GeminiGenerateContent.Metadata {
+    readonly mimeType?: string;
+}
+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: "audio-delta";
+    readonly chunk: Uint8Array<ArrayBufferLike>;
+} | {
+    readonly type: "timestamps";
+    readonly items: readonly {
+        readonly text: string;
+        readonly startSeconds: number;
+        readonly endSeconds: number;
+    }[];
+} | {
+    readonly type: "finish";
+    readonly audio: import("../media.js").Asset;
+    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;
+}, string, State>;
+export declare const model: (input: MediaRoute.ModelInput) => SpeechModel<GoogleSpeechOptions>;
+export declare const GoogleSpeech: {
+    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: "audio-delta";
+        readonly chunk: Uint8Array<ArrayBufferLike>;
+    } | {
+        readonly type: "timestamps";
+        readonly items: readonly {
+            readonly text: string;
+            readonly startSeconds: number;
+            readonly endSeconds: number;
+        }[];
+    } | {
+        readonly type: "finish";
+        readonly audio: import("../media.js").Asset;
+        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;
+    }, string, State>;
+    readonly model: (input: MediaRoute.ModelInput) => SpeechModel<GoogleSpeechOptions>;
+};
+export {};

package/dist/protocols/google-speech.js

@@ -0,0 +1,88 @@
+import { Effect, Schema } from "effect";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { mergeJsonRecords } from "../schema/index.js";
+import { SpeechModel } from "../speech.js";
+import { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
+import { SpeechStream } from "./utils/speech-stream.js";
+const route = MediaProtocol.identity({ id: "google-speech", name: "Google Speech", provider: "google" });
+export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+const DEFAULT_SAMPLE_RATE = 24000;
+// ---------------------------------------------------------------------------
+// 3. Streaming event schema
+// ---------------------------------------------------------------------------
+const GenerateContentChunk = GeminiGenerateContent.chunk(Schema.Struct({
+    text: Schema.optional(Schema.String),
+    inlineData: Schema.optional(Schema.Struct({ mimeType: Schema.String, data: Schema.Uint8ArrayFromBase64 })),
+}));
+const decodeChunk = route.decodeFrame(GenerateContentChunk);
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const fromRequest = Effect.fn("GoogleSpeech.fromRequest")(function* (request) {
+    // Not in `unsupported`: that list would also reject `timestamps: false`, which asks for nothing.
+    if (request.timestamps === true)
+        return yield* route.unsupported("media.timestamps", `${route.name} does not return timestamps`);
+    if (request.format === "pcm" && request.mode === "generate" && /^gemini-3\.8-.*-tts(?:-|$)/.test(request.model.id))
+        return yield* route.unsupported("media.format", `${route.name} returns WAV by default for Gemini 3.8 TTS unary requests; omit the format to accept it`);
+    if (request.format !== undefined && request.format !== "pcm")
+        return yield* route.unsupported("media.format", `${route.name} only accepts raw PCM as an explicit format; omit it to accept the provider's default output`);
+    const voiceName = SpeechStream.voiceID(request.voice);
+    return MediaProtocol.json(mergeJsonRecords({
+        contents: [{ role: "user", parts: [{ text: request.text }] }],
+        generationConfig: mergeJsonRecords({
+            responseModalities: ["AUDIO"],
+            speechConfig: {
+                voiceConfig: voiceName === undefined ? undefined : { prebuiltVoiceConfig: { voiceName } },
+                languageCode: request.language,
+            },
+        }, request.providerOptions),
+    }, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Stream parsing
+// ---------------------------------------------------------------------------
+const step = Effect.fn("GoogleSpeech.step")(function* (state, frame) {
+    const chunk = yield* decodeChunk(frame);
+    const blocked = GeminiGenerateContent.blocked(route.name, chunk, frame);
+    if (blocked !== undefined)
+        return yield* blocked;
+    const audio = (chunk.candidates?.[0]?.content?.parts ?? []).flatMap((part) => part.inlineData === undefined ? [] : [part.inlineData]);
+    const next = { ...GeminiGenerateContent.track(state, chunk), mimeType: state.mimeType ?? audio[0]?.mimeType };
+    return [next, audio.flatMap((part) => SpeechStream.delta(next, part.data)[1])];
+});
+const finish = (state, context) => {
+    const sampleRate = SpeechStream.sampleRate(state.mimeType) ?? DEFAULT_SAMPLE_RATE;
+    const output = state.mimeType?.split(";")[0]?.toLowerCase() === "audio/wav"
+        ? SpeechStream.container("wav", sampleRate)
+        : SpeechStream.pcm("pcm_s16le", sampleRate, state.mimeType ?? `audio/L16;codec=pcm;rate=${sampleRate}`);
+    if (context.request.format === "pcm" && output.info.format !== "pcm")
+        return Effect.fail(route.frameError(`Google Speech returned ${output.info.format} instead of the requested raw PCM`));
+    return SpeechStream.finish(route, state, {
+        ...output,
+        usage: GeminiGenerateContent.usage(state.usage),
+        providerMetadata: GeminiGenerateContent.providerMetadata(state),
+        detail: state.finishReason === undefined ? undefined : `finish reason: ${state.finishReason}`,
+    });
+};
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.stream(route, {
+    unsupported: ["instructions", "speed"],
+    body: { from: fromRequest },
+    frames: (bytes, context) => GeminiGenerateContent.frames(bytes, context.request.mode),
+    initial: () => ({ chunks: [] }),
+    step,
+    finish,
+});
+export const model = (input) => SpeechModel.fromRoute({
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    // Only `gemini-3.1-flash-tts-preview` and later stream; earlier TTS models reject `streamGenerateContent`.
+    path: ({ request }) => GeminiGenerateContent.path(request.model.id, request.mode),
+}, input);
+export const GoogleSpeech = {
+    protocol,
+    model,
+};

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

@@ -0,0 +1,174 @@
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
+import { TranscriptionModel, type TranscriptionRequestFor, type TranscriptionSegment, type TranscriptionWord } from "../transcription.js";
+import { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
+export declare const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+/**
+ * Merged into `generationConfig`. The API rejects `customVocabulary` and `mode: "SMART"` alongside diarization or word
+ * timestamps.
+ */
+export type GoogleTranscriptionOptions = {
+    readonly audioTranscriptionConfig?: {
+        readonly mode?: OpenString<"VERBATIM" | "SMART">;
+        readonly customVocabulary?: ReadonlyArray<string>;
+        readonly languageCodes?: ReadonlyArray<string>;
+    };
+} & Record<string, unknown>;
+export type Request = TranscriptionRequestFor<GoogleTranscriptionOptions>;
+interface State extends GeminiGenerateContent.Metadata {
+    readonly text: string;
+    readonly segments: Array<TranscriptionSegment>;
+    readonly words: Array<TranscriptionWord>;
+}
+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;
+}, string, State>;
+export declare const model: (input: MediaRoute.ModelInput) => TranscriptionModel<GoogleTranscriptionOptions>;
+export declare const GoogleTranscription: {
+    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;
+    }, string, State>;
+    readonly model: (input: MediaRoute.ModelInput) => TranscriptionModel<GoogleTranscriptionOptions>;
+};
+export {};

package/dist/protocols/google-transcription.js

@@ -0,0 +1,126 @@
+import { Effect, Schema, SchemaGetter } from "effect";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { mergeJsonRecords } from "../schema/index.js";
+import { TranscriptionFinishEvent, TranscriptionModel, TranscriptionSegmentEvent, TranscriptionTextDeltaEvent, } from "../transcription.js";
+import { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
+const route = MediaProtocol.identity({ id: "google-transcription", name: "Google Transcription", provider: "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 = route.decodeFrame(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* route.unsupported("transcription.model", `${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(route.id, 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(route.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(route.incomplete());
+    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(route, {
+    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({
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    path: ({ request }) => GeminiGenerateContent.path(request.model.id, request.mode),
+}, input);
+export const GoogleTranscription = {
+    protocol,
+    model,
+};

package/dist/protocols/google-video.d.ts

@@ -0,0 +1,26 @@
+import { Schema } from "effect";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { type OpenString } from "../schema/index.js";
+import { VideoModel, VideoResponse, type VideoRequestFor } from "../video.js";
+export declare const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+/** Provider-native `parameters`. Common fields (`aspectRatio`, `resolution`, `durationSeconds`, `seed`) live on the request. */
+export type GoogleVideoOptions = {
+    readonly personGeneration?: OpenString<"allow_all" | "allow_adult" | "dont_allow">;
+} & Record<string, unknown>;
+export type Request = VideoRequestFor<GoogleVideoOptions>;
+/** The long-running operation name, e.g. `models/veo-3.1-generate-preview/operations/abc123`. */
+export declare const Token: Schema.Struct<{
+    readonly operation: Schema.String;
+}>;
+export type Token = Schema.Schema.Type<typeof Token>;
+export declare const protocol: MediaProtocol.Queued<Request, VideoResponse, {
+    readonly operation: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => VideoModel<GoogleVideoOptions>;
+export declare const GoogleVideo: {
+    readonly protocol: MediaProtocol.Queued<Request, VideoResponse, {
+        readonly operation: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => VideoModel<GoogleVideoOptions>;
+};