@opencode/ai 0.0.0-dev-20076 → 0.0.0-dev-20077

package/dist/protocols/gemini.d.ts

@@ -76,7 +76,7 @@ declare const GeminiBody: Schema.Struct<{
         readonly functionDeclarations: Schema.$Array<Schema.Struct<{
             readonly name: Schema.String;
             readonly description: Schema.String;
-            readonly parameters: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+            readonly parametersJsonSchema: Schema.$Record<Schema.String, Schema.Unknown>;
         }>>;
     }>>>;
     toolConfig: Schema.optional<Schema.Struct<{
@@ -148,11 +148,11 @@ export declare const protocol: Protocol<{
     }[];
     readonly tools?: readonly {
         readonly functionDeclarations: readonly {
-            readonly description: string;
             readonly name: string;
-            readonly parameters?: {
+            readonly description: string;
+            readonly parametersJsonSchema: {
                 readonly [x: string]: unknown;
-            } | undefined;
+            };
         }[];
     }[] | undefined;
     readonly serviceTier?: string | undefined;
@@ -262,11 +262,11 @@ export declare const route: Route<{
     }[];
     readonly tools?: readonly {
         readonly functionDeclarations: readonly {
-            readonly description: string;
             readonly name: string;
-            readonly parameters?: {
+            readonly description: string;
+            readonly parametersJsonSchema: {
                 readonly [x: string]: unknown;
-            } | undefined;
+            };
         }[];
     }[] | undefined;
     readonly serviceTier?: string | undefined;

package/dist/protocols/gemini.js

@@ -10,7 +10,7 @@ import { classifyProviderFailure } from "../provider-error.js";
 import { Media } from "../media.js";
 import { JsonObject, knownString, lenient, optionalArray, optionalNull, ProviderShared } from "./shared.js";
 import { GeminiGenerateContent } from "./utils/gemini-generate-content.js";
-import { GeminiToolSchema } from "./utils/gemini-tool-schema.js";
+import { GeminiJsonSchema } from "./utils/gemini-json-schema.js";
 import { Lifecycle } from "./utils/lifecycle.js";
 import { ToolSchemaProjection } from "./utils/tool-schema.js";
 const ADAPTER = "gemini";
@@ -103,7 +103,7 @@ const GeminiSystemInstruction = Schema.Struct({
 const GeminiFunctionDeclaration = Schema.Struct({
     name: Schema.String,
     description: Schema.String,
-    parameters: Schema.optional(JsonObject),
+    parametersJsonSchema: JsonObject,
 });
 const GeminiTool = Schema.Struct({
     functionDeclarations: Schema.Array(GeminiFunctionDeclaration),
@@ -187,34 +187,14 @@ const GeminiEvent = Schema.Struct({
     usageMetadata: optionalNull(GeminiUsage),
 });
 // =============================================================================
-// Tool Schema Conversion
-// =============================================================================
-// Tool-schema conversion has two distinct concerns:
-//
-// 1. Sanitize — fix common authoring mistakes Gemini rejects: integer/number
-//    enums (must be strings), `required` entries that don't match a property,
-//    untyped arrays (`items` must be present), and `properties`/`required`
-//    keys on non-object scalars. Mirrors OpenCode's historical Gemini rules.
-//
-// 2. Project — lossy mapping from JSON Schema to Gemini's schema dialect:
-//    drop empty root parameter schemas while preserving nested empty objects,
-//    expand type arrays into `anyOf`, derive `nullable: true` from null members,
-//    coerce `const` to `[const]` enum, recurse properties/items, and propagate
-//    only an allowlisted set of keys (description, required, format, type,
-//    nullable, enum, properties, items, allOf, anyOf, oneOf, minLength).
-//    Anything outside the allowlist (e.g. `additionalProperties`, `$ref`) is
-//    silently dropped.
-//
-// Sanitize runs first, then project. The implementation lives in
-// `utils/gemini-tool-schema` so this protocol keeps the same shape as the other
-// provider protocols.
-// =============================================================================
 // Request Lowering
 // =============================================================================
+// Tool schemas go in `parametersJsonSchema`, which accepts standard JSON Schema.
+// `utils/gemini-json-schema` rewrites only the few shapes Gemini still rejects.
 const lowerTool = (tool, inputSchema) => ({
     name: tool.name,
     description: tool.description,
-    parameters: GeminiToolSchema.convert(inputSchema),
+    parametersJsonSchema: GeminiJsonSchema.normalize(inputSchema),
 });
 const lowerToolConfig = (toolChoice) => ProviderShared.matchToolChoice("Gemini", toolChoice, {
     auto: () => ({ functionCallingConfig: { mode: "AUTO" } }),

package/dist/protocols/utils/gemini-json-schema.d.ts

@@ -0,0 +1,3 @@
+import type { JsonSchema } from "../../schema/index.js";
+export declare const normalize: (schema: JsonSchema) => JsonSchema;
+export * as GeminiJsonSchema from "./gemini-json-schema.js";

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

@@ -0,0 +1,76 @@
+import { isRecord } from "../../utils/record.js";
+// Gemini's `parametersJsonSchema` accepts standard JSON Schema, but rejects a few shapes that
+// published tool schemas commonly contain. Rewrite only those and send everything else unchanged.
+const SCHEMA_MAPS = new Set([
+    "properties",
+    "patternProperties",
+    "$defs",
+    "definitions",
+    "dependentSchemas",
+    "dependencies",
+]);
+const VALUES = new Set(["const", "default", "enum", "examples", "dependentRequired"]);
+const mapValues = (record, map) => Object.fromEntries(Object.entries(record).map(([key, value]) => [key, map(value, key)]));
+const normalizeNode = (schema) => {
+    if (Array.isArray(schema))
+        return schema.map(normalizeNode);
+    if (!isRecord(schema))
+        return schema;
+    const properties = isRecord(schema.properties) ? schema.properties : undefined;
+    return Object.fromEntries(Object.entries(schema).flatMap(([key, value]) => {
+        if (VALUES.has(key))
+            return [[key, value]];
+        if (SCHEMA_MAPS.has(key) && isRecord(value))
+            return [[key, mapValues(value, normalizeNode)]];
+        // `required` may only name declared properties.
+        if (key === "required" && properties && Array.isArray(value))
+            return [[key, value.filter((name) => typeof name === "string" && Object.hasOwn(properties, name))]];
+        // Draft-04 boolean exclusive bounds become the numeric form.
+        if (key === "exclusiveMinimum" && typeof value === "boolean")
+            return value && typeof schema.minimum === "number" ? [[key, schema.minimum]] : [];
+        if (key === "exclusiveMaximum" && typeof value === "boolean")
+            return value && typeof schema.maximum === "number" ? [[key, schema.maximum]] : [];
+        if (key === "minimum" && schema.exclusiveMinimum === true)
+            return [];
+        if (key === "maximum" && schema.exclusiveMaximum === true)
+            return [];
+        // Draft-07 tuples (`items` array plus `additionalItems`) are `prefixItems` plus `items` in 2020-12.
+        if (key === "items" && Array.isArray(value))
+            return [["prefixItems", value.map(normalizeNode)]];
+        if (key === "additionalItems" && Array.isArray(schema.items))
+            return [["items", normalizeNode(value)]];
+        return [[key, normalizeNode(value)]];
+    }));
+};
+// Gemini accepts a recursive `$ref` only when the loop passes through an optional property or
+// potentially empty array `items`. Replace other self-references with an unconstrained schema.
+const cutLoops = (schema, target, safe) => {
+    if (Array.isArray(schema))
+        return schema.map((item) => cutLoops(item, target, safe));
+    if (!isRecord(schema))
+        return schema;
+    if (schema.$ref === target && !safe)
+        return {};
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    return mapValues(schema, (value, key) => {
+        if (VALUES.has(key))
+            return value;
+        if (key === "items")
+            return cutLoops(value, target, safe || !(Number(schema.minItems) > 0));
+        if (key === "properties" && isRecord(value))
+            return mapValues(value, (child, name) => cutLoops(child, target, safe || !required.includes(name)));
+        if (SCHEMA_MAPS.has(key) && isRecord(value))
+            return mapValues(value, (child) => cutLoops(child, target, safe));
+        return cutLoops(value, target, safe);
+    });
+};
+export const normalize = (schema) => {
+    const normalized = normalizeNode(schema);
+    if (!isRecord(normalized))
+        return {};
+    const result = cutLoops(mapValues(normalized, (value, key) => (key === "$defs" || key === "definitions") && isRecord(value)
+        ? mapValues(value, (def, name) => cutLoops(def, `#/${key}/${name}`, false))
+        : value), "#", false);
+    return isRecord(result) ? result : {};
+};
+export * as GeminiJsonSchema from "./gemini-json-schema.js";

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

@@ -67,11 +67,11 @@ export declare const routes: Route<{
     }[];
     readonly tools?: readonly {
         readonly functionDeclarations: readonly {
-            readonly description: string;
             readonly name: string;
-            readonly parameters?: {
+            readonly description: string;
+            readonly parametersJsonSchema: {
                 readonly [x: string]: unknown;
-            } | undefined;
+            };
         }[];
     }[] | undefined;
     readonly serviceTier?: string | undefined;

package/dist/providers/google.d.ts

@@ -52,11 +52,11 @@ export declare const routes: import("../route/client.js").Route<{
     }[];
     readonly tools?: readonly {
         readonly functionDeclarations: readonly {
-            readonly description: string;
             readonly name: string;
-            readonly parameters?: {
+            readonly description: string;
+            readonly parametersJsonSchema: {
                 readonly [x: string]: unknown;
-            } | undefined;
+            };
         }[];
     }[] | undefined;
     readonly serviceTier?: string | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "0.0.0-dev-20076",
+  "version": "0.0.0-dev-20077",
   "name": "@opencode/ai",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
   "devDependencies": {
     "@clack/prompts": "1.0.0-alpha.1",
     "@effect/platform-node": "4.0.0-rc.112",
-    "@opencode/http-recorder": "0.0.0-dev-20076",
+    "@opencode/http-recorder": "0.0.0-dev-20077",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -44,7 +44,7 @@
     "@aws-sdk/credential-providers": "3.1057.0",
     "@smithy/eventstream-codec": "4.2.14",
     "@smithy/util-utf8": "4.2.2",
-    "@opencode/schema": "0.0.0-dev-20076",
+    "@opencode/schema": "0.0.0-dev-20077",
     "aws4fetch": "1.0.20",
     "effect": "4.0.0-rc.112",
     "google-auth-library": "10.5.0"