@opencode-ai/ai 0.0.0-beta-17498 → 0.0.0-beta-17570

package/dist/protocols/anthropic-messages.js

@@ -13,7 +13,6 @@ import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "anthropic-messages";
-const MEDIA_MIMES = new Set([...ProviderShared.IMAGE_MIMES, ...ProviderShared.PDF_MIMES]);
 export const DEFAULT_BASE_URL = "https://api.anthropic.com/v1";
 export const PATH = "/messages";
 // =============================================================================
@@ -293,7 +292,7 @@ const lowerServerToolResult = Effect.fn("AnthropicMessages.lowerServerToolResult
     return { type: wireType, tool_use_id: part.id, content: payload };
 });
 const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part) {
-    const media = yield* ProviderShared.validateMedia("Anthropic Messages", part, MEDIA_MIMES);
+    const media = ProviderShared.normalizeMedia(part);
     if (media.mime === "application/pdf")
         return {
             type: "document",
@@ -303,6 +302,8 @@ const lowerMedia = Effect.fn("AnthropicMessages.lowerMedia")(function* (part) {
                 data: media.base64,
             },
         };
+    if (!media.mime.startsWith("image/"))
+        return yield* invalid(`Anthropic Messages does not support media type ${part.mediaType}`);
     return {
         type: "image",
         source: {

package/dist/protocols/gemini.d.ts

@@ -38,7 +38,7 @@ declare const GeminiBody: Schema.Struct<{
             readonly functionCall: Schema.Struct<{
                 readonly id: Schema.optional<Schema.String>;
                 readonly name: Schema.String;
-                readonly args: Schema.Unknown;
+                readonly args: Schema.optional<Schema.Unknown>;
             }>;
             readonly thoughtSignature: Schema.optional<Schema.String>;
         }>, Schema.Struct<{
@@ -55,6 +55,7 @@ declare const GeminiBody: Schema.Struct<{
             }>;
         }>]>>;
     }>>;
+    labels: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
     safetySettings: Schema.optional<Schema.$Array<Schema.Struct<{
         readonly category: Schema.String;
         readonly threshold: Schema.String;
@@ -115,8 +116,8 @@ export declare const protocol: Protocol<{
         } | {
             readonly functionCall: {
                 readonly name: string;
-                readonly args: unknown;
                 readonly id?: string | undefined;
+                readonly args?: unknown;
             };
             readonly thoughtSignature?: string | undefined;
         } | {
@@ -154,6 +155,9 @@ export declare const protocol: Protocol<{
         readonly threshold: string;
     }[] | undefined;
     readonly serviceTier?: string | undefined;
+    readonly labels?: {
+        readonly [x: string]: string;
+    } | undefined;
     readonly systemInstruction?: {
         readonly parts: readonly {
             readonly text: string;
@@ -190,8 +194,8 @@ export declare const protocol: Protocol<{
             } | {
                 readonly functionCall: {
                     readonly name: string;
-                    readonly args: unknown;
                     readonly id?: string | undefined;
+                    readonly args?: unknown;
                 };
                 readonly thoughtSignature?: string | undefined;
             } | {
@@ -210,6 +214,12 @@ export declare const protocol: Protocol<{
         } | undefined;
         readonly finishReason?: string | undefined;
     }[] | undefined;
+    readonly promptFeedback?: {
+        readonly [x: string]: unknown;
+        readonly blockReason?: string | undefined;
+        readonly blockReasonMessage?: string | undefined;
+        readonly safetyRatings?: unknown;
+    } | undefined;
     readonly usageMetadata?: {
         readonly cachedContentTokenCount?: number | undefined;
         readonly thoughtsTokenCount?: number | undefined;
@@ -237,8 +247,8 @@ export declare const route: Route<{
         } | {
             readonly functionCall: {
                 readonly name: string;
-                readonly args: unknown;
                 readonly id?: string | undefined;
+                readonly args?: unknown;
             };
             readonly thoughtSignature?: string | undefined;
         } | {
@@ -276,6 +286,9 @@ export declare const route: Route<{
         readonly threshold: string;
     }[] | undefined;
     readonly serviceTier?: string | undefined;
+    readonly labels?: {
+        readonly [x: string]: string;
+    } | undefined;
     readonly systemInstruction?: {
         readonly parts: readonly {
             readonly text: string;

package/dist/protocols/gemini.js

@@ -11,7 +11,6 @@ import { GeminiToolSchema } from "./utils/gemini-tool-schema.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolSchemaProjection } from "./utils/tool-schema.js";
 const ADAPTER = "gemini";
-const MEDIA_MIMES = new Set(ProviderShared.MEDIA_MIMES);
 // Google documents this sentinel for replaying Gemini 3 function calls after their original signature was lost.
 const SKIP_THOUGHT_SIGNATURE_VALIDATOR = "skip_thought_signature_validator";
 export const DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
@@ -45,7 +44,7 @@ const GeminiFunctionCallPart = Schema.Struct({
     functionCall: Schema.Struct({
         id: Schema.optional(Schema.String),
         name: Schema.String,
-        args: Schema.Unknown,
+        args: Schema.optional(Schema.Unknown),
     }),
     thoughtSignature: Schema.optional(Schema.String),
 });
@@ -107,6 +106,7 @@ const GeminiGenerationConfig = Schema.Struct({
 const GeminiBodyFields = {
     cachedContent: Schema.optional(Schema.String),
     contents: Schema.Array(GeminiContent),
+    labels: Schema.optional(Schema.Record(Schema.String, Schema.String)),
     safetySettings: optionalArray(GeminiSafetySetting),
     serviceTier: Schema.optional(Schema.String),
     systemInstruction: Schema.optional(GeminiSystemInstruction),
@@ -126,8 +126,14 @@ const GeminiCandidate = Schema.Struct({
     content: Schema.optional(GeminiContent),
     finishReason: Schema.optional(Schema.String),
 });
+const GeminiPromptFeedback = Schema.StructWithRest(Schema.Struct({
+    blockReason: Schema.optional(Schema.String),
+    blockReasonMessage: Schema.optional(Schema.String),
+    safetyRatings: Schema.optional(Schema.Unknown),
+}), [Schema.Record(Schema.String, Schema.Unknown)]);
 const GeminiEvent = Schema.Struct({
     candidates: optionalArray(GeminiCandidate),
+    promptFeedback: Schema.optional(GeminiPromptFeedback),
     usageMetadata: Schema.optional(GeminiUsage),
 });
 // =============================================================================
@@ -169,7 +175,7 @@ const lowerToolConfig = (toolChoice) => ProviderShared.matchToolChoice("Gemini",
 const lowerUserPart = Effect.fn("Gemini.lowerUserPart")(function* (part) {
     if (part.type === "text")
         return { text: part.text };
-    const media = yield* ProviderShared.validateMedia("Gemini", part, MEDIA_MIMES);
+    const media = ProviderShared.normalizeMedia(part);
     return { inlineData: { mimeType: media.mime, data: media.base64 } };
 });
 const googleMetadata = (metadata) => ({ google: metadata });
@@ -267,7 +273,7 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
             for (const item of content) {
                 if (item.type === "text")
                     continue;
-                const value = yield* ProviderShared.validateToolFile("Gemini", item, MEDIA_MIMES);
+                const value = ProviderShared.normalizeToolFile(item);
                 media.push({ inlineData: { mimeType: value.mime, data: value.base64 } });
             }
             parts.push({
@@ -402,25 +408,29 @@ const mapFinishReason = (finishReason, hasToolCalls) => {
         return "error";
     return "unknown";
 };
-const finish = (state) => state.finishReason || state.usage
-    ? (() => {
-        const events = [];
-        const lifecycle = state.reasoningSignature
-            ? Lifecycle.reasoningEnd(state.lifecycle, events, "reasoning-0", googleMetadata({ thoughtSignature: state.reasoningSignature }))
-            : state.lifecycle;
-        Lifecycle.finish(lifecycle, events, {
-            reason: {
-                normalized: mapFinishReason(state.finishReason, state.hasToolCalls),
-                raw: state.finishReason,
-            },
-            usage: state.usage,
-        });
-        return events;
-    })()
-    : [];
+const finish = (state) => {
+    const promptBlockReason = state.finishReason === undefined ? state.promptFeedback?.blockReason : undefined;
+    const finishReason = state.finishReason ?? promptBlockReason;
+    if (finishReason === undefined && state.usage === undefined)
+        return [];
+    const events = [];
+    const lifecycle = state.reasoningSignature
+        ? Lifecycle.reasoningEnd(state.lifecycle, events, "reasoning-0", googleMetadata({ thoughtSignature: state.reasoningSignature }))
+        : state.lifecycle;
+    Lifecycle.finish(lifecycle, events, {
+        reason: {
+            normalized: promptBlockReason === undefined ? mapFinishReason(finishReason, state.hasToolCalls) : "content-filter",
+            raw: finishReason,
+        },
+        usage: state.usage,
+        providerMetadata: state.promptFeedback === undefined ? undefined : googleMetadata({ promptFeedback: state.promptFeedback }),
+    });
+    return events;
+};
 const step = (state, event) => {
     const nextState = {
         ...state,
+        promptFeedback: event.promptFeedback ?? state.promptFeedback,
         usage: event.usageMetadata ? (mapUsage(event.usageMetadata) ?? state.usage) : state.usage,
     };
     const candidate = event.candidates?.[0];
@@ -447,7 +457,7 @@ const step = (state, event) => {
             continue;
         }
         if ("functionCall" in part) {
-            const input = part.functionCall.args;
+            const input = part.functionCall.args === undefined ? {} : part.functionCall.args;
             const id = `tool_${nextToolCallId++}`;
             const metadata = {
                 ...(part.functionCall.id === undefined ? {} : { functionCallId: part.functionCall.id }),

package/dist/protocols/open-responses.d.ts

@@ -366,7 +366,7 @@ export interface Extension {
     readonly name: string;
     readonly lowerMedia?: (input: {
         readonly part: MediaPart;
-        readonly media: ProviderShared.ValidatedMedia;
+        readonly media: ProviderShared.NormalizedMedia;
         readonly request: LLMRequest;
     }) => MediaInput | undefined;
     readonly messagePhase?: (value: unknown) => MessagePhase | null | undefined;

package/dist/protocols/open-responses.js

@@ -10,7 +10,6 @@ import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "open-responses";
 const NAME = "Open Responses";
-const MEDIA_MIMES = new Set([...ProviderShared.IMAGE_MIMES, ...ProviderShared.PDF_MIMES]);
 export const PATH = "/responses";
 // =============================================================================
 // Request Body Schema
@@ -243,14 +242,14 @@ const hostedToolItemID = (part, providerMetadataKey) => {
         : undefined;
 };
 const lowerMedia = Effect.fn("OpenResponses.lowerMedia")(function* (part, request, extension) {
-    const media = yield* ProviderShared.validateMedia(extension.name, part, MEDIA_MIMES);
+    const media = ProviderShared.normalizeMedia(part);
     const extended = extension.lowerMedia?.({ part, media, request });
     if (extended)
         return extended;
-    if (media.mime === "application/pdf") {
+    if (!media.mime.startsWith("image/")) {
         return {
             type: "input_file",
-            filename: part.filename ?? "document.pdf",
+            filename: part.filename ?? (media.mime === "application/pdf" ? "document.pdf" : "file"),
             file_data: media.dataUrl,
         };
     }

package/dist/protocols/openai-chat.js

@@ -13,7 +13,6 @@ import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolSchemaProjection } from "./utils/tool-schema.js";
 import { ToolStream } from "./utils/tool-stream.js";
 const ADAPTER = "openai-chat";
-const IMAGE_MIMES = new Set(ProviderShared.IMAGE_MIMES);
 const RESERVED_REASONING_FIELDS = new Set(["role", "content", "tool_calls"]);
 export const DEFAULT_BASE_URL = "https://api.openai.com/v1";
 export const PATH = "/chat/completions";
@@ -189,7 +188,9 @@ const lowerToolCall = (part) => ({
     },
 });
 const lowerMedia = Effect.fn("OpenAIChat.lowerMedia")(function* (part) {
-    const media = yield* ProviderShared.validateMedia("OpenAI Chat", part, IMAGE_MIMES);
+    const media = ProviderShared.normalizeMedia(part);
+    if (!media.mime.startsWith("image/"))
+        return yield* ProviderShared.invalidRequest(`OpenAI Chat does not support media type ${part.mediaType}`);
     return { type: "image_url", image_url: { url: media.dataUrl } };
 });
 const openAICompatibleReasoningContent = (native) => isRecord(native) && typeof native.reasoning_content === "string" ? native.reasoning_content : undefined;

package/dist/protocols/shared.d.ts

@@ -1,8 +1,7 @@
-import { Buffer } from "node:buffer";
 import { Tool } from "@opencode-ai/schema/tool";
 import { Effect, Schema, Stream } from "effect";
 import { Headers, HttpClientRequest } from "effect/unstable/http";
-import { AIError, type ContentPart, type LLMRequest, type ToolResultPart } from "../schema/index.js";
+import { AIError, type ContentPart, type LLMRequest, type MediaPart, type ToolResultPart } from "../schema/index.js";
 import { isRecord } from "../utils/record.js";
 export { isRecord };
 export declare const Json: Schema.fromJsonString<Schema.Unknown>;
@@ -106,39 +105,13 @@ export declare const wrappedSystemUpdate: (route: string, message: import("../sc
  * routes: `Invalid JSON input for <route> tool call <name>`.
  */
 export declare const parseToolInput: (route: string, name: string, raw: string) => Effect.Effect<unknown, AIError, never>;
-export declare const IMAGE_MIMES: readonly ["image/png", "image/jpeg", "image/gif", "image/webp"];
-export declare const VIDEO_MIMES: readonly ["video/mp4", "video/webm", "video/quicktime"];
-export declare const AUDIO_MIMES: readonly ["audio/wav", "audio/mp3", "audio/aiff", "audio/aac", "audio/ogg", "audio/flac"];
-export declare const PDF_MIMES: readonly ["application/pdf"];
-export declare const MEDIA_MIMES: readonly ["image/png", "image/jpeg", "image/gif", "image/webp", "video/mp4", "video/webm", "video/quicktime", "audio/wav", "audio/mp3", "audio/aiff", "audio/aac", "audio/ogg", "audio/flac", "application/pdf"];
-export declare const MAX_MEDIA_ENCODED_BYTES: number;
-export declare const MAX_MEDIA_DECODED_BYTES: number;
-export interface ValidatedMedia {
+export interface NormalizedMedia {
     readonly mime: string;
     readonly base64: string;
     readonly dataUrl: string;
-    readonly bytes: Uint8Array;
 }
-export declare const validateMedia: (route: string, part: {
-    readonly data: string | Uint8Array<ArrayBufferLike>;
-    readonly type: "media";
-    readonly mediaType: string;
-    readonly metadata?: {
-        readonly [x: string]: unknown;
-    } | undefined;
-    readonly filename?: string | undefined;
-}, supportedMimes: ReadonlySet<string>) => Effect.Effect<{
-    mime: string;
-    base64: string;
-    dataUrl: string;
-    bytes: Buffer<ArrayBuffer>;
-}, AIError, never>;
-export declare const validateToolFile: (route: string, part: Tool.FileContent, supportedMimes: ReadonlySet<string>) => Effect.Effect<{
-    mime: string;
-    base64: string;
-    dataUrl: string;
-    bytes: Buffer<ArrayBuffer>;
-}, AIError, never>;
+export declare const normalizeMedia: (part: MediaPart) => NormalizedMedia;
+export declare const normalizeToolFile: (part: Tool.FileContent) => NormalizedMedia;
 export declare const trimBaseUrl: (value: string) => string;
 export declare const toolResultText: (part: ToolResultPart) => string;
 export declare const errorText: (error: unknown) => string;
@@ -147,8 +120,8 @@ export declare const errorText: (error: unknown) => string;
  * decoder, and drops empty / `[DONE]` keep-alive events so the downstream
  * `decodeChunk` sees one JSON string per element. The SSE channel emits a
  * `Retry` control event on its error channel; we drop it here (we don't
- * implement client-driven retries) so the public error channel stays
- * `AIError`.
+ * implement client-driven retries). Decoder failures become provider output
+ * errors so the public error channel stays `AIError`.
  */
 export declare const sseFraming: (bytes: Stream.Stream<Uint8Array, AIError>) => Stream.Stream<string, AIError>;
 /**

package/dist/protocols/shared.js

@@ -113,47 +113,17 @@ export const wrappedSystemUpdate = Effect.fn("ProviderShared.wrappedSystemUpdate
  * routes: `Invalid JSON input for <route> tool call <name>`.
  */
 export const parseToolInput = (route, name, raw) => parseJson(route, raw || "{}", `Invalid JSON input for ${route} tool call ${name}`);
-export const IMAGE_MIMES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
-export const VIDEO_MIMES = ["video/mp4", "video/webm", "video/quicktime"];
-export const AUDIO_MIMES = ["audio/wav", "audio/mp3", "audio/aiff", "audio/aac", "audio/ogg", "audio/flac"];
-export const PDF_MIMES = ["application/pdf"];
-export const MEDIA_MIMES = [...IMAGE_MIMES, ...VIDEO_MIMES, ...AUDIO_MIMES, ...PDF_MIMES];
-export const MAX_MEDIA_ENCODED_BYTES = 28 * 1024 * 1024;
-export const MAX_MEDIA_DECODED_BYTES = 20 * 1024 * 1024;
-const base64Pattern = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
-export const validateMedia = Effect.fn("ProviderShared.validateMedia")(function* (route, part, supportedMimes) {
+export const normalizeMedia = (part) => {
     const mime = part.mediaType.toLowerCase();
-    if (!supportedMimes.has(mime))
-        return yield* invalidRequest(`${route} does not support media type ${part.mediaType}`);
-    let base64;
     if (typeof part.data !== "string") {
-        if (part.data.byteLength > MAX_MEDIA_DECODED_BYTES)
-            return yield* invalidRequest(`${route} media exceeds the ${MAX_MEDIA_DECODED_BYTES} byte decoded limit`);
-        base64 = Buffer.from(part.data).toString("base64");
+        const base64 = Buffer.from(part.data).toString("base64");
+        return { mime, base64, dataUrl: `data:${mime};base64,${base64}` };
     }
-    else if (part.data.startsWith("data:")) {
-        const match = /^data:([^;,]+);base64,([A-Za-z0-9+/]*={0,2})$/s.exec(part.data);
-        if (!match)
-            return yield* invalidRequest(`${route} media data URL must contain valid base64`);
-        if (match[1].toLowerCase() !== mime)
-            return yield* invalidRequest(`${route} media type ${part.mediaType} does not match data URL type ${match[1]}`);
-        base64 = match[2];
-    }
-    else {
-        base64 = part.data;
-    }
-    if (Buffer.byteLength(base64, "utf8") > MAX_MEDIA_ENCODED_BYTES)
-        return yield* invalidRequest(`${route} media exceeds the ${MAX_MEDIA_ENCODED_BYTES} byte encoded limit`);
-    if (!base64 || base64.length % 4 !== 0 || !base64Pattern.test(base64))
-        return yield* invalidRequest(`${route} media must contain valid base64`);
-    const bytes = Buffer.from(base64, "base64");
-    if (bytes.byteLength > MAX_MEDIA_DECODED_BYTES)
-        return yield* invalidRequest(`${route} media exceeds the ${MAX_MEDIA_DECODED_BYTES} byte decoded limit`);
-    if (bytes.toString("base64") !== base64)
-        return yield* invalidRequest(`${route} media must contain canonical base64`);
-    return { mime, base64, dataUrl: `data:${mime};base64,${base64}`, bytes };
-});
-export const validateToolFile = (route, part, supportedMimes) => validateMedia(route, { type: "media", mediaType: part.mime, data: part.uri, filename: part.name }, supportedMimes);
+    if (!part.data.startsWith("data:"))
+        return { mime, base64: part.data, dataUrl: `data:${mime};base64,${part.data}` };
+    return { mime, base64: part.data.slice(part.data.indexOf(",") + 1), dataUrl: part.data };
+};
+export const normalizeToolFile = (part) => normalizeMedia({ type: "media", mediaType: part.mime, data: part.uri, filename: part.name });
 export const trimBaseUrl = (value) => value.replace(/\/+$/, "");
 export const toolResultText = (part) => {
     if (part.result.type === "text")
@@ -184,10 +154,10 @@ export const errorText = (error) => {
  * decoder, and drops empty / `[DONE]` keep-alive events so the downstream
  * `decodeChunk` sees one JSON string per element. The SSE channel emits a
  * `Retry` control event on its error channel; we drop it here (we don't
- * implement client-driven retries) so the public error channel stays
- * `AIError`.
+ * implement client-driven retries). Decoder failures become provider output
+ * errors so the public error channel stays `AIError`.
  */
-export const sseFraming = (bytes) => bytes.pipe(Stream.decodeText(), Stream.pipeThroughChannel(Sse.decode()), Stream.catchTag("Retry", () => Stream.empty), Stream.filter((event) => event.data.length > 0 && event.data !== "[DONE]"), Stream.map((event) => event.data));
+export const sseFraming = (bytes) => bytes.pipe(Stream.decodeText(), Stream.pipeThroughChannel(Sse.decode()), Stream.catchTag("Retry", () => Stream.empty), Stream.catchTag("SseError", (error) => Stream.fail(eventError("sse", error.message))), Stream.filter((event) => event.data.length > 0 && event.data !== "[DONE]"), Stream.map((event) => event.data));
 /**
  * Canonical invalid-request constructor. Lift one-line `const invalid =
  * (message) => invalidRequest(message)` aliases out of every

package/dist/protocols/utils/bedrock-media.js

@@ -53,7 +53,7 @@ export const lower = Effect.fn("BedrockMedia.lower")(function* (part) {
     const mime = part.mediaType.toLowerCase();
     const imageFormat = IMAGE_FORMATS[mime];
     if (imageFormat) {
-        const media = yield* ProviderShared.validateMedia("Bedrock Converse", part, new Set(Object.keys(IMAGE_FORMATS)));
+        const media = ProviderShared.normalizeMedia(part);
         return { image: { format: imageFormat, source: { bytes: media.base64 } } };
     }
     if (mime.startsWith("image/"))
@@ -62,7 +62,7 @@ export const lower = Effect.fn("BedrockMedia.lower")(function* (part) {
     if (documentFormat) {
         if (!part.filename)
             return yield* ProviderShared.invalidRequest("Bedrock Converse document media requires a filename");
-        const media = yield* ProviderShared.validateMedia("Bedrock Converse", part, new Set(Object.keys(DOCUMENT_FORMATS)));
+        const media = ProviderShared.normalizeMedia(part);
         return documentBlock(part.filename, documentFormat, media.base64);
     }
     return yield* ProviderShared.invalidRequest(`Bedrock Converse does not support media type ${part.mediaType}`);

package/dist/provider-error.js

@@ -35,7 +35,7 @@ export const isPayloadTooLarge = (message) => payloadPatterns.some((pattern) =>
 export const isContextOverflowFailure = (failure) => failure instanceof AIError
     ? failure.reason._tag === "InvalidRequest" && failure.reason.classification === "context-overflow"
     : Schema.is(ProviderErrorEvent)(failure) && failure.classification === "context-overflow";
-const decodeJson = Schema.decodeUnknownOption(Schema.UnknownFromJsonString);
+const decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
 const QUOTA_CODES = new Set(["insufficient_quota", "usage_not_included", "billing_error"]);
 const SERVER_CODES = new Set([
     "api_error",

package/dist/providers/google-vertex.d.ts

@@ -1,16 +1,20 @@
 import type { ProviderPackage } from "../provider-package.js";
 import { Gemini } from "../protocols/gemini.js";
 import { Route, type RouteDefaultsInput } from "../route/client.js";
-import { type ModelID } from "../schema/index.js";
+import { type ModelID, type ProviderOptions } from "../schema/index.js";
 import { GoogleVertexShared } from "./google-vertex-shared.js";
-export type GeminiOptionsInput = Gemini.OptionsInput;
-export type GeminiProviderOptionsInput = Gemini.ProviderOptionsInput;
+export interface GeminiOptionsInput extends Gemini.OptionsInput {
+    readonly labels?: Readonly<Record<string, string>>;
+}
+export type GeminiProviderOptionsInput = ProviderOptions & {
+    readonly gemini?: GeminiOptionsInput;
+};
 export declare const id: string & import("effect/Brand").Brand<"AI.ProviderID">;
 export type Config = RouteDefaultsInput & GoogleVertexShared.ApiKeyOptions & {
     readonly baseURL?: string;
     readonly location?: string;
     readonly project?: string;
-    readonly providerOptions?: Gemini.ProviderOptionsInput;
+    readonly providerOptions?: GeminiProviderOptionsInput;
 };
 export type Settings = ProviderPackage.Settings & ({
     readonly accessToken?: string;
@@ -22,7 +26,7 @@ export type Settings = ProviderPackage.Settings & ({
     readonly baseURL?: string;
     readonly location?: string;
     readonly project?: string;
-    readonly providerOptions?: Gemini.ProviderOptionsInput;
+    readonly providerOptions?: GeminiProviderOptionsInput;
 };
 export declare const routes: Route<{
     readonly contents: readonly {
@@ -39,8 +43,8 @@ export declare const routes: Route<{
         } | {
             readonly functionCall: {
                 readonly name: string;
-                readonly args: unknown;
                 readonly id?: string | undefined;
+                readonly args?: unknown;
             };
             readonly thoughtSignature?: string | undefined;
         } | {
@@ -78,6 +82,9 @@ export declare const routes: Route<{
         readonly threshold: string;
     }[] | undefined;
     readonly serviceTier?: string | undefined;
+    readonly labels?: {
+        readonly [x: string]: string;
+    } | undefined;
     readonly systemInstruction?: {
         readonly parts: readonly {
             readonly text: string;
@@ -101,15 +108,15 @@ export declare const routes: Route<{
 }, import("../route/transport/http.js").HttpPrepared<string>>[];
 export declare const configure: (input?: Config) => {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.ProviderOptionsInput>;
+    model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<GeminiProviderOptionsInput>;
     configure: (input?: Config) => /*elided*/ any;
 };
 export declare const provider: {
     id: string & import("effect/Brand").Brand<"AI.ProviderID">;
     configure: (input?: Config) => {
         id: string & import("effect/Brand").Brand<"AI.ProviderID">;
-        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<Gemini.ProviderOptionsInput>;
+        model: (modelID: string | ModelID) => import("../schema/options.js").LanguageModel<GeminiProviderOptionsInput>;
         configure: /*elided*/ any;
     };
 };
-export declare const model: ProviderPackage.Definition<Settings, Gemini.ProviderOptionsInput>["model"];
+export declare const model: ProviderPackage.Definition<Settings, GeminiProviderOptionsInput>["model"];

package/dist/providers/google-vertex.js

@@ -1,4 +1,6 @@
+import { Effect } from "effect";
 import { Gemini } from "../protocols/gemini.js";
+import { ProviderShared } from "../protocols/shared.js";
 import { Auth } from "../route/auth.js";
 import { Route } from "../route/client.js";
 import { Endpoint } from "../route/endpoint.js";
@@ -6,11 +8,26 @@ import { Framing } from "../route/framing.js";
 import { ProviderID } from "../schema/index.js";
 import { GoogleVertexShared } from "./google-vertex-shared.js";
 export const id = ProviderID.make("google-vertex");
+const fromRequest = Effect.fn("GoogleVertex.fromRequest")(function* (request) {
+    const body = yield* Gemini.protocol.body.from(request);
+    const value = request.providerOptions?.gemini?.labels;
+    const labels = ProviderShared.isRecord(value)
+        ? Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"))
+        : undefined;
+    return { ...body, labels };
+});
+const protocol = {
+    ...Gemini.protocol,
+    body: {
+        ...Gemini.protocol.body,
+        from: fromRequest,
+    },
+};
 const route = Route.make({
     id: "google-vertex-gemini",
     provider: id,
     providerMetadataKey: "google",
-    protocol: Gemini.protocol,
+    protocol,
     endpoint: Endpoint.path(({ request }) => {
         const model = String(request.model.id);
         return `/${model.startsWith("endpoints/") ? model : `models/${model}`}:streamGenerateContent?alt=sse`;

package/dist/providers/google.d.ts

@@ -22,8 +22,8 @@ export declare const routes: import("../route/client.js").Route<{
         } | {
             readonly functionCall: {
                 readonly name: string;
-                readonly args: unknown;
                 readonly id?: string | undefined;
+                readonly args?: unknown;
             };
             readonly thoughtSignature?: string | undefined;
         } | {
@@ -61,6 +61,9 @@ export declare const routes: import("../route/client.js").Route<{
         readonly threshold: string;
     }[] | undefined;
     readonly serviceTier?: string | undefined;
+    readonly labels?: {
+        readonly [x: string]: string;
+    } | undefined;
     readonly systemInstruction?: {
         readonly parts: readonly {
             readonly text: string;

package/dist/schema/errors.js

@@ -132,7 +132,7 @@ export const AIErrorReason = Schema.Union([
     InvalidProviderOutputReason,
     UnknownProviderReason,
 ]).pipe(Schema.toTaggedUnion("_tag"));
-export class AIError extends Schema.TaggedErrorClass()("AI.Error", {
+export class AIError extends Schema.TaggedError()("AI.Error", {
     module: Schema.String,
     method: Schema.String,
     reason: AIErrorReason,

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-beta-17498",
+  "version": "0.0.0-beta-17570",
   "name": "@opencode-ai/ai",
   "type": "module",
   "license": "MIT",
@@ -29,8 +29,8 @@
   },
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
-    "@effect/platform-node": "4.0.0-beta.101",
-    "@opencode-ai/http-recorder": "0.0.0-beta-17498",
+    "@effect/platform-node": "4.0.0-beta.107",
+    "@opencode-ai/http-recorder": "0.0.0-beta-17570",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.3.13",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -39,9 +39,9 @@
   "dependencies": {
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode-ai/schema": "0.0.0-beta-17498",
+    "@opencode-ai/schema": "0.0.0-beta-17570",
     "aws4fetch": "1.0.20",
-    "effect": "4.0.0-beta.101",
+    "effect": "4.0.0-beta.107",
     "google-auth-library": "10.5.0"
   }
 }