@opencode/ai 2.0.14 → 2.0.16

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>>;
                 }>>>;
             }>;
         }>]>>>>;
@@ -69,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<{
@@ -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;
@@ -134,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;
@@ -192,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;
@@ -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;
@@ -241,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

@@ -7,8 +7,9 @@ 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 { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolSchemaProjection } from "./utils/tool-schema.js";
 const ADAPTER = "gemini";
@@ -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,
 ]);
@@ -92,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),
@@ -176,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" } }),
@@ -211,11 +201,10 @@ 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) {
+const lowerContentPart = Effect.fn("Gemini.lowerContentPart")(function* (part) {
     if (part.type === "text")
         return { text: part.text };
-    const media = ProviderShared.normalizeMedia(part);
-    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) => {
@@ -259,7 +248,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 +258,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 +324,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)
@@ -357,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,
@@ -380,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,
@@ -539,6 +538,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>;
 };