@opencode-ai/ai 0.0.0-next-16996 → 0.0.0-next-16998

package/README.md

@@ -368,11 +368,12 @@ Other provider exports listed above remain direct facades until they explicitly
 
 ## Provider options & HTTP overlays
 
-Three escape hatches in order of stability:
+Request options in order of stability:
 
 1. **`generation`** — portable knobs (`maxTokens`, `temperature`, `topP`, `topK`, penalties, seed, stop).
-2. **`providerOptions: { <provider>: {...} }`** — typed-at-the-facade provider-specific knobs (OpenAI `promptCacheKey`, Anthropic `thinking`, Gemini `thinkingConfig`, OpenRouter routing).
-3. **`http: { body, headers, query }`** — last-resort serializable overlays merged into the final HTTP request. Reach for this only when a stable typed path doesn't yet exist.
+2. **`promptCacheKey`** — stable cache affinity lowered by every protocol that supports it.
+3. **`providerOptions: { <provider>: {...} }`** — typed-at-the-facade provider-specific knobs (OpenAI `store`, Anthropic `thinking`, Gemini `thinkingConfig`, OpenRouter routing).
+4. **`http: { body, headers, query }`** — last-resort serializable overlays merged into the final HTTP request. Reach for this only when a stable typed path doesn't yet exist.
 
 Route/provider defaults are overridden by request-level values for each axis.
 

package/dist/protocols/gemini.d.ts

