@opencode/ai 2.0.14 → 2.0.15

package/dist/protocols/bedrock-converse.d.ts

@@ -157,7 +157,7 @@ export declare const protocol: Protocol<{
             };
         } | {
             readonly document: {
-                readonly format: "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md";
+                readonly format: "pdf" | "txt" | "md" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html";
                 readonly name: string;
                 readonly source: {
                     readonly bytes: string;
@@ -176,7 +176,7 @@ export declare const protocol: Protocol<{
                     };
                 } | {
                     readonly document: {
-                        readonly format: "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md";
+                        readonly format: "pdf" | "txt" | "md" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html";
                         readonly name: string;
                         readonly source: {
                             readonly bytes: string;
@@ -386,7 +386,7 @@ export declare const route: Route<{
             };
         } | {
             readonly document: {
-                readonly format: "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md";
+                readonly format: "pdf" | "txt" | "md" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html";
                 readonly name: string;
                 readonly source: {
                     readonly bytes: string;
@@ -405,7 +405,7 @@ export declare const route: Route<{
                     };
                 } | {
                     readonly document: {
-                        readonly format: "pdf" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html" | "txt" | "md";
+                        readonly format: "pdf" | "txt" | "md" | "csv" | "doc" | "docx" | "xls" | "xlsx" | "html";
                         readonly name: string;
                         readonly source: {
                             readonly bytes: string;

package/dist/protocols/bedrock-converse.js

@@ -221,12 +221,7 @@ const lowerToolResultContent = Effect.fn("BedrockConverse.lowerToolResultContent
             content.push({ text: item.text });
             continue;
         }
-        const media = yield* BedrockMedia.lower({
-            type: "media",
-            mediaType: item.mime,
-            data: item.uri,
-            filename: item.name,
-        }, documentNames);
+        const media = yield* BedrockMedia.lower(ProviderShared.toolFileMedia(item), documentNames);
         content.push(...media);
     }
     return content;

package/dist/protocols/gemini.d.ts

@@ -33,6 +33,12 @@ declare const GeminiBody: Schema.Struct<{
                 readonly mimeType: Schema.String;
                 readonly data: Schema.String;
             }>;
+            readonly thoughtSignature: Schema.optional<Schema.NullOr<Schema.String>>;
+        }>, Schema.Struct<{
+            readonly fileData: Schema.Struct<{
+                readonly mimeType: Schema.String;
+                readonly fileUri: Schema.String;
+            }>;
         }>, Schema.Struct<{
             readonly functionCall: Schema.Struct<{
                 readonly id: Schema.optional<Schema.NullOr<Schema.String>>;
@@ -50,6 +56,7 @@ declare const GeminiBody: Schema.Struct<{
                         readonly mimeType: Schema.String;
                         readonly data: Schema.String;
                     }>;
+                    readonly thoughtSignature: Schema.optional<Schema.NullOr<Schema.String>>;
                 }>>>;
             }>;
         }>]>>>>;
@@ -106,10 +113,16 @@ export declare const protocol: Protocol<{
                 readonly mimeType: string;
                 readonly data: string;
             };
+            readonly thoughtSignature?: string | null | undefined;
         } | {
             readonly text: string;
             readonly thought?: boolean | null | undefined;
             readonly thoughtSignature?: string | null | undefined;
+        } | {
+            readonly fileData: {
+                readonly mimeType: string;
+                readonly fileUri: string;
+            };
         } | {
             readonly functionCall: {
                 readonly name: string;
@@ -127,6 +140,7 @@ export declare const protocol: Protocol<{
                         readonly mimeType: string;
                         readonly data: string;
                     };
+                    readonly thoughtSignature?: string | null | undefined;
                 }[] | undefined;
             };
         })[] | null | undefined;
@@ -213,10 +227,16 @@ export declare const route: Route<{
                 readonly mimeType: string;
                 readonly data: string;
             };
+            readonly thoughtSignature?: string | null | undefined;
         } | {
             readonly text: string;
             readonly thought?: boolean | null | undefined;
             readonly thoughtSignature?: string | null | undefined;
+        } | {
+            readonly fileData: {
+                readonly mimeType: string;
+                readonly fileUri: string;
+            };
         } | {
             readonly functionCall: {
                 readonly name: string;
@@ -234,6 +254,7 @@ export declare const route: Route<{
                         readonly mimeType: string;
                         readonly data: string;
                     };
+                    readonly thoughtSignature?: string | null | undefined;
                 }[] | undefined;
             };
         })[] | null | undefined;

