@opencode/ai 2.0.15 → 2.0.16

package/dist/protocols/fal-images.js

@@ -0,0 +1,114 @@
+import { Effect, Schema } from "effect";
+import { ImageModel, ImageResponse } from "../image.js";
+import { Media } from "../media.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { ProviderShared, optionalNull } from "./shared.js";
+import { FalQueue } from "./utils/fal-queue.js";
+import { MediaInput } from "./utils/media-input.js";
+const ADAPTER = "fal-images";
+const NAME = "fal Images";
+const PROVIDER = ProviderID.make("fal");
+// ---------------------------------------------------------------------------
+// 2. Response schema
+// ---------------------------------------------------------------------------
+const QueueResult = Schema.StructWithRest(Schema.Struct({
+    images: Schema.Array(Schema.Struct({
+        url: Schema.String,
+        width: optionalNull(Schema.Number),
+        height: optionalNull(Schema.Number),
+        content_type: optionalNull(Schema.String),
+    })),
+    seed: optionalNull(Schema.Number),
+    has_nsfw_concepts: optionalNull(Schema.Array(Schema.Boolean)),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const sizing = (model) => {
+    if (/^fal-ai\/(nano-banana|flux-pro\/v1\.1-ultra)/.test(model))
+        return "aspect_ratio";
+    if (model.startsWith("fal-ai/flux"))
+        return "image_size";
+    return undefined;
+};
+const unsupported = (model, field, message) => ProviderShared.unsupportedOperation({
+    operation: `media.${field}`,
+    provider: PROVIDER,
+    route: ADAPTER,
+    message: `${model} ${message}`,
+});
+const validate = (request) => {
+    const id = request.model.id;
+    const field = sizing(id);
+    if (request.size !== undefined && request.aspectRatio !== undefined)
+        return Effect.fail(ProviderShared.invalidRequest(`${NAME} accepts either size or aspectRatio, not both`));
+    if (request.size !== undefined && field === "aspect_ratio")
+        return Effect.fail(unsupported(id, "size", "sizes by aspectRatio"));
+    if (request.aspectRatio !== undefined && field === "image_size")
+        return Effect.fail(unsupported(id, "aspectRatio", "sizes by size (image_size)"));
+    if ((request.images?.length ?? 0) > 1 && !isEdit(id))
+        return Effect.fail(unsupported(id, "images", "takes one image_url; use an /edit endpoint for several images"));
+    return Effect.void;
+};
+// `/edit` endpoints take an `image_urls` list; image-to-image, fill, and Ultra take one `image_url` (beside `mask_url`).
+const isEdit = (model) => model.endsWith("/edit");
+const fromRequest = Effect.fn("FalImages.fromRequest")(function* (request) {
+    yield* validate(request);
+    const images = yield* Effect.forEach(request.images ?? [], (image) => FalQueue.mediaUrl(image, NAME));
+    const edit = isEdit(request.model.id);
+    return MediaProtocol.json(mergeJsonRecords({
+        prompt: request.prompt,
+        num_images: request.n,
+        seed: request.seed,
+        image_size: request.size === undefined ? undefined : MediaInput.dimensions(request.size),
+        aspect_ratio: request.aspectRatio,
+        output_format: request.format,
+        image_urls: edit && images.length > 0 ? images : undefined,
+        image_url: edit ? undefined : images[0],
+        mask_url: request.mask === undefined ? undefined : yield* FalQueue.mediaUrl(request.mask, NAME),
+    }, request.providerOptions, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeQueueResult = MediaProtocol.decodeJson(ADAPTER, NAME, QueueResult);
+const decodeResult = Effect.fn("FalImages.decodeResult")(function* (response, context) {
+    const output = yield* decodeQueueResult(response);
+    const { images, seed, has_nsfw_concepts, ...rest } = output.value;
+    if (images.length === 0)
+        return yield* output.invalid(`${NAME} returned no images`);
+    // With the safety checker on, flagged images come back blacked out rather than omitted.
+    const flagged = (has_nsfw_concepts ?? []).flatMap((value, index) => (value ? [index] : []));
+    return new ImageResponse({
+        images: images.map((image) => Media.url(image.url, {
+            mediaType: image.content_type ?? undefined,
+            info: { width: image.width ?? undefined, height: image.height ?? undefined },
+        })),
+        notices: flagged.length === 0
+            ? undefined
+            : flagged.map((index) => ({ type: "moderated", message: `${NAME} flagged image ${index} as NSFW` })),
+        providerMetadata: { fal: { requestId: context.token.requestID, seed: seed ?? undefined, ...rest } },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = FalQueue.protocol({
+    id: ADAPTER,
+    name: NAME,
+    from: fromRequest,
+    decodeResult,
+});
+export const model = (input) => ImageModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: FalQueue.DEFAULT_BASE_URL,
+    path: ({ request }) => `/${request.model.id}`,
+}, input);
+export const FalImages = {
+    protocol,
+    model,
+};

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

@@ -0,0 +1,29 @@
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { VideoModel, VideoResponse, type VideoRequestFor } from "../video.js";
+export type FalVideoString<Known extends string> = Known | (string & {});
+/**
+ * Provider-native input. fal video endpoints are model-specific: `duration` is a string enum whose values differ per
+ * model (`"8s"` for Veo, `"5"` for Kling), and last-frame fields are named per model (`end_image_url`,
+ * `last_frame_url`, `tail_image_url`), so those pass through here instead of lowering from common fields.
+ */
+export type FalVideoOptions = {
+    readonly duration?: FalVideoString<"4s" | "6s" | "8s" | "5" | "10">;
+} & Record<string, unknown>;
+export type Request = VideoRequestFor<FalVideoOptions>;
+export declare const protocol: MediaProtocol.Queued<Request, VideoResponse, {
+    readonly requestID: string;
+    readonly statusURL: string;
+    readonly responseURL: string;
+    readonly cancelURL: string;
+}>;
+export declare const model: (input: MediaRoute.ModelInput) => VideoModel<FalVideoOptions>;
+export declare const FalVideo: {
+    readonly protocol: MediaProtocol.Queued<Request, VideoResponse, {
+        readonly requestID: string;
+        readonly statusURL: string;
+        readonly responseURL: string;
+        readonly cancelURL: string;
+    }>;
+    readonly model: (input: MediaRoute.ModelInput) => VideoModel<FalVideoOptions>;
+};

package/dist/protocols/fal-video.js

@@ -0,0 +1,88 @@
+import { Effect, Schema } from "effect";
+import { Media } from "../media.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, mergeJsonRecords } from "../schema/index.js";
+import { VideoModel, VideoResponse } from "../video.js";
+import { ProviderShared, optionalNull } from "./shared.js";
+import { FalQueue } from "./utils/fal-queue.js";
+const ADAPTER = "fal-video";
+const NAME = "fal Video";
+const PROVIDER = ProviderID.make("fal");
+// ---------------------------------------------------------------------------
+// 2. Response schema
+// ---------------------------------------------------------------------------
+const QueueResult = Schema.StructWithRest(Schema.Struct({
+    video: Schema.Struct({
+        url: Schema.String,
+        content_type: optionalNull(Schema.String),
+        file_name: optionalNull(Schema.String),
+        file_size: optionalNull(Schema.Number),
+    }),
+    seed: optionalNull(Schema.Number),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const fromRequest = Effect.fn("FalVideo.fromRequest")(function* (request) {
+    if (request.frames?.last !== undefined)
+        return yield* ProviderShared.unsupportedOperation({
+            operation: "video.frames.last",
+            provider: PROVIDER,
+            route: ADAPTER,
+            message: `${NAME} names the last frame per model; pass it through providerOptions (e.g. end_image_url) instead of frames.last`,
+        });
+    const imageUrl = request.frames?.first === undefined ? undefined : yield* FalQueue.mediaUrl(request.frames.first, NAME);
+    const videoUrl = request.video === undefined ? undefined : yield* FalQueue.mediaUrl(request.video, NAME);
+    return MediaProtocol.json(mergeJsonRecords({
+        prompt: request.prompt,
+        negative_prompt: request.negativePrompt,
+        seed: request.seed,
+        aspect_ratio: request.aspectRatio,
+        resolution: request.resolution,
+        generate_audio: request.audio,
+        image_url: imageUrl,
+        video_url: videoUrl,
+    }, request.providerOptions, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeQueueResult = MediaProtocol.decodeJson(ADAPTER, NAME, QueueResult);
+const decodeResult = Effect.fn("FalVideo.decodeResult")(function* (response, context) {
+    const output = yield* decodeQueueResult(response);
+    const { video, seed, ...rest } = output.value;
+    return new VideoResponse({
+        videos: [Media.url(video.url, { mediaType: video.content_type ?? "video/mp4" })],
+        providerMetadata: {
+            fal: {
+                requestId: context.token.requestID,
+                seed: seed ?? undefined,
+                fileName: video.file_name ?? undefined,
+                fileSize: video.file_size ?? undefined,
+                ...rest,
+            },
+        },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = FalQueue.protocol({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["n", "durationSeconds", "references"],
+    from: fromRequest,
+    decodeResult,
+});
+export const model = (input) => VideoModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: FalQueue.DEFAULT_BASE_URL,
+    path: ({ request }) => `/${request.model.id}`,
+}, input);
+export const FalVideo = {
+    protocol,
+    model,
+};

package/dist/protocols/gemini.d.ts

@@ -76,7 +76,7 @@ declare const GeminiBody: Schema.Struct<{
         readonly functionDeclarations: Schema.$Array<Schema.Struct<{
             readonly name: Schema.String;
             readonly description: Schema.String;
-            readonly parameters: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+            readonly parametersJsonSchema: Schema.$Record<Schema.String, Schema.Unknown>;
         }>>;
     }>>>;
     toolConfig: Schema.optional<Schema.Struct<{
@@ -148,11 +148,11 @@ export declare const protocol: Protocol<{
     }[];
     readonly tools?: readonly {
         readonly functionDeclarations: readonly {
-            readonly description: string;
             readonly name: string;
-            readonly parameters?: {
+            readonly description: string;
+            readonly parametersJsonSchema: {
                 readonly [x: string]: unknown;
-            } | undefined;
+            };
         }[];
     }[] | undefined;
     readonly serviceTier?: string | undefined;
@@ -206,11 +206,11 @@ export declare const protocol: Protocol<{
         readonly safetyRatings?: unknown;
     } | null | undefined;
     readonly usageMetadata?: {
-        readonly cachedContentTokenCount?: number | null | undefined;
-        readonly thoughtsTokenCount?: number | null | undefined;
         readonly promptTokenCount?: number | null | undefined;
         readonly candidatesTokenCount?: number | null | undefined;
         readonly totalTokenCount?: number | null | undefined;
+        readonly cachedContentTokenCount?: number | null | undefined;
+        readonly thoughtsTokenCount?: number | null | undefined;
     } | null | undefined;
 }, {
     route: string;
@@ -262,11 +262,11 @@ export declare const route: Route<{
     }[];
     readonly tools?: readonly {
         readonly functionDeclarations: readonly {
-            readonly description: string;
             readonly name: string;
-            readonly parameters?: {
+            readonly description: string;
+            readonly parametersJsonSchema: {
                 readonly [x: string]: unknown;
-            } | undefined;
+            };
         }[];
     }[] | undefined;
     readonly serviceTier?: string | undefined;

package/dist/protocols/gemini.js

@@ -9,7 +9,7 @@ import { AIError, LLMEvent, Usage, } from "../schema/index.js";
 import { classifyProviderFailure } from "../provider-error.js";
 import { Media } from "../media.js";
 import { JsonObject, knownString, lenient, optionalArray, optionalNull, ProviderShared } from "./shared.js";
-import { GeminiToolSchema } from "./utils/gemini-tool-schema.js";
+import { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolSchemaProjection } from "./utils/tool-schema.js";
 const ADAPTER = "gemini";
@@ -102,7 +102,7 @@ const GeminiSystemInstruction = Schema.Struct({
 const GeminiFunctionDeclaration = Schema.Struct({
     name: Schema.String,
     description: Schema.String,
-    parameters: Schema.optional(JsonObject),
+    parametersJsonSchema: JsonObject,
 });
 const GeminiTool = Schema.Struct({
     functionDeclarations: Schema.Array(GeminiFunctionDeclaration),
@@ -186,34 +186,14 @@ const GeminiEvent = Schema.Struct({
     usageMetadata: optionalNull(GeminiUsage),
 });
 // =============================================================================
-// Tool Schema Conversion
-// =============================================================================
-// Tool-schema conversion has two distinct concerns:
-//
-// 1. Sanitize — fix common authoring mistakes Gemini rejects: integer/number
-//    enums (must be strings), `required` entries that don't match a property,
-//    untyped arrays (`items` must be present), and `properties`/`required`
-//    keys on non-object scalars. Mirrors OpenCode's historical Gemini rules.
-//
-// 2. Project — lossy mapping from JSON Schema to Gemini's schema dialect:
-//    drop empty root parameter schemas while preserving nested empty objects,
-//    expand type arrays into `anyOf`, derive `nullable: true` from null members,
-//    coerce `const` to `[const]` enum, recurse properties/items, and propagate
-//    only an allowlisted set of keys (description, required, format, type,
-//    nullable, enum, properties, items, allOf, anyOf, oneOf, minLength).
-//    Anything outside the allowlist (e.g. `additionalProperties`, `$ref`) is
-//    silently dropped.
-//
-// Sanitize runs first, then project. The implementation lives in
-// `utils/gemini-tool-schema` so this protocol keeps the same shape as the other
-// provider protocols.
-// =============================================================================
 // Request Lowering
 // =============================================================================
-const lowerTool = (tool, inputSchema) => ({
+// Tool schemas go in `parametersJsonSchema`, which accepts standard JSON Schema. Gemini's schema
+// rules are this API's default, including for tuned endpoints whose IDs do not name Gemini.
+const lowerTool = (tool, model) => ({
     name: tool.name,
     description: tool.description,
-    parameters: GeminiToolSchema.convert(inputSchema),
+    parametersJsonSchema: ToolSchemaProjection.modelCompatibility(tool.inputSchema, model, "gemini"),
 });
 const lowerToolConfig = (toolChoice) => ProviderShared.matchToolChoice("Gemini", toolChoice, {
     auto: () => ({ functionCallingConfig: { mode: "AUTO" } }),
@@ -221,15 +201,10 @@ const lowerToolConfig = (toolChoice) => ProviderShared.matchToolChoice("Gemini",
     required: () => ({ functionCallingConfig: { mode: "ANY" } }),
     tool: (name) => ({ functionCallingConfig: { mode: "ANY", allowedFunctionNames: [name] } }),
 });
-// Gemini does not fetch public URLs; inline payloads and Gemini Files references are the accepted inputs.
 const lowerContentPart = Effect.fn("Gemini.lowerContentPart")(function* (part) {
     if (part.type === "text")
         return { text: part.text };
-    const source = part.media.source;
-    if (source.type === "ref" && source.provider === "google")
-        return { fileData: { mimeType: part.media.mediaType, fileUri: source.id } };
-    const media = yield* ProviderShared.requireInlineMedia("Gemini", part.media);
-    return { inlineData: { mimeType: media.mime, data: media.base64 } };
+    return yield* GeminiGenerateContent.mediaPart("Gemini", part.media);
 });
 const providerMetadata = (key, metadata) => ({ [key]: metadata });
 const thoughtSignature = (metadata, key) => {
@@ -382,7 +357,6 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request) {
     const hasTools = flattened.tools.length > 0;
     const generation = request.generation;
     const options = yield* decodeOptions(request.providerOptions ?? {});
-    const toolSchemaCompatibility = request.model.compatibility?.toolSchema;
     const generationConfig = {
         maxOutputTokens: generation?.maxTokens,
         temperature: generation?.temperature,
@@ -405,7 +379,7 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request) {
         tools: hasTools
             ? [
                 {
-                    functionDeclarations: flattened.tools.map((tool) => lowerTool(tool, ToolSchemaProjection.modelCompatibility(tool.inputSchema, toolSchemaCompatibility))),
+                    functionDeclarations: flattened.tools.map((tool) => lowerTool(tool, request.model)),
                 },
             ]
             : undefined,

package/dist/protocols/google-images.js

@@ -1,10 +1,10 @@
 import { Effect, Schema } from "effect";
 import { ImageModel, ImageResponse } from "../image.js";
-import { Media } from "../media.js";
 import { MediaProtocol } from "../route/media-protocol.js";
 import { MediaRoute } from "../route/media.js";
 import { ProviderID, mergeJsonRecords } from "../schema/index.js";
 import { ProviderShared } from "./shared.js";
+import { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
 import { MediaInput } from "./utils/media-input.js";
 const ADAPTER = "google-images";
 const NAME = "Google Images";
@@ -61,18 +61,6 @@ const generationConfig = (request) => {
         thinkingConfig: Object.values(thinkingConfig).some((value) => value !== undefined) ? thinkingConfig : undefined,
     }, native) ?? { responseModalities: ["IMAGE"] });
 };
-// Gemini does not fetch public URLs; inline payloads or Gemini Files references are the only accepted inputs.
-const imagePart = (asset) => {
-    const inline = asset.inline();
-    if (inline)
-        return Effect.succeed({ inlineData: { mimeType: inline.mime, data: inline.base64 } });
-    const id = MediaInput.refID(asset, PROVIDER);
-    if (id)
-        return Effect.succeed({ fileData: { mimeType: asset.mediaType, fileUri: id } });
-    if (asset.source.type === "ref")
-        return Effect.fail(ProviderShared.invalidRequest("Google generateContent requires Gemini file references rather than other providers' file IDs"));
-    return Effect.fail(ProviderShared.invalidRequest("Google generateContent does not fetch public image URLs; use bytes, a data URL, or a Gemini file reference"));
-};
 const fromRequest = Effect.fn("GoogleImages.fromRequest")(function* (request) {
     if (request.n !== undefined && request.n > 1)
         return yield* ProviderShared.unsupportedOperation({
@@ -81,7 +69,7 @@ const fromRequest = Effect.fn("GoogleImages.fromRequest")(function* (request) {
             route: ADAPTER,
             message: `${NAME} generates one image per request; call it once per image instead of n=${request.n}`,
         });
-    const parts = yield* Effect.forEach(request.images ?? [], imagePart);
+    const parts = yield* Effect.forEach(request.images ?? [], (image) => GeminiGenerateContent.mediaPart(NAME, image));
     return MediaProtocol.json(mergeJsonRecords({
         contents: [{ role: "user", parts: [{ text: request.prompt }, ...parts] }],
         generationConfig: generationConfig(request),

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

@@ -0,0 +1,130 @@
+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 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 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,84 @@
+import { Effect, Schema } from "effect";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
+import { ProviderID, 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 ADAPTER = "google-speech";
+const NAME = "Google Speech";
+const PROVIDER = ProviderID.make("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 = MediaProtocol.decodeFrame(ADAPTER, NAME, GenerateContentChunk);
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const fromRequest = Effect.fn("GoogleSpeech.fromRequest")(function* (request) {
+    if (request.format !== undefined && request.format !== "pcm")
+        return yield* SpeechStream.unsupportedFormat(PROVIDER, ADAPTER, `${NAME} only returns raw PCM; request format "pcm" or omit it, then wrap the samples yourself`);
+    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(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) => {
+    const sampleRate = SpeechStream.sampleRate(state.mimeType) ?? DEFAULT_SAMPLE_RATE;
+    return SpeechStream.finish(ADAPTER, state, {
+        ...SpeechStream.pcm("pcm_s16le", sampleRate, state.mimeType ?? `audio/L16;codec=pcm;rate=${sampleRate}`),
+        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({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["instructions", "speed", "timestamps"],
+    body: { from: fromRequest },
+    frames: (bytes, context) => GeminiGenerateContent.frames(bytes, context.request.mode),
+    initial: () => ({ chunks: [] }),
+    step,
+    finish,
+});
+export const model = (input) => SpeechModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    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,
+};