@opencode-ai/ai 0.0.0-beta-18050 → 0.0.0-beta-18138

package/dist/protocols/anthropic-messages.js

@@ -1,3 +1,4 @@
+import { Buffer } from "node:buffer";
 import { Effect, Schema } from "effect";
 import { Tool } from "@opencode-ai/schema/tool";
 import { Route } from "../route/client.js";
@@ -40,28 +41,62 @@ const AnthropicTextBlock = Schema.Struct({
     text: Schema.String,
     cache_control: Schema.optional(AnthropicCacheControl),
 });
+// SDK: Base64ImageSource:201 {type:"base64", media_type:"image/jpeg"|... , data}, URLImageSource:3817 {type:"url", url}, FileImageSource:2350 {type:"file", file_id}
+// SDK: ImageBlockParam:2356 {source: Base64|URL|File, cache_control, transformations:2381 {oversized_image?}}
+const AnthropicBase64ImageSource = Schema.Struct({
+    type: Schema.tag("base64"),
+    media_type: Schema.String,
+    data: Schema.String,
+});
+const AnthropicURLImageSource = Schema.Struct({ type: Schema.tag("url"), url: Schema.String });
+const AnthropicFileImageSource = Schema.Struct({ type: Schema.tag("file"), file_id: Schema.String });
+const AnthropicImageSource = Schema.Union([
+    AnthropicBase64ImageSource,
+    AnthropicURLImageSource,
+    AnthropicFileImageSource,
+]);
+const AnthropicImageTransformations = Schema.Struct({
+    oversized_image: Schema.optional(Schema.Literals(["downsize", "error"])),
+});
 const AnthropicImageBlock = Schema.Struct({
     type: Schema.tag("image"),
-    source: Schema.Struct({
-        type: Schema.tag("base64"),
-        media_type: Schema.String,
-        data: Schema.String,
-    }),
+    source: AnthropicImageSource,
     cache_control: Schema.optional(AnthropicCacheControl),
+    transformations: Schema.optional(AnthropicImageTransformations),
+});
+// SDK: Base64PDFSource:209 {type:"base64", media_type:"application/pdf", data}, PlainTextSource:2716 {type:"text", media_type:"text/plain", data},
+// SDK: URLPDFSource:3823 {type:"url", url}, FileDocumentSource:2344 {type:"file", file_id}, ContentBlockSource:2266 {type:"content", content}
+// SDK: DocumentBlockParam:2297 {source: 5-way union, cache_control, citations, context, title}
+const AnthropicBase64PDFSource = Schema.Struct({
+    type: Schema.tag("base64"),
+    media_type: Schema.Literal("application/pdf"),
+    data: Schema.String,
+});
+const AnthropicPlainTextSource = Schema.Struct({
+    type: Schema.tag("text"),
+    media_type: Schema.Literal("text/plain"),
+    data: Schema.String,
 });
+const AnthropicURLPDFSource = Schema.Struct({ type: Schema.tag("url"), url: Schema.String });
+const AnthropicFileDocumentSource = Schema.Struct({ type: Schema.tag("file"), file_id: Schema.String });
+const AnthropicDocumentSource = Schema.Union([
+    AnthropicBase64PDFSource,
+    AnthropicPlainTextSource,
+    AnthropicURLPDFSource,
+    AnthropicFileDocumentSource,
+]);
 const AnthropicDocumentBlock = Schema.Struct({
     type: Schema.tag("document"),
-    source: Schema.Struct({
-        type: Schema.tag("base64"),
-        media_type: Schema.Literal("application/pdf"),
-        data: Schema.String,
-    }),
+    source: AnthropicDocumentSource,
     cache_control: Schema.optional(AnthropicCacheControl),
+    title: Schema.optional(Schema.String),
+    context: Schema.optional(Schema.String),
+    citations: Schema.optional(Schema.Struct({ enabled: Schema.Boolean })),
 });
 const AnthropicThinkingBlock = Schema.Struct({
     type: Schema.tag("thinking"),
     thinking: Schema.String,
-    signature: Schema.optional(Schema.String),
+    signature: Schema.String,
     cache_control: Schema.optional(AnthropicCacheControl),
 });
 // Safety-filtered thinking arrives as an opaque encrypted `data` payload with