package/dist/protocols/gemini.js

@@ -7,6 +7,7 @@ import { Framing } from "../route/framing.js";
 import { Protocol } from "../route/protocol.js";
 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 { Lifecycle } from "./utils/lifecycle.js";
@@ -54,6 +55,14 @@ const GeminiInlineDataPart = Schema.Struct({
         mimeType: Schema.String,
         data: Schema.String,
     }),
+    thoughtSignature: optionalNull(Schema.String),
+});
+/** Gemini Files API reference; the only remote input Gemini accepts. */
+const GeminiFileDataPart = Schema.Struct({
+    fileData: Schema.Struct({
+        mimeType: Schema.String,
+        fileUri: Schema.String,
+    }),
 });
 const GeminiFunctionCallPart = Schema.Struct({
     functionCall: Schema.Struct({
@@ -74,6 +83,7 @@ const GeminiFunctionResponsePart = Schema.Struct({
 const GeminiContentPart = Schema.Union([
     GeminiTextPart,
     GeminiInlineDataPart,
+    GeminiFileDataPart,
     GeminiFunctionCallPart,
     GeminiFunctionResponsePart,
 ]);
@@ -211,10 +221,14 @@ const lowerToolConfig = (toolChoice) => ProviderShared.matchToolChoice("Gemini",
     required: () => ({ functionCallingConfig: { mode: "ANY" } }),
     tool: (name) => ({ functionCallingConfig: { mode: "ANY", allowedFunctionNames: [name] } }),
 });
-const lowerUserPart = Effect.fn("Gemini.lowerUserPart")(function* (part) {
+// 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 media = ProviderShared.normalizeMedia(part);
+    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 } };
 });
 const providerMetadata = (key, metadata) => ({ [key]: metadata });
@@ -259,7 +273,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
             for (const part of message.content) {
                 if (!ProviderShared.supportsContent(part, ["text", "media"]))
                     return yield* ProviderShared.unsupportedContent("Gemini", "user", ["text", "media"]);
-                parts.push(yield* lowerUserPart(part));
+                parts.push(yield* lowerContentPart(part));
             }
             contents.push({ role: "user", parts });
             continue;
@@ -269,12 +283,23 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
             // Parallel Gemini 3 calls may carry one signature on the first call; unsigned sibling calls are valid.
             let hasSignedToolCall = false;
             for (const part of message.content) {
-                if (!ProviderShared.supportsContent(part, ["text", "reasoning", "tool-call"]))
-                    return yield* ProviderShared.unsupportedContent("Gemini", "assistant", ["text", "reasoning", "tool-call"]);
+                if (!ProviderShared.supportsContent(part, ["text", "reasoning", "tool-call", "media"]))
+                    return yield* ProviderShared.unsupportedContent("Gemini", "assistant", [
+                        "text",
+                        "reasoning",
+                        "tool-call",
+                        "media",
+                    ]);
                 if (part.type === "text") {
                     parts.push({ text: part.text, thoughtSignature: thoughtSignature(part.providerMetadata, metadataKey) });
                     continue;
                 }
+                // Generated images replay as model-role inline data so multi-turn image editing keeps the prior output.
+                if (part.type === "media") {
+                    const lowered = yield* lowerContentPart(part);
+                    parts.push({ ...lowered, thoughtSignature: thoughtSignature(part.providerMetadata, metadataKey) });
+                    continue;
+                }
                 if (part.type === "reasoning") {
                     parts.push({
                         text: part.text,
@@ -324,7 +349,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
             for (const item of content) {
                 if (item.type === "text")
                     continue;
-                const value = ProviderShared.normalizeToolFile(item);
+                const value = yield* ProviderShared.requireInlineMedia("Gemini", ProviderShared.toolFileMedia(item).media);
                 media.push({ inlineData: { mimeType: value.mime, data: value.base64 } });
             }
             if (legacyToolMedia && media.length > 0)
@@ -539,6 +564,17 @@ const step = (state, event) => {
             reasoningSignature = signature;
         else if (signature !== undefined && "text" in part)
             textSignature = signature;
+        // Image-capable Gemini models return generated images as inline data parts; surface them as first-class output.
+        if ("inlineData" in part) {
+            lifecycle = Lifecycle.stepStart(lifecycle, events);
+            events.push(LLMEvent.media({
+                media: Media.base64(part.inlineData.data, part.inlineData.mimeType),
+                providerMetadata: signature
+                    ? providerMetadata(state.providerMetadataKey, { thoughtSignature: signature })
+                    : undefined,
+            }));
+            continue;
+        }
         if ("text" in part && part.text.length > 0) {
             if (part.thought) {
                 if (textId !== undefined) {

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

@@ -1,30 +1,18 @@
-import { ImageModel } from "../image.js";
-import { type Definition as AuthDefinition } 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";
 export declare const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
 export type GoogleImageString<Known extends string> = Known | (string & {});
+/** Provider-native options. Common fields (`aspectRatio`, `seed`, `images`) live on the request. */
 export type GoogleImageOptions = {
-    readonly aspectRatio?: GoogleImageString<"1:1" | "2:3" | "3:2" | "3:4" | "4:3" | "4:5" | "5:4" | "9:16" | "16:9" | "21:9">;
     readonly imageSize?: GoogleImageString<"1K" | "2K" | "4K">;
-    readonly seed?: number;
     readonly thinkingLevel?: GoogleImageString<"MINIMAL" | "LOW" | "MEDIUM" | "HIGH">;
     readonly includeThoughts?: boolean;
 } & Record<string, unknown>;
-export type GoogleImageBody = Record<string, unknown> & {
-    readonly contents: ReadonlyArray<{
-        readonly role: "user";
-        readonly parts: ReadonlyArray<Record<string, unknown>>;
-    }>;
-    readonly generationConfig: Record<string, unknown>;
-};
-export interface ModelInput {
-    readonly id: string;
-    readonly auth: AuthDefinition;
-    readonly baseURL?: string;
-    readonly headers?: Record<string, string>;
-    readonly http?: HttpOptions;
-}
-export declare const model: (input: ModelInput) => ImageModel<GoogleImageOptions>;
+export type Request = ImageRequestFor<GoogleImageOptions>;
+export declare const protocol: MediaProtocol.Inline<Request, ImageResponse>;
+export declare const model: (input: MediaRoute.ModelInput) => ImageModel<GoogleImageOptions>;
 export declare const GoogleImages: {
-    readonly model: (input: ModelInput) => ImageModel<GoogleImageOptions>;
+    readonly protocol: MediaProtocol.Inline<Request, ImageResponse>;
+    readonly model: (input: MediaRoute.ModelInput) => ImageModel<GoogleImageOptions>;
 };

package/dist/protocols/google-images.js

@@ -1,12 +1,18 @@
-import { Effect, Encoding, Schema } from "effect";
-import { Headers, HttpClientRequest } from "effect/unstable/http";
-import { GeneratedImage, ImageModel, ImageResponse, } from "../image.js";
-import { Auth } from "../route/auth.js";
-import { AIError, Usage, mergeHttpOptions, mergeJsonRecords } from "../schema/index.js";
+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 { ImageInputs } from "./utils/image-input.js";
+import { MediaInput } from "./utils/media-input.js";
 const ADAPTER = "google-images";
+const NAME = "Google Images";
+const PROVIDER = ProviderID.make("google");
 export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
+// ---------------------------------------------------------------------------
+// 2. Response schema
+// ---------------------------------------------------------------------------
 const GoogleUsage = Schema.StructWithRest(Schema.Struct({
     cachedContentTokenCount: Schema.optional(Schema.Number),
     thoughtsTokenCount: Schema.optional(Schema.Number),
@@ -41,141 +47,172 @@ const GoogleImageResponse = Schema.Struct({
     responseId: Schema.optional(Schema.String),
     promptFeedback: Schema.optional(Schema.Unknown),
 });
-const nativeOptions = (options) => {
-    const { aspectRatio, imageSize, seed, thinkingLevel, includeThoughts, ...native } = options ?? {};
-    const image = {
-        aspectRatio,
-        imageSize,
-    };
-    const thinkingConfig = {
-        thinkingLevel,
-        includeThoughts,
-    };
+// ---------------------------------------------------------------------------
+// 5. Request body construction
+// ---------------------------------------------------------------------------
+const generationConfig = (request) => {
+    const { imageSize, thinkingLevel, includeThoughts, ...native } = request.providerOptions ?? {};
+    const imageConfig = { aspectRatio: request.aspectRatio, imageSize };
+    const thinkingConfig = { thinkingLevel, includeThoughts };
     return (mergeJsonRecords({
         responseModalities: ["IMAGE"],
-        imageConfig: Object.values(image).some((value) => value !== undefined) ? image : undefined,
-        seed,
+        imageConfig: Object.values(imageConfig).some((value) => value !== undefined) ? imageConfig : undefined,
+        seed: request.seed,
         thinkingConfig: Object.values(thinkingConfig).some((value) => value !== undefined) ? thinkingConfig : undefined,
     }, native) ?? { responseModalities: ["IMAGE"] });
 };
-const applyQuery = (url, query) => {
-    if (!query)
-        return url;
-    const next = new URL(url);
-    Object.entries(query).forEach(([key, value]) => next.searchParams.set(key, value));
-    return next.toString();
+// 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"));
 };
-export const model = (input) => {
-    const route = {
-        id: ADAPTER,
-        generate: Effect.fn("GoogleImages.generate")(function* (request, execute) {
-            const imageParts = yield* Effect.forEach(request.images ?? [], googleImagePart);
-            const http = mergeHttpOptions(request.model.http, request.http);
-            const requestBody = mergeJsonRecords({
-                contents: [{ role: "user", parts: [{ text: request.prompt }, ...imageParts] }],
-                generationConfig: nativeOptions(request.options),
-            }, http?.body);
-            const text = ProviderShared.encodeJson(requestBody);
-            const url = applyQuery(`${(input.baseURL ?? DEFAULT_BASE_URL).replace(/\/$/, "")}/models/${request.model.id}:generateContent`, http?.query);
-            const headers = yield* Auth.toEffect(input.auth)({
-                request,
-                method: "POST",
-                url,
-                body: text,
-                headers: Headers.fromInput({ ...input.headers, ...http?.headers }),
-            });
-            const response = yield* execute(HttpClientRequest.post(url).pipe(HttpClientRequest.setHeaders(headers), HttpClientRequest.bodyText(text, "application/json")));
-            const output = yield* ProviderShared.imageResponse(ADAPTER, "Google Images", response);
-            const decoded = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(GoogleImageResponse))(output.body).pipe(Effect.mapError((cause) => output.invalid("Google Images returned an invalid response", cause)));
-            const candidates = decoded.candidates ?? [];
-            const candidateMetadata = candidates.map((candidate, candidateIndex) => ({
-                index: candidate.index ?? candidateIndex,
-                finishReason: candidate.finishReason,
-                finishMessage: candidate.finishMessage,
-                safetyRatings: candidate.safetyRatings,
-                citationMetadata: candidate.citationMetadata,
-                groundingMetadata: candidate.groundingMetadata,
-                parts: (candidate.content?.parts ?? []).map((part) => part.inlineData === undefined
-                    ? {
-                        type: "text",
-                        text: part.text,
-                        thought: part.thought,
-                        thoughtSignature: part.thoughtSignature,
-                    }
-                    : {
-                        type: "inlineData",
-                        mediaType: part.inlineData.mimeType,
-                        thought: part.thought,
-                        thoughtSignature: part.thoughtSignature,
-                    }),
-            }));
-            const encoded = candidates.flatMap((candidate, candidateIndex) => (candidate.content?.parts ?? []).flatMap((part, partIndex) => part.inlineData === undefined || part.thought === true
-                ? []
-                : [{ candidate, candidateIndex, partIndex, inlineData: part.inlineData }]));
-            const images = yield* Effect.forEach(encoded, (item) => Effect.fromResult(Encoding.decodeBase64(item.inlineData.data)).pipe(Effect.mapError((cause) => output.invalid(`Google Images candidate ${item.candidateIndex} part ${item.partIndex} contains invalid base64 data`, cause)), Effect.map((data) => new GeneratedImage({
-                mediaType: item.inlineData.mimeType,
-                data,
-                providerMetadata: {
-                    google: {
-                        candidateIndex: item.candidate.index ?? item.candidateIndex,
-                        partIndex: item.partIndex,
-                        finishReason: item.candidate.finishReason,
-                        safetyRatings: item.candidate.safetyRatings,
-                        citationMetadata: item.candidate.citationMetadata,
-                        groundingMetadata: item.candidate.groundingMetadata,
-                        thoughtSignature: item.candidate.content?.parts[item.partIndex]?.thoughtSignature,
-                    },
+const fromRequest = Effect.fn("GoogleImages.fromRequest")(function* (request) {
+    if (request.n !== undefined && request.n > 1)
+        return yield* ProviderShared.unsupportedOperation({
+            operation: "image.n",
+            provider: PROVIDER,
+            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);
+    return MediaProtocol.json(mergeJsonRecords({
+        contents: [{ role: "user", parts: [{ text: request.prompt }, ...parts] }],
+        generationConfig: generationConfig(request),
+    }, request.http?.body) ?? {});
+});
+// ---------------------------------------------------------------------------
+// 6. Response decoding
+// ---------------------------------------------------------------------------
+const decodeResponse = Effect.fn("GoogleImages.decodeResponse")(function* (response) {
+    const output = yield* MediaProtocol.decodeJson(ADAPTER, NAME, GoogleImageResponse)(response);
+    const decoded = output.value;
+    const candidates = decoded.candidates ?? [];
+    const candidateMetadata = candidates.map((candidate, candidateIndex) => ({
+        index: candidate.index ?? candidateIndex,
+        finishReason: candidate.finishReason,
+        finishMessage: candidate.finishMessage,
+        safetyRatings: candidate.safetyRatings,
+        citationMetadata: candidate.citationMetadata,
+        groundingMetadata: candidate.groundingMetadata,
+        parts: (candidate.content?.parts ?? []).map((part) => part.inlineData === undefined
+            ? { type: "text", text: part.text, thought: part.thought, thoughtSignature: part.thoughtSignature }
+            : {
+                type: "inlineData",
+                mediaType: part.inlineData.mimeType,
+                thought: part.thought,
+                thoughtSignature: part.thoughtSignature,
+            }),
+    }));
+    // Thought parts are drafts; only non-thought inline data is a final image.
+    const encoded = candidates.flatMap((candidate, candidateIndex) => (candidate.content?.parts ?? []).flatMap((part, partIndex) => part.inlineData === undefined || part.thought === true
+        ? []
+        : [
+            {
+                candidate,
+                candidateIndex,
+                partIndex,
+                inlineData: part.inlineData,
+                thoughtSignature: part.thoughtSignature,
+            },
+        ]));
+    const images = yield* Effect.forEach(encoded, (item) => MediaInput.decodedAsset(output.invalid, `${NAME} candidate ${item.candidateIndex} part ${item.partIndex}`, item.inlineData.data, item.inlineData.mimeType, {
+        providerMetadata: {
+            google: {
+                candidateIndex: item.candidate.index ?? item.candidateIndex,
+                partIndex: item.partIndex,
+                finishReason: item.candidate.finishReason,
+                safetyRatings: item.candidate.safetyRatings,
+                citationMetadata: item.candidate.citationMetadata,
+                groundingMetadata: item.candidate.groundingMetadata,
+                thoughtSignature: item.thoughtSignature,
+            },
+        },
+    }));
+    if (images.length === 0) {
+        const finishReasons = candidates.flatMap((candidate) => candidate.finishReason === undefined ? [] : [candidate.finishReason]);
+        return yield* output.invalid(`${NAME} returned no final images${finishReasons.length === 0 ? "" : ` (finish reasons: ${finishReasons.join(", ")})`}; inspect body for prompt feedback and candidate details`);
+    }
+    // Candidates that stopped for a safety or policy reason are partial results, not a silent drop.
+    const notices = [
+        ...(decoded.promptFeedback === undefined
+            ? []
+            : [
+                {
+                    type: "filtered",
+                    message: `${NAME} reported prompt feedback`,
+                    providerMetadata: { google: { promptFeedback: decoded.promptFeedback } },
                 },
-            }))));
-            if (images.length === 0) {
-                const finishReasons = candidates.flatMap((candidate) => candidate.finishReason === undefined ? [] : [candidate.finishReason]);
-                return yield* output.invalid(`Google Images returned no final images${finishReasons.length === 0 ? "" : ` (finish reasons: ${finishReasons.join(", ")})`}; inspect body for prompt feedback and candidate details`);
-            }
-            const usage = decoded.usageMetadata;
-            const outputTokens = usage?.candidatesTokenCount === undefined
-                ? undefined
-                : usage.candidatesTokenCount + (usage.thoughtsTokenCount ?? 0);
-            return new ImageResponse({
-                images,
-                usage: usage === undefined
-                    ? undefined
-                    : new Usage({
-                        inputTokens: usage.promptTokenCount,
-                        outputTokens,
-                        nonCachedInputTokens: ProviderShared.subtractTokens(usage.promptTokenCount, usage.cachedContentTokenCount),
-                        cacheReadInputTokens: usage.cachedContentTokenCount,
-                        reasoningTokens: usage.thoughtsTokenCount,
-                        totalTokens: ProviderShared.totalTokens(usage.promptTokenCount, outputTokens, usage.totalTokenCount),
-                        providerMetadata: { google: usage },
-                    }),
-                providerMetadata: {
-                    google: {
-                        modelVersion: decoded.modelVersion,
-                        responseId: decoded.responseId,
-                        promptFeedback: decoded.promptFeedback,
-                        candidates: candidateMetadata,
+            ]),
+        ...candidates.flatMap((candidate, index) => candidate.finishReason === undefined || candidate.finishReason === "STOP"
+            ? []
+            : [
+                {
+                    type: "filtered",
+                    message: `${NAME} candidate ${candidate.index ?? index} finished with ${candidate.finishReason}${candidate.finishMessage === undefined ? "" : `: ${candidate.finishMessage}`}`,
+                    providerMetadata: {
+                        google: {
+                            candidateIndex: candidate.index ?? index,
+                            finishReason: candidate.finishReason,
+                            finishMessage: candidate.finishMessage,
+                            safetyRatings: candidate.safetyRatings,
+                        },
                     },
                 },
-            });
-        }),
-    };
-    return ImageModel.make({ id: input.id, provider: "google", route, http: input.http });
-};
-const googleImagePart = (image) => {
-    if (image.type === "bytes")
-        return Effect.succeed({ inlineData: { mimeType: image.mediaType, data: Encoding.encodeBase64(image.data) } });
-    if (image.type === "file-uri")
-        return Effect.succeed({ fileData: { mimeType: image.mediaType, fileUri: image.uri } });
-    if (image.type === "url")
-        return ImageInputs.decodeDataUrl(image.url).pipe(Effect.flatMap((decoded) => {
-            if (decoded === undefined)
-                return Effect.fail(ImageInputs.invalid("Google generateContent does not fetch public image URLs; use bytes, a data URL, or a Gemini file URI"));
-            return Effect.succeed({
-                inlineData: { mimeType: decoded.mediaType, data: Encoding.encodeBase64(decoded.data) },
-            });
-        }));
-    return Effect.fail(ImageInputs.invalid("Google generateContent requires Gemini file URIs rather than provider file IDs"));
-};
+            ]),
+    ];
+    const usage = decoded.usageMetadata;
+    const outputTokens = usage?.candidatesTokenCount === undefined ? undefined : usage.candidatesTokenCount + (usage.thoughtsTokenCount ?? 0);
+    return new ImageResponse({
+        images,
+        notices: notices.length === 0 ? undefined : notices,
+        usage: usage === undefined
+            ? undefined
+            : {
+                type: "tokens",
+                input: usage.promptTokenCount,
+                output: outputTokens,
+                total: ProviderShared.totalTokens(usage.promptTokenCount, outputTokens, usage.totalTokenCount),
+                details: {
+                    reasoningTokens: usage.thoughtsTokenCount,
+                    cacheReadInputTokens: usage.cachedContentTokenCount,
+                    google: usage,
+                },
+            },
+        providerMetadata: {
+            google: {
+                modelVersion: decoded.modelVersion,
+                responseId: decoded.responseId,
+                promptFeedback: decoded.promptFeedback,
+                candidates: candidateMetadata,
+            },
+        },
+    });
+});
+// ---------------------------------------------------------------------------
+// 7. Protocol and route
+// ---------------------------------------------------------------------------
+export const protocol = MediaProtocol.inline({
+    id: ADAPTER,
+    name: NAME,
+    unsupported: ["mask", "size", "format"],
+    body: { from: fromRequest },
+    response: { decode: decodeResponse },
+});
+export const model = (input) => ImageModel.fromRoute({
+    id: ADAPTER,
+    provider: PROVIDER,
+    protocol,
+    baseURL: DEFAULT_BASE_URL,
+    path: ({ request }) => `/models/${request.model.id}:generateContent`,
+}, input);
 export const GoogleImages = {
+    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";