@@ -83,6 +83,9 @@ declare const GeminiBody: Schema.Struct<{
         readonly temperature: Schema.optional<Schema.Number>;
         readonly topP: Schema.optional<Schema.Number>;
         readonly topK: Schema.optional<Schema.Number>;
+        readonly frequencyPenalty: Schema.optional<Schema.Number>;
+        readonly presencePenalty: Schema.optional<Schema.Number>;
+        readonly seed: Schema.optional<Schema.Number>;
         readonly stopSequences: Schema.optional<Schema.$Array<Schema.String>>;
         readonly thinkingConfig: Schema.optional<Schema.Struct<{
             readonly thinkingBudget: Schema.optional<Schema.Number>;
@@ -160,6 +163,9 @@ export declare const protocol: Protocol<{
         readonly temperature?: number | undefined;
         readonly topP?: number | undefined;
         readonly topK?: number | undefined;
+        readonly frequencyPenalty?: number | undefined;
+        readonly presencePenalty?: number | undefined;
+        readonly seed?: number | undefined;
         readonly stopSequences?: readonly string[] | undefined;
         readonly thinkingConfig?: {
             readonly thinkingBudget?: number | undefined;
@@ -279,6 +285,9 @@ export declare const route: Route<{
         readonly temperature?: number | undefined;
         readonly topP?: number | undefined;
         readonly topK?: number | undefined;
+        readonly frequencyPenalty?: number | undefined;
+        readonly presencePenalty?: number | undefined;
+        readonly seed?: number | undefined;
         readonly stopSequences?: readonly string[] | undefined;
         readonly thinkingConfig?: {
             readonly thinkingBudget?: number | undefined;

package/dist/protocols/gemini.js

@@ -12,7 +12,21 @@ import { Lifecycle } from "./utils/lifecycle";
 import { ToolSchemaProjection } from "./utils/tool-schema";
 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";
+// Gemini 3 rejects replayed function calls without a thought signature. Google's SDKs avoid that in normal chats by
+// retaining complete model responses, but OpenCode reconstructs durable history and may encounter an unsigned call
+// from an older or external session. Model IDs are open-ended, so unknown Gemini aliases inherit current behavior.
+const requiresThoughtSignatureFallback = (modelID) => {
+    if (!/(^|\/)gemini-/i.test(modelID))
+        return false;
+    if (/(^|\/)gemini-(?:1|2)(?:[.-]|$)/i.test(modelID))
+        return false;
+    if (/(^|\/)gemini-pro(?:-vision)?$/i.test(modelID))
+        return false;
+    return !/(^|\/)gemini-robotics-er-1\.5(?:[.-]|$)/i.test(modelID);
+};
 // =============================================================================
 // Request Body Schema
 // =============================================================================
@@ -84,6 +98,9 @@ const GeminiGenerationConfig = Schema.Struct({
     temperature: Schema.optional(Schema.Number),
     topP: Schema.optional(Schema.Number),
     topK: Schema.optional(Schema.Number),
+    frequencyPenalty: Schema.optional(Schema.Number),
+    presencePenalty: Schema.optional(Schema.Number),
+    seed: Schema.optional(Schema.Number),
     stopSequences: optionalArray(Schema.String),
     thinkingConfig: Schema.optional(GeminiThinkingConfig),
 });
@@ -124,11 +141,13 @@ const GeminiEvent = Schema.Struct({
 //    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 objects, derive `nullable: true` from `type: [..., "null"]`,
-//    coerce `const` to `[const]` enum, recurse properties/items, propagate
+//    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,
-//    properties, items, allOf, anyOf, oneOf, minLength). Anything outside the
-//    allowlist (e.g. `additionalProperties`, `$ref`) is silently dropped.
+//    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
@@ -194,6 +213,8 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
         }
         if (message.role === "assistant") {
             const parts = [];
+            // 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"]);
@@ -206,7 +227,17 @@ const lowerMessages = Effect.fn("Gemini.lowerMessages")(function* (request) {
                     continue;
                 }
                 if (part.type === "tool-call") {
-                    parts.push(lowerToolCall(part));
+                    const lowered = lowerToolCall(part);
+                    const signature = lowered.thoughtSignature;
+                    parts.push({
+                        ...lowered,
+                        thoughtSignature: signature ??
+                            (requiresThoughtSignatureFallback(request.model.id) && !hasSignedToolCall
+                                ? SKIP_THOUGHT_SIGNATURE_VALIDATOR
+                                : undefined),
+                    });
+                    if (signature !== undefined)
+                        hasSignedToolCall = true;
                     continue;
                 }
             }
@@ -292,6 +323,9 @@ const fromRequest = Effect.fn("Gemini.fromRequest")(function* (request) {
         temperature: generation?.temperature,
         topP: generation?.topP,
         topK: generation?.topK,
+        frequencyPenalty: generation?.frequencyPenalty,
+        presencePenalty: generation?.presencePenalty,
+        seed: generation?.seed,
         stopSequences: generation?.stop,
         thinkingConfig: options.thinkingConfig,
     };

package/dist/protocols/open-responses.js

@@ -392,7 +392,7 @@ const lowerOptions = (request) => {
     return {
         ...(options.instructions ? { instructions: options.instructions } : {}),
         ...(options.store !== undefined ? { store: options.store } : {}),
-        ...(options.promptCacheKey ? { prompt_cache_key: options.promptCacheKey } : {}),
+        ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
         ...(options.include ? { include: options.include } : {}),
         ...(options.reasoningEffort || options.reasoningSummary
             ? { reasoning: { effort: options.reasoningEffort, summary: options.reasoningSummary } }

package/dist/protocols/utils/gemini-tool-schema.js

@@ -47,37 +47,57 @@ const sanitizeNode = (schema) => {
 const emptyObjectSchema = (schema) => schema.type === "object" &&
     (!isRecord(schema.properties) || Object.keys(schema.properties).length === 0) &&
     !schema.additionalProperties;
-const projectNode = (schema) => {
+const projectNode = (schema, nested = false) => {
     if (!isRecord(schema))
         return undefined;
-    if (emptyObjectSchema(schema))
+    if (!nested && emptyObjectSchema(schema))
         return undefined;
-    return Object.fromEntries([
+    const types = Array.isArray(schema.type) ? schema.type.filter((type) => type !== "null") : undefined;
+    const anyOf = Array.isArray(schema.anyOf) ? schema.anyOf : undefined;
+    const hasNullAnyOf = anyOf?.some((item) => isRecord(item) && item.type === "null") ?? false;
+    const anyOfTypes = hasNullAnyOf ? anyOf?.filter((item) => !isRecord(item) || item.type !== "null") : anyOf;
+    const flattenedAnyOf = hasNullAnyOf && anyOfTypes?.length === 1 ? projectNode(anyOfTypes[0], true) : undefined;
+    const result = Object.fromEntries([
         ["description", schema.description],
         ["required", schema.required],
         ["format", schema.format],
-        ["type", Array.isArray(schema.type) ? schema.type.filter((type) => type !== "null")[0] : schema.type],
-        ["nullable", Array.isArray(schema.type) && schema.type.includes("null") ? true : undefined],
+        ["type", types ? (types.length === 0 ? "null" : undefined) : schema.type],
+        [
+            "nullable",
+            (Array.isArray(schema.type) && schema.type.includes("null") && types && types.length > 0) || hasNullAnyOf
+                ? true
+                : undefined,
+        ],
         ["enum", schema.const !== undefined ? [schema.const] : schema.enum],
         [
             "properties",
             isRecord(schema.properties)
-                ? Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => [key, projectNode(value)]))
+                ? Object.fromEntries(Object.entries(schema.properties).map(([key, value]) => [key, projectNode(value, true)]))
                 : undefined,
         ],
         [
             "items",
             Array.isArray(schema.items)
-                ? schema.items.map(projectNode)
+                ? schema.items.map((item) => projectNode(item, true))
                 : schema.items === undefined
                     ? undefined
-                    : projectNode(schema.items),
+                    : projectNode(schema.items, true),
+        ],
+        ["allOf", Array.isArray(schema.allOf) ? schema.allOf.map((item) => projectNode(item, true)) : undefined],
+        [
+            "anyOf",
+            anyOfTypes
+                ? hasNullAnyOf && anyOfTypes.length === 1
+                    ? undefined
+                    : anyOfTypes.map((item) => projectNode(item, true))
+                : types && types.length > 0
+                    ? types.map((type) => ({ type }))
+                    : undefined,
         ],
-        ["allOf", Array.isArray(schema.allOf) ? schema.allOf.map(projectNode) : undefined],
-        ["anyOf", Array.isArray(schema.anyOf) ? schema.anyOf.map(projectNode) : undefined],
-        ["oneOf", Array.isArray(schema.oneOf) ? schema.oneOf.map(projectNode) : undefined],
+        ["oneOf", Array.isArray(schema.oneOf) ? schema.oneOf.map((item) => projectNode(item, true)) : undefined],
         ["minLength", schema.minLength],
     ].filter((entry) => entry[1] !== undefined));
+    return flattenedAnyOf ? { ...result, ...flattenedAnyOf } : result;
 };
 export const convert = (schema) => projectNode(sanitizeNode(schema));
 export * as GeminiToolSchema from "./gemini-tool-schema";

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

@@ -11,7 +11,6 @@ export declare const ServiceTierSchema: Schema.Literals<readonly ["auto", "defau
 export interface Resolved {
     readonly instructions?: string;
     readonly store?: boolean;
-    readonly promptCacheKey?: string;
     readonly reasoningEffort?: string;
     readonly reasoningSummary?: "auto" | "concise" | "detailed";
     readonly include?: ReadonlyArray<ResponseIncludable>;

package/dist/protocols/utils/open-responses-options.js

@@ -29,7 +29,6 @@ export const resolve = (request) => {
     return {
         instructions: typeof input?.instructions === "string" ? input.instructions : undefined,
         store: typeof input?.store === "boolean" ? input.store : undefined,
-        promptCacheKey: typeof input?.promptCacheKey === "string" ? input.promptCacheKey : undefined,
         reasoningEffort: typeof input?.reasoningEffort === "string" ? input.reasoningEffort : undefined,
         reasoningSummary: reasoningSummary === "auto" || reasoningSummary === "concise" || reasoningSummary === "detailed"
             ? reasoningSummary

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

@@ -87,6 +87,9 @@ export declare const routes: Route<{
         readonly temperature?: number | undefined;
         readonly topP?: number | undefined;
         readonly topK?: number | undefined;
+        readonly frequencyPenalty?: number | undefined;
+        readonly presencePenalty?: number | undefined;
+        readonly seed?: number | undefined;
         readonly stopSequences?: readonly string[] | undefined;
         readonly thinkingConfig?: {
             readonly thinkingBudget?: number | undefined;

package/dist/providers/google.d.ts

@@ -70,6 +70,9 @@ export declare const routes: import("../route").Route<{
         readonly temperature?: number | undefined;
         readonly topP?: number | undefined;
         readonly topK?: number | undefined;
+        readonly frequencyPenalty?: number | undefined;
+        readonly presencePenalty?: number | undefined;
+        readonly seed?: number | undefined;
         readonly stopSequences?: readonly string[] | undefined;
         readonly thinkingConfig?: {
             readonly thinkingBudget?: number | undefined;

package/dist/providers/open-responses-options.d.ts

@@ -4,7 +4,6 @@ export interface OpenResponsesOptionsInput {
     readonly [key: string]: unknown;
     readonly instructions?: string;
     readonly store?: boolean;
-    readonly promptCacheKey?: string;
     readonly reasoningEffort?: ReasoningEffort;
     readonly reasoningSummary?: "auto" | "concise" | "detailed";
     readonly include?: ReadonlyArray<ResponseIncludable>;

package/dist/providers/openai-options.js

@@ -3,7 +3,6 @@ const definedEntries = (input) => Object.entries(input).filter((entry) => entry[
 const openAIProviderOptions = (options) => {
     const openai = Object.fromEntries(definedEntries({
         store: options?.store,
-        promptCacheKey: options?.promptCacheKey,
         reasoningEffort: options?.reasoningEffort,
         reasoningSummary: options?.reasoningSummary,
         include: options?.include,

package/dist/providers/openrouter.d.ts

@@ -59,7 +59,6 @@ export interface OpenRouterOptions {
     }>;
     readonly models?: ReadonlyArray<string>;
     readonly plugins?: ReadonlyArray<OpenRouterPlugin>;
-    readonly promptCacheKey?: string;
     readonly provider?: OpenRouterProviderRouting;
     readonly reasoning?: Readonly<{
         enabled?: boolean;

package/dist/providers/openrouter.js

@@ -43,6 +43,7 @@ export const protocol = Protocol.make({
                 ...body,
                 messages,
                 ...bodyOptions(request.providerOptions?.openrouter),
+                ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
             };
         })),
     },
@@ -79,7 +80,6 @@ const bodyOptions = (input) => {
         ...(isRecord(debug) ? { debug } : {}),
         ...(typeof user === "string" ? { user } : {}),
         ...(isRecord(reasoning) ? { reasoning } : {}),
-        ...(typeof promptCacheKey === "string" ? { prompt_cache_key: promptCacheKey } : {}),
     };
 };
 export const route = Route.make({

package/dist/schema/messages.d.ts

@@ -368,6 +368,7 @@ declare const LLMRequest_base: Schema.Class<LLMRequest, Schema.Struct<{
         }>]>>;
         readonly ttlSeconds: Schema.optional<Schema.Number>;
     }>]>>;
+    readonly promptCacheKey: Schema.optional<Schema.String>;
     readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
 }>, {}>;
 export declare class LLMRequest extends LLMRequest_base {

package/dist/schema/messages.js

@@ -211,6 +211,8 @@ export class LLMRequest extends Schema.Class("LLM.Request")({
     providerOptions: Schema.optional(ProviderOptions),
     http: Schema.optional(HttpOptions),
     cache: Schema.optional(CachePolicy),
+    // Stable cache affinity for protocols that support provider-managed prompt caching.
+    promptCacheKey: Schema.optional(Schema.String),
     metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
 }) {
 }
@@ -226,6 +228,7 @@ export class LLMRequest extends Schema.Class("LLM.Request")({
         providerOptions: request.providerOptions,
         http: request.http,
         cache: request.cache,
+        promptCacheKey: request.promptCacheKey,
         metadata: request.metadata,
     });
     LLMRequest.update = (request, patch) => {

package/package.json

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