@@ -139,8 +174,11 @@ const AnthropicTool = Schema.Struct({
     cache_control: Schema.optional(AnthropicCacheControl),
 });
 const AnthropicToolChoice = Schema.Union([
-    Schema.Struct({ type: Schema.Literals(["auto", "any", "none"]) }),
-    Schema.Struct({ type: Schema.tag("tool"), name: Schema.String }),
+    Schema.Struct({
+        type: Schema.Literals(["auto", "any", "none"]),
+        disable_parallel_tool_use: Schema.optional(Schema.Boolean),
+    }),
+    Schema.Struct({ type: Schema.tag("tool"), name: Schema.String, disable_parallel_tool_use: Schema.optional(Schema.Boolean) }),
 ]);
 const AnthropicThinking = Schema.Union([
     Schema.Struct({
@@ -156,9 +194,25 @@ const AnthropicThinking = Schema.Union([
         type: Schema.tag("disabled"),
     }),
 ]);
+// SDK OutputConfig:2684 {effort?: "low"|"medium"|"high"|"xhigh"|"max"|null, format?: JSONOutputFormat:2399}
+const AnthropicJsonOutputFormat = Schema.Struct({
+    type: Schema.Literal("json_schema"),
+    schema: JsonObject,
+});
 const AnthropicOutputConfig = Schema.Struct({
     effort: Schema.optional(Schema.String),
+    format: Schema.optional(Schema.NullOr(AnthropicJsonOutputFormat)),
 });
+// SDK Metadata:2649 {user_id?: string|null}
+const AnthropicMetadata = Schema.Struct({ user_id: optionalNull(Schema.String) });
+// SDK MessageCreateParamsContainer:2596 ContainerParams|string; ContainerParams:2172 {id?, skills?}
+const AnthropicContainer = Schema.Union([
+    Schema.String,
+    Schema.Struct({
+        id: optionalNull(Schema.String),
+        skills: optionalNull(Schema.Array(JsonObject)),
+    }),
+]);
 const AnthropicBodyFields = {
     model: Schema.String,
     system: optionalArray(AnthropicTextBlock),
@@ -173,6 +227,12 @@ const AnthropicBodyFields = {
     stop_sequences: optionalArray(Schema.String),
     thinking: Schema.optional(AnthropicThinking),
     output_config: Schema.optional(AnthropicOutputConfig),
+    // SDK top-level passthrough: cache_control:4638, container:4643, inference_geo:4649, metadata:4654, service_tier:4670
+    cache_control: Schema.optional(AnthropicCacheControl),
+    container: Schema.optional(Schema.NullOr(AnthropicContainer)),
+    inference_geo: Schema.optional(Schema.NullOr(Schema.String)),
+    metadata: Schema.optional(AnthropicMetadata),
+    service_tier: Schema.optional(Schema.Literals(["auto", "standard_only"])),
 };
 export const AnthropicMessagesBody = Schema.Struct(AnthropicBodyFields);
 const AnthropicUsage = Schema.StructWithRest(Schema.Struct({
@@ -267,10 +327,26 @@ const lowerTool = (breakpoints, tool, inputSchema) => ({
     cache_control: cacheControl(breakpoints, tool.cache),
 });
 const lowerToolChoice = (toolChoice) => ProviderShared.matchToolChoice("Anthropic Messages", toolChoice, {
-    auto: () => ({ type: "auto" }),
+    auto: () => ({
+        type: "auto",
+        ...(toolChoice.disableParallelToolUse === undefined
+            ? {}
+            : { disable_parallel_tool_use: toolChoice.disableParallelToolUse }),
+    }),
     none: () => ({ type: "none" }),
-    required: () => ({ type: "any" }),
-    tool: (name) => ({ type: "tool", name }),
+    required: () => ({
+        type: "any",
+        ...(toolChoice.disableParallelToolUse === undefined
+            ? {}
+            : { disable_parallel_tool_use: toolChoice.disableParallelToolUse }),
+    }),
+    tool: (name) => ({
+        type: "tool",
+        name,
+        ...(toolChoice.disableParallelToolUse === undefined
+            ? {}
+            : { disable_parallel_tool_use: toolChoice.disableParallelToolUse }),
+    }),
 });
 const scrubToolCallID = (id) => id.replace(/[^a-zA-Z0-9_-]/g, "_");
 const lowerToolCall = (part) => ({
@@ -306,7 +382,149 @@ const lowerServerToolResult = Effect.fn("AnthropicMessages.lowerServerToolResult
     const payload = part.providerMetadata?.anthropic?.["result"] ?? part.result.value;
     return { type: wireType, tool_use_id: scrubToolCallID(part.id), content: payload };
 });
-const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part) {
+const fileIdFromMetadata = (metadata) => {
+    if (!ProviderShared.isRecord(metadata))
+        return undefined;
+    const anthropic = metadata.anthropic;
+    if (ProviderShared.isRecord(anthropic)) {
+        if (typeof anthropic.file_id === "string")
+            return anthropic.file_id;
+        if (typeof anthropic.fileId === "string")
+            return anthropic.fileId;
+    }
+    if (typeof metadata.file_id === "string")
+        return metadata.file_id;
+    if (typeof metadata.fileId === "string")
+        return metadata.fileId;
+    return undefined;
+};
+const transformationsFromMetadata = (metadata) => {
+    if (!ProviderShared.isRecord(metadata))
+        return undefined;
+    const anthropic = ProviderShared.isRecord(metadata.anthropic) ? metadata.anthropic : undefined;
+    const raw = anthropic?.transformations ?? metadata.transformations;
+    if (ProviderShared.isRecord(raw)) {
+        const value = raw.oversized_image;
+        if (value === "downsize" || value === "error")
+            return { oversized_image: value };
+    }
+    if (anthropic && (anthropic.oversized_image === "downsize" || anthropic.oversized_image === "error"))
+        return { oversized_image: anthropic.oversized_image };
+    return undefined;
+};
+const documentTitleFromPart = (part) => {
+    if (ProviderShared.isRecord(part.metadata)) {
+        const anthropic = part.metadata.anthropic;
+        if (ProviderShared.isRecord(anthropic) && typeof anthropic.title === "string")
+            return anthropic.title;
+        if (typeof part.metadata.title === "string")
+            return part.metadata.title;
+    }
+    if (typeof part.filename === "string" && part.filename.length > 0)
+        return part.filename;
+    return undefined;
+};
+const documentContextFromMetadata = (metadata) => {
+    if (!ProviderShared.isRecord(metadata))
+        return undefined;
+    const anthropic = ProviderShared.isRecord(metadata.anthropic) ? metadata.anthropic : undefined;
+    if (anthropic && typeof anthropic.context === "string")
+        return anthropic.context;
+    if (typeof metadata.context === "string")
+        return metadata.context;
+    return undefined;
+};
+const citationsFromMetadata = (metadata) => {
+    if (!ProviderShared.isRecord(metadata))
+        return undefined;
+    const raw = ProviderShared.isRecord(metadata.anthropic)
+        ? (metadata.anthropic.citations ?? metadata.citations)
+        : metadata.citations;
+    if (ProviderShared.isRecord(raw) && typeof raw.enabled === "boolean")
+        return { enabled: raw.enabled };
+    return undefined;
+};
+const isHttpUrl = (value) => /^https?:\/\//i.test(value.trim());
+const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part, breakpoints) {
+    const mime = part.mediaType.toLowerCase();
+    const cacheControlValue = breakpoints ? cacheControl(breakpoints, part.cache) : undefined;
+    const fileId = fileIdFromMetadata(part.metadata);
+    // SDK file sources: FileImageSource:2350 / FileDocumentSource:2344 {type:"file", file_id}
+    if (fileId) {
+        if (mime.startsWith("image/"))
+            return {
+                type: "image",
+                source: { type: "file", file_id: fileId },
+                ...(cacheControlValue === undefined ? {} : { cache_control: cacheControlValue }),
+                ...(transformationsFromMetadata(part.metadata) === undefined
+                    ? {}
+                    : { transformations: transformationsFromMetadata(part.metadata) }),
+            };
+        return {
+            type: "document",
+            source: { type: "file", file_id: fileId },
+            ...(cacheControlValue === undefined ? {} : { cache_control: cacheControlValue }),
+            ...(documentTitleFromPart(part) === undefined ? {} : { title: documentTitleFromPart(part) }),
+            ...(documentContextFromMetadata(part.metadata) === undefined
+                ? {}
+                : { context: documentContextFromMetadata(part.metadata) }),
+            ...(citationsFromMetadata(part.metadata) === undefined
+                ? {}
+                : { citations: citationsFromMetadata(part.metadata) }),
+        };
+    }
+    const rawString = typeof part.data === "string" ? part.data.trim() : undefined;
+    // SDK URL sources: URLImageSource:3817 / URLPDFSource:3823 {type:"url", url}
+    if (rawString && isHttpUrl(rawString) && !rawString.startsWith("data:")) {
+        if (mime.startsWith("image/"))
+            return {
+                type: "image",
+                source: { type: "url", url: rawString },
+                ...(cacheControlValue === undefined ? {} : { cache_control: cacheControlValue }),
+                ...(transformationsFromMetadata(part.metadata) === undefined
+                    ? {}
+                    : { transformations: transformationsFromMetadata(part.metadata) }),
+            };
+        if (mime === "application/pdf")
+            return {
+                type: "document",
+                source: { type: "url", url: rawString },
+                ...(cacheControlValue === undefined ? {} : { cache_control: cacheControlValue }),
+                ...(documentTitleFromPart(part) === undefined ? {} : { title: documentTitleFromPart(part) }),
+                ...(documentContextFromMetadata(part.metadata) === undefined
+                    ? {}
+                    : { context: documentContextFromMetadata(part.metadata) }),
+                ...(citationsFromMetadata(part.metadata) === undefined
+                    ? {}
+                    : { citations: citationsFromMetadata(part.metadata) }),
+            };
+    }
+    // SDK PlainTextSource:2716 {type:"text", media_type:"text/plain", data}
+    if (mime === "text/plain") {
+        const textData = typeof part.data !== "string"
+            ? Buffer.from(part.data).toString("utf8")
+            : part.data.startsWith("data:")
+                ? (() => {
+                    const comma = part.data.indexOf(",");
+                    const payload = comma >= 0 ? part.data.slice(comma + 1) : part.data;
+                    return part.data.includes(";base64")
+                        ? Buffer.from(payload, "base64").toString("utf8")
+                        : decodeURIComponent(payload);
+                })()
+                : part.data;
+        return {
+            type: "document",
+            source: { type: "text", media_type: "text/plain", data: textData },
+            ...(cacheControlValue === undefined ? {} : { cache_control: cacheControlValue }),
+            ...(documentTitleFromPart(part) === undefined ? {} : { title: documentTitleFromPart(part) }),
+            ...(documentContextFromMetadata(part.metadata) === undefined
+                ? {}
+                : { context: documentContextFromMetadata(part.metadata) }),
+            ...(citationsFromMetadata(part.metadata) === undefined
+                ? {}
+                : { citations: citationsFromMetadata(part.metadata) }),
+        };
+    }
     const media = ProviderShared.normalizeMedia(part);
     if (media.mime === "application/pdf")
         return {
@@ -316,6 +534,14 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part) {
                 media_type: "application/pdf",
                 data: media.base64,
             },
+            ...(cacheControlValue === undefined ? {} : { cache_control: cacheControlValue }),
+            ...(documentTitleFromPart(part) === undefined ? {} : { title: documentTitleFromPart(part) }),
+            ...(documentContextFromMetadata(part.metadata) === undefined
+                ? {}
+                : { context: documentContextFromMetadata(part.metadata) }),
+            ...(citationsFromMetadata(part.metadata) === undefined
+                ? {}
+                : { citations: citationsFromMetadata(part.metadata) }),
         };
     if (!media.mime.startsWith("image/"))
         return yield* invalid(`Anthropic Messages does not support media type ${part.mediaType}`);
@@ -326,6 +552,10 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part) {
             media_type: media.mime,
             data: media.base64,
         },
+        ...(cacheControlValue === undefined ? {} : { cache_control: cacheControlValue }),
+        ...(transformationsFromMetadata(part.metadata) === undefined
+            ? {}
+            : { transformations: transformationsFromMetadata(part.metadata) }),
     };
 });
 // Tool results may carry structured text, images, and documents. Keep media as provider-native
@@ -344,6 +574,24 @@ const lowerToolResultContent = Effect.fnUntraced(function* (part) {
     const content = part.result.value;
     return yield* Effect.forEach(content, lowerToolResultContentItem);
 });
+const requireThinkingSignature = (request) => {
+    if (request.model.compatibility?.requireSignature !== undefined)
+        return request.model.compatibility.requireSignature;
+    const provider = request.model.provider.toLowerCase();
+    const model = request.model.id.toLowerCase();
+    const baseURL = (request.model.route.endpoint.baseURL ?? "").toLowerCase();
+    if (provider === "kimi-for-coding" ||
+        provider === "moonshotai" ||
+        provider === "moonshotai-cn" ||
+        model.startsWith("kimi-") ||
+        baseURL.includes("api.kimi.com/coding") ||
+        baseURL.includes("api.moonshot.ai/anthropic") ||
+        baseURL.includes("api.moonshot.cn/anthropic"))
+        return false;
+    if (provider.includes("xiaomi") || model.includes("mimo") || baseURL.includes("xiaomimimo.com"))
+        return false;
+    return true;
+};
 // Mid-conversation system messages became available with Opus 4.8 and version
 // 5 of the other supported Claude families. Treat later family versions as
 // compatible without assuming that every Anthropic Messages model is Claude.
@@ -421,7 +669,7 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
                     continue;
                 }
                 if (part.type === "media") {
-                    content.push(yield* lowerMedia(part));
+                    content.push(yield* lowerMedia(part, breakpoints));
                     continue;
                 }
                 return yield* ProviderShared.unsupportedContent("Anthropic Messages", "user", ["text", "media"]);
@@ -437,15 +685,31 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
                     continue;
                 }
                 if (part.type === "reasoning") {
-                    // Mirrors Vercel's @ai-sdk/anthropic: a signature marks visible
-                    // thinking; only signature-less parts carrying redactedData
-                    // round-trip as opaque redacted_thinking blocks.
+                    // A signature marks visible thinking; only signature-less parts carrying
+                    // redactedData round-trip as opaque redacted_thinking blocks.
                     const signature = part.encrypted ?? signatureFromMetadata(part.providerMetadata);
                     const redactedData = redactedDataFromMetadata(part.providerMetadata);
                     if (signature === undefined && redactedData !== undefined) {
                         content.push({ type: "redacted_thinking", data: redactedData });
                         continue;
                     }
+                    if (typeof signature !== "string" || signature.trim().length === 0) {
+                        if (part.text.trim().length === 0)
+                            continue;
+                        if (!requireThinkingSignature(request)) {
+                            content.push({ type: "thinking", thinking: part.text, signature: "" });
+                            continue;
+                        }
+                        // Without a signature this cannot be a valid thinking block per
+                        // the SDK ThinkingBlockParam:3217 — demote to text so the
+                        // conversation remains sendable.
+                        content.push({
+                            type: "text",
+                            text: part.text,
+                            cache_control: cacheControl(breakpoints, part.cache),
+                        });
+                        continue;
+                    }
                     content.push({ type: "thinking", thinking: part.text, signature });
                     continue;
                 }
