@opencode-ai/ai 0.0.0-dev-17534 → 0.0.0-dev-17582

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

@@ -44,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),
 });
@@ -106,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),
@@ -125,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),
 });
 // =============================================================================
@@ -401,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];
@@ -446,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/shared.d.ts

@@ -120,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

@@ -154,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/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-dev-17534",
+  "version": "0.0.0-dev-17582",
   "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-dev-17534",
+    "@effect/platform-node": "4.0.0-beta.107",
+    "@opencode-ai/http-recorder": "0.0.0-dev-17582",
     "@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-dev-17534",
+    "@opencode-ai/schema": "0.0.0-dev-17582",
     "aws4fetch": "1.0.20",
-    "effect": "4.0.0-beta.101",
+    "effect": "4.0.0-beta.107",
     "google-auth-library": "10.5.0"
   }
 }