@opencode/ai 2.0.14 → 2.0.16

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

@@ -0,0 +1,173 @@
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.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?: "VERBATIM" | "SMART" | (string & {});
+        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,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/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 { VideoModel, VideoResponse, type VideoRequestFor } from "../video.js";
+export declare const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+export type GoogleVideoString<Known extends string> = Known | (string & {});
+/** Provider-native `parameters`. Common fields (`aspectRatio`, `resolution`, `durationSeconds`, `seed`) live on the request. */
+export type GoogleVideoOptions = {
+    readonly personGeneration?: GoogleVideoString<"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>;
+};

package/dist/protocols/google-video.js

@@ -0,0 +1,158 @@
+import { Duration, 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, optionalArray } from "./shared.js";
+const ADAPTER = "google-video";
+const NAME = "Google Veo";
+const PROVIDER = ProviderID.make("google");
+export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+/** Veo keeps generated files for two days; the asset carries that deadline so callers materialize in time. */
+const FILE_RETENTION = Duration.days(2);
+// ---------------------------------------------------------------------------
+// 2. Token and response schemas
+// ---------------------------------------------------------------------------
+/** The long-running operation name, e.g. `models/veo-3.1-generate-preview/operations/abc123`. */
+export const Token = Schema.Struct({ operation: Schema.String });
+const StartResponse = Schema.Struct({ name: Schema.String });
+const Operation = Schema.Struct({
+    done: Schema.optional(Schema.Boolean),
+    error: Schema.optional(Schema.Struct({ message: Schema.optional(Schema.String) })),
+    response: Schema.optional(Schema.Struct({
+        generateVideoResponse: Schema.optional(Schema.Struct({
+            generatedSamples: optionalArray(Schema.Struct({
+                video: Schema.optional(Schema.Struct({
+                    uri: Schema.optional(Schema.String),
+                    mimeType: Schema.optional(Schema.String),
+                })),
+            })),
+            raiMediaFilteredCount: Schema.optional(Schema.Number),
+            raiMediaFilteredReasons: optionalArray(Schema.String),
+        })),
+    })),
+    metadata: Schema.optional(Schema.Unknown),
+});
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+// Veo takes inline media only; a prior Veo output is `Media.url` with transient auth, so materialize it first.
+const inlineMedia = (asset) => ProviderShared.requireInlineMedia(NAME, asset).pipe(Effect.map((inline) => ({ inlineData: { mimeType: inline.mime, data: inline.base64 } })));
+const fromRequest = Effect.fn("GoogleVideo.fromRequest")(function* (request) {
+    if (request.n !== undefined && request.n > 1)
+        return yield* ProviderShared.unsupportedOperation({
+            operation: "video.n",
+            provider: PROVIDER,
+            route: ADAPTER,
+            message: `${NAME} generates one video per request; call it once per video instead of n=${request.n}`,
+        });
+    if (request.audio === false)
+        return yield* ProviderShared.unsupportedOperation({
+            operation: "video.audio",
+            provider: PROVIDER,
+            route: ADAPTER,
+            message: `${NAME} always generates audio; audio: false cannot be honored`,
+        });
+    if (request.frames?.last !== undefined && request.frames.first === undefined)
+        return yield* ProviderShared.invalidRequest(`${NAME} requires frames.first when frames.last is set`);
+    const image = request.frames?.first === undefined ? undefined : yield* inlineMedia(request.frames.first);
+    const lastFrame = request.frames?.last === undefined ? undefined : yield* inlineMedia(request.frames.last);
+    const video = request.video === undefined ? undefined : yield* inlineMedia(request.video);
+    const referenceImages = yield* Effect.forEach(request.references ?? [], (asset) => inlineMedia(asset).pipe(Effect.map((image) => ({ image, referenceType: "asset" }))));
+    return MediaProtocol.json(mergeJsonRecords({
+        instances: [
+            {
+                prompt: request.prompt,
+                image,
+                lastFrame,
+                referenceImages: referenceImages.length === 0 ? undefined : referenceImages,
+                video,
+            },
+        ],
+        parameters: mergeJsonRecords({
+            aspectRatio: request.aspectRatio,
+            resolution: request.resolution,
+            durationSeconds: request.durationSeconds,
+            negativePrompt: request.negativePrompt,
+            seed: request.seed,
+        }, request.providerOptions),
+    }, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeStart = MediaProtocol.decodeStarted(ADAPTER, NAME, StartResponse, (value) => ({
+    token: { operation: value.name },
+    snapshot: { id: value.name, status: "running" },
+}));
+// Operations carry no status string: not done is running, done with `error` failed, otherwise completed.
+const statusOf = (operation) => {
+    if (operation.done !== true)
+        return "running";
+    return operation.error === undefined ? "completed" : "failed";
+};
+const decodeOperation = MediaProtocol.decodeJson(ADAPTER, NAME, Operation);
+const decodeStatus = Effect.fn("GoogleVideo.decodeStatus")(function* (response, context) {
+    const output = yield* decodeOperation(response);
+    return { id: context.token.operation, status: statusOf(output.value) };
+});
+const decodeResult = Effect.fn("GoogleVideo.decodeResult")(function* (response, context) {
+    const output = yield* decodeOperation(response);
+    const operation = output.value;
+    const status = statusOf(operation);
+    if (status === "running")
+        return yield* output.invalid(`${NAME} operation ${context.token.operation} has not finished`);
+    if (status === "failed")
+        return yield* output.ended("failed", `${NAME} operation failed${operation.error?.message === undefined ? "" : `: ${operation.error.message}`}`);
+    const generated = operation.response?.generateVideoResponse;
+    // Downloads require the same API key as the poll; the asset carries it transiently and follows the redirect.
+    const videos = yield* Effect.forEach((generated?.generatedSamples ?? []).flatMap((sample) => sample.video?.uri === undefined ? [] : [{ uri: sample.video.uri, mimeType: sample.video.mimeType }]), (video) => MediaProtocol.expiringUrl(video.uri, FILE_RETENTION, {
+        mediaType: video.mimeType ?? "video/mp4",
+        headers: context.auth,
+    }));
+    const reasons = generated?.raiMediaFilteredReasons ?? [];
+    const notices = reasons.map((reason) => ({
+        type: "filtered",
+        message: `${NAME} filtered media: ${reason}`,
+        providerMetadata: { google: { raiMediaFilteredReason: reason } },
+    }));
+    if (videos.length === 0 && (reasons.length > 0 || (generated?.raiMediaFilteredCount ?? 0) > 0))
+        return yield* output.contentPolicy(`${NAME} filtered every video${reasons.length === 0 ? "" : `: ${reasons.join("; ")}`}`);
+    if (videos.length === 0)
+        return yield* output.invalid(`${NAME} operation completed without any video`);
+    return new VideoResponse({
+        videos,
+        notices: notices.length === 0 ? undefined : notices,
+        providerMetadata: {
+            google: {
+                operation: context.token.operation,
+                raiMediaFilteredCount: generated?.raiMediaFilteredCount,
+                metadata: operation.metadata,
+            },
+        },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+const operationPath = (token) => `/${token.operation}`;
+export const protocol = MediaProtocol.queued({
+    id: ADAPTER,
+    name: NAME,
+    token: Token,
+    start: { body: { from: fromRequest }, decode: decodeStart },
+    status: { path: operationPath, decode: decodeStatus },
+    result: { path: operationPath, decode: decodeResult },
+});
+export const model = (input) => VideoModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    path: ({ request }) => `/models/${request.model.id}:predictLongRunning`,
+}, input);
+export const GoogleVideo = {
+    protocol,
+    model,
+};

package/dist/protocols/meta-images.d.ts

@@ -1,12 +1,9 @@
-import { ImageModel } from "../image.js";
-import { Auth } from "../route/auth.js";
-import { type HttpOptions } from "../schema/index.js";
+import { ImageModel, ImageResponse, type ImageRequestFor } from "../image.js";
+import { MediaProtocol } from "../route/media-protocol.js";
+import { MediaRoute } from "../route/media.js";
 type OpenString<Known extends string> = Known | (string & {});
+/** Provider-native options. Common fields (`n`, `size`, `format`, `images`) live on the request. */
 export type ImageOptions = {
-    readonly n?: number;
-    /** Aspect ratio hint, not an exact output resolution. */
-    readonly size?: string;
-    readonly outputFormat?: OpenString<"webp" | "png" | "jpeg">;
     readonly responseFormat?: OpenString<"b64_json" | "url">;
     readonly reasoningStrength?: OpenString<"low" | "high">;
     readonly toolEnablement?: {
@@ -16,11 +13,9 @@ export type ImageOptions = {
     };
     readonly [key: string]: unknown;
 };
-export declare const model: (input: {
-    readonly id: string;
-    readonly auth: Auth.Definition;
+export type Request = ImageRequestFor<ImageOptions>;
+export declare const protocol: MediaProtocol.Inline<Request, ImageResponse>;
+export declare const model: (input: MediaRoute.ModelInput & {
     readonly baseURL: string;
-    readonly headers?: Record<string, string>;
-    readonly http?: HttpOptions;
 }) => ImageModel<ImageOptions>;
 export * as MetaImages from "./meta-images.js";