@@ -484,9 +748,52 @@ const lowerMessages = Effect.fn("AnthropicMessages.lowerMessages")(function* (re
 });
 const resolveOptions = Effect.fn("AnthropicMessages.resolveOptions")(function* (request) {
     const input = request.providerOptions;
+    const rawServiceTier = input?.service_tier ?? input?.serviceTier;
+    const service_tier = rawServiceTier === "auto" || rawServiceTier === "standard_only"
+        ? rawServiceTier
+        : undefined;
+    const rawMetadata = input?.metadata;
+    const metadata = ProviderShared.isRecord(rawMetadata) &&
+        (typeof rawMetadata.user_id === "string" || rawMetadata.user_id === null)
+        ? { user_id: rawMetadata.user_id }
+        : undefined;
+    const container = typeof input?.container === "string" ||
+        ProviderShared.isRecord(input?.container)
+        ? input.container
+        : undefined;
+    const rawInferenceGeo = input?.inference_geo ??
+        input?.inferenceGeo;
+    const inference_geo = typeof rawInferenceGeo === "string" ? rawInferenceGeo : undefined;
+    const rawCacheControl = input?.cache_control ??
+        input?.cacheControl;
+    const cache_control = ProviderShared.isRecord(rawCacheControl) && rawCacheControl.type === "ephemeral"
+        ? rawCacheControl
+        : undefined;
+    const rawOutputConfig = input?.output_config ??
+        input?.outputConfig;
+    const outputConfigEffort = typeof input?.effort === "string"
+        ? input.effort
+        : ProviderShared.isRecord(rawOutputConfig) && typeof rawOutputConfig.effort === "string"
+            ? rawOutputConfig.effort
+            : undefined;
+    const outputConfigFormat = ProviderShared.isRecord(rawOutputConfig) && ProviderShared.isRecord(rawOutputConfig.format)
+        ? rawOutputConfig.format
+        : undefined;
+    const output_config = outputConfigEffort === undefined && outputConfigFormat === undefined
+        ? undefined
+        : {
+            ...(outputConfigEffort === undefined ? {} : { effort: outputConfigEffort }),
+            ...(outputConfigFormat === undefined ? {} : { format: outputConfigFormat }),
+        };
     return {
         thinking: yield* resolveThinking(input?.thinking),
-        effort: typeof input?.effort === "string" ? input.effort : undefined,
+        effort: outputConfigEffort,
+        output_config,
+        service_tier,
+        metadata,
+        container,
+        inference_geo,
+        cache_control,
     };
 });
 const resolveThinking = Effect.fn("AnthropicMessages.resolveThinking")(function* (input) {
@@ -547,7 +854,13 @@ const fromRequest = Effect.fn("AnthropicMessages.fromRequest")(function* (reques
         top_k: generation?.topK,
         stop_sequences: generation?.stop,
         thinking: options.thinking,
-        output_config: options.effort === undefined ? undefined : { effort: options.effort },
+        output_config: options.output_config,
+        // top-level passthrough per SDK MessageCreateParamsBase:4638,4643,4649,4654,4670
+        cache_control: options.cache_control,
+        container: options.container,
+        inference_geo: options.inference_geo,
+        metadata: options.metadata,
+        service_tier: options.service_tier,
     };
 });
 // =============================================================================
@@ -889,7 +1202,7 @@ export const route = Route.make({
     provider: "anthropic",
     providerMetadataKey: "anthropic",
     protocol,
-    endpoint: Endpoint.path(PATH, { baseURL: DEFAULT_BASE_URL }),
+    endpoint: Endpoint.path((input) => (input.request.model.provider === "anthropic" ? `${PATH}?beta=true` : PATH), { baseURL: DEFAULT_BASE_URL }),
     auth: Auth.none,
     framing,
     headers: () => ({ "anthropic-version": "2023-06-01" }),

package/dist/protocols/gemini.d.ts

@@ -139,6 +139,7 @@ export declare const protocol: Protocol<{
             } | undefined;
         }[];
     }[] | undefined;
+    readonly serviceTier?: string | undefined;
     readonly toolConfig?: {
         readonly functionCallingConfig: {
             readonly mode: "AUTO" | "NONE" | "ANY";
@@ -150,7 +151,6 @@ export declare const protocol: Protocol<{
         readonly category: string;
         readonly threshold: string;
     }[] | undefined;
-    readonly serviceTier?: string | undefined;
     readonly labels?: {
         readonly [x: string]: string;
     } | undefined;
@@ -177,35 +177,7 @@ export declare const protocol: Protocol<{
 }, string, {
     readonly candidates?: readonly {
         readonly content?: {
-            readonly parts?: readonly ({
-                readonly inlineData: {
-                    readonly mimeType: string;
-                    readonly data: string;
-                };
-            } | {
-                readonly text: string;
-                readonly thought?: boolean | null | undefined;
-                readonly thoughtSignature?: string | null | undefined;
-            } | {
-                readonly functionCall: {
-                    readonly name: string;
-                    readonly id?: string | null | undefined;
-                    readonly args?: unknown;
-                };
-                readonly thoughtSignature?: string | null | undefined;
-            } | {
-                readonly functionResponse: {
-                    readonly name: string;
-                    readonly response: unknown;
-                    readonly id?: string | undefined;
-                    readonly parts?: readonly {
-                        readonly inlineData: {
-                            readonly mimeType: string;
-                            readonly data: string;
-                        };
-                    }[] | undefined;
-                };
-            })[] | null | undefined;
+            readonly parts?: readonly unknown[] | null | undefined;
             readonly role?: "model" | "user" | null | undefined;
         } | null | undefined;
         readonly finishReason?: string | null | undefined;
@@ -224,6 +196,7 @@ export declare const protocol: Protocol<{
         readonly totalTokenCount?: number | null | undefined;
     } | null | undefined;
 }, {
+    route: string;
     hasToolCalls: boolean;
     lifecycle: Lifecycle.State;
 }>;
@@ -269,6 +242,7 @@ export declare const route: Route<{
             } | undefined;
         }[];
     }[] | undefined;
+    readonly serviceTier?: string | undefined;
     readonly toolConfig?: {
         readonly functionCallingConfig: {
             readonly mode: "AUTO" | "NONE" | "ANY";
@@ -280,7 +254,6 @@ export declare const route: Route<{
         readonly category: string;
         readonly threshold: string;
     }[] | undefined;
-    readonly serviceTier?: string | undefined;
     readonly labels?: {
         readonly [x: string]: string;
     } | undefined;

package/dist/protocols/gemini.js

@@ -1,4 +1,4 @@
-import { Effect, Schema } from "effect";
+import { Effect, Option, Schema } from "effect";
 import { Tool } from "@opencode-ai/schema/tool";
 import { Route } from "../route/client.js";
 import { Auth } from "../route/auth.js";
@@ -76,10 +76,15 @@ const GeminiContentPart = Schema.Union([
     GeminiFunctionCallPart,
     GeminiFunctionResponsePart,
 ]);
+const decodeGeminiContentPart = Schema.decodeUnknownOption(GeminiContentPart);
 const GeminiContent = Schema.Struct({
     role: optionalNull(Schema.Literals(["user", "model"])),
     parts: optionalNull(Schema.Array(GeminiContentPart)),
 });
+const GeminiResponseContent = Schema.Struct({
+    role: optionalNull(Schema.Literals(["user", "model"])),
+    parts: optionalNull(Schema.Array(Schema.Unknown)),
+});
 const GeminiSystemInstruction = Schema.Struct({
     parts: Schema.Array(Schema.Struct({ text: Schema.String })),
 });
@@ -137,7 +142,7 @@ const GeminiUsage = Schema.Struct({
     totalTokenCount: optionalNull(Schema.Number),
 });
 const GeminiCandidate = Schema.Struct({
-    content: optionalNull(GeminiContent),
+    content: optionalNull(GeminiResponseContent),
     finishReason: optionalNull(Schema.String),
 });
 const GeminiPromptFeedback = Schema.StructWithRest(Schema.Struct({
@@ -485,7 +490,17 @@ const step = (state, event) => {
     let textSignature = nextState.textSignature;
     // Supplier ids must be tracked across chunks of the same response, not just within one event's parts.
     const seenCallIds = new Set(nextState.seenCallIds);
-    for (const part of candidate.content.parts ?? []) {
+    for (const input of candidate.content.parts ?? []) {
+        if (ProviderShared.isRecord(input) &&
+            !("text" in input) &&
+            !("inlineData" in input) &&
+            !("functionCall" in input) &&
+            !("functionResponse" in input))
+            continue;
+        const decoded = decodeGeminiContentPart(input);
+        if (Option.isNone(decoded))
+            return Effect.fail(ProviderShared.eventError(ADAPTER, `Invalid ${state.route} stream event`, ProviderShared.encodeJson(event)));
+        const part = decoded.value;
         const signature = "thoughtSignature" in part && part.thoughtSignature ? part.thoughtSignature : undefined;
         // Gemini attaches replay signatures to thought parts, visible text, or function calls;
         // each block kind must retain the signature attached to its own parts.
@@ -553,7 +568,11 @@ export const protocol = Protocol.make({
     },
     stream: {
         event: Protocol.jsonEvent(GeminiEvent),
-        initial: () => ({ hasToolCalls: false, lifecycle: Lifecycle.initial() }),
+        initial: (request) => ({
+            route: `${request.model.provider}/${request.model.route.id}`,
+            hasToolCalls: false,
+            lifecycle: Lifecycle.initial(),
+        }),
         step,
         onHalt: finish,
     },