@cortexkit/opencode-antigravity-auth 3.0.2 → 3.0.3

package/dist/index.js

@@ -20435,11 +20435,11 @@ var AccountManager = class _AccountManager {
         usage: () => this.requestSaveToDisk(),
         stale: (account, label) => this.ignoreStale(account, label)
       },
-      // A repository-backed manager gets its own new trackers. A pool-file
-      // manager without supplied trackers shares the process-wide ones
-      // (`getHealthTracker`, `getTokenTracker`), as it always has.
-      healthTracker: options.healthTracker ?? (repositoryBacked ? new HealthScoreTracker() : getHealthTracker),
-      tokenTracker: options.tokenTracker ?? (repositoryBacked ? new TokenBucketTracker() : getTokenTracker),
+      // A repository-backed manager gets its own new trackers, which run on
+      // this manager's clock. A pool-file manager without supplied trackers
+      // shares the process-wide ones (`getHealthTracker`, `getTokenTracker`).
+      healthTracker: options.healthTracker ?? (repositoryBacked ? new HealthScoreTracker({}, this.now) : getHealthTracker),
+      tokenTracker: options.tokenTracker ?? (repositoryBacked ? new TokenBucketTracker({}, this.now) : getTokenTracker),
       now: this.now,
       random: options.random ?? (() => Math.random()),
       pid: options.pid ?? process.pid,
@@ -24235,29 +24235,29 @@ function appendClaudeThinkingHint(payload, hint = CLAUDE_INTERLEAVED_THINKING_HI
 }
 
 // ../core/dist/transform/gemini.js
-var UNSUPPORTED_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
-  "additionalProperties",
-  "$schema",
-  "$id",
-  "$comment",
-  "$ref",
-  "$defs",
-  "definitions",
-  "const",
-  "contentMediaType",
-  "contentEncoding",
-  "if",
-  "then",
-  "else",
-  "not",
-  "patternProperties",
-  "unevaluatedProperties",
-  "unevaluatedItems",
-  "dependentRequired",
-  "dependentSchemas",
-  "propertyNames",
-  "minContains",
-  "maxContains"
+var ALLOWED_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
+  "type",
+  "properties",
+  "items",
+  "required",
+  "description",
+  "format",
+  "pattern",
+  "title",
+  "nullable",
+  "propertyOrdering",
+  "example",
+  "default",
+  "enum",
+  "anyOf",
+  "minimum",
+  "maximum",
+  "minLength",
+  "maxLength",
+  "minItems",
+  "maxItems",
+  "minProperties",
+  "maxProperties"
 ]);
 var NUMERIC_SCHEMA_CONSTRAINTS = /* @__PURE__ */ new Set([
   "minLength",
@@ -24272,13 +24272,121 @@ var NUMERIC_SCHEMA_CONSTRAINTS = /* @__PURE__ */ new Set([
   "exclusiveMaximum",
   "multipleOf"
 ]);
+function isSchemaObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function describeValue(value) {
+  return JSON.stringify(value) ?? String(value);
+}
+function sameSchemaValue(left, right) {
+  if (left === right)
+    return true;
+  if (Array.isArray(left) && Array.isArray(right)) {
+    return left.length === right.length && left.every((value, index) => sameSchemaValue(value, right[index]));
+  }
+  if (!isSchemaObject(left) || !isSchemaObject(right))
+    return false;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every((key) => Object.hasOwn(right, key) && sameSchemaValue(left[key], right[key]));
+}
+function mergeSchemaAllOf(schema, hints) {
+  if (!Array.isArray(schema.allOf))
+    return schema;
+  const { allOf, ...base } = schema;
+  const branches = [base, ...allOf];
+  const properties = {};
+  const required2 = /* @__PURE__ */ new Set();
+  const descriptions = [];
+  const metadata = {};
+  let unambiguous = allOf.length > 0;
+  for (const branch of branches) {
+    if (!isSchemaObject(branch) || branch.type !== void 0 && String(branch.type).toUpperCase() !== "OBJECT" || branch.properties !== void 0 && !isSchemaObject(branch.properties)) {
+      unambiguous = false;
+      break;
+    }
+    for (const [key, value] of Object.entries(branch)) {
+      if (!["properties", "required", "description"].includes(key) && !Object.hasOwn(metadata, key))
+        metadata[key] = value;
+    }
+    if (typeof branch.description === "string")
+      descriptions.push(branch.description);
+    for (const [name, property] of Object.entries(branch.properties ?? {})) {
+      if (Object.hasOwn(properties, name) && !sameSchemaValue(properties[name], property))
+        unambiguous = false;
+      properties[name] = property;
+    }
+    if (Array.isArray(branch.required)) {
+      for (const name of branch.required) {
+        if (typeof name === "string")
+          required2.add(name);
+      }
+    }
+  }
+  if (unambiguous) {
+    return {
+      ...metadata,
+      type: "object",
+      properties,
+      ...required2.size ? { required: [...required2] } : {},
+      ...descriptions.length ? { description: descriptions.join(" ") } : {}
+    };
+  }
+  hints.push("allOf: using the first branch; other intersection constraints omitted.");
+  const first = isSchemaObject(allOf[0]) ? allOf[0] : {};
+  return {
+    ...base,
+    ...first,
+    ...base.description ? { description: base.description } : {}
+  };
+}
+var CLAUDE_VALIDATED_HINT_FIELDS = /* @__PURE__ */ new Set([
+  "minLength",
+  "maxLength",
+  "minItems",
+  "maxItems",
+  "pattern",
+  "format",
+  "default"
+]);
+function flattenClaudeUnion(schema, hints) {
+  if (!Array.isArray(schema.anyOf) || schema.anyOf.length === 0)
+    return schema;
+  const { anyOf, ...base } = schema;
+  const branches = anyOf.filter(isSchemaObject);
+  if (!branches.length)
+    return base;
+  if (branches.length === anyOf.length && branches.every((branch) => Array.isArray(branch.enum) && branch.enum.length > 0 && branch.enum.every((value) => typeof value === "string") && (branch.type === void 0 || branch.type === "STRING") && !branch.properties && !branch.items)) {
+    return {
+      ...base,
+      type: "STRING",
+      enum: [...new Set(branches.flatMap((branch) => branch.enum))]
+    };
+  }
+  const typeName = (branch) => branch.properties ? "object" : branch.items ? "array" : String(branch.type ?? "null").toLowerCase();
+  const score = (branch) => {
+    const type = typeName(branch);
+    return type === "object" ? 3 : type === "array" ? 2 : type === "null" ? 0 : 1;
+  };
+  let selected = branches[0];
+  for (const branch of branches.slice(1)) {
+    if (score(branch) > score(selected))
+      selected = branch;
+  }
+  const result = { ...base, ...selected };
+  if (typeof base.description === "string" && base.description) {
+    result.description = typeof selected.description === "string" && selected.description && selected.description !== base.description ? `${base.description} (${selected.description})` : base.description;
+  }
+  if (branches.length > 1)
+    hints.push(`Accepts: ${[...new Set(branches.map(typeName))].join(" | ")}`);
+  return result;
+}
 function toGeminiSchema(schema, options = {}) {
   if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
     return schema;
   }
-  const inputSchema = schema;
-  const result = {};
   const numericConstraintHints = [];
+  const inputSchema = mergeSchemaAllOf(schema, numericConstraintHints);
+  let result = {};
   const propertyNames = /* @__PURE__ */ new Set();
   if (inputSchema.properties && typeof inputSchema.properties === "object") {
     for (const propName of Object.keys(inputSchema.properties)) {
@@ -24286,9 +24394,51 @@ function toGeminiSchema(schema, options = {}) {
     }
   }
   for (const [key, value] of Object.entries(inputSchema)) {
-    if (UNSUPPORTED_SCHEMA_FIELDS.has(key)) {
+    if (options.claudeValidated) {
+      if (key === "title")
+        continue;
+      if (key === "additionalProperties" && value === false)
+        numericConstraintHints.push("No extra properties allowed");
+      if (CLAUDE_VALIDATED_HINT_FIELDS.has(key)) {
+        if (value !== void 0 && typeof value !== "object")
+          numericConstraintHints.push(`${key}: ${value}`);
+        continue;
+      }
+    }
+    if (key === "const") {
+      if (typeof value === "string")
+        result.enum = [value];
+      else
+        numericConstraintHints.push(`Must be ${describeValue(value)}.`);
       continue;
     }
+    if (NUMERIC_SCHEMA_CONSTRAINTS.has(key)) {
+      const exclusive = key === "exclusiveMinimum" || key === "exclusiveMaximum";
+      if (exclusive && !options.moveNumericConstraintsToDescription && String(inputSchema.type).toUpperCase() === "INTEGER" && typeof value === "number" && Number.isFinite(value)) {
+        const lower = key === "exclusiveMinimum";
+        const bound = lower ? Math.floor(value) + 1 : Math.ceil(value) - 1;
+        const inclusiveKey = lower ? "minimum" : "maximum";
+        const existing = inputSchema[inclusiveKey];
+        if (Number.isSafeInteger(bound)) {
+          result[inclusiveKey] = typeof existing === "number" ? lower ? Math.max(existing, bound) : Math.min(existing, bound) : bound;
+          continue;
+        }
+      }
+      if (options.moveNumericConstraintsToDescription || exclusive || key === "multipleOf") {
+        if (["string", "number", "boolean"].includes(typeof value))
+          numericConstraintHints.push(`${key}: ${value}`);
+        continue;
+      }
+    }
+    if (key === "oneOf" && Array.isArray(value)) {
+      if (!Array.isArray(inputSchema.anyOf))
+        result.anyOf = value.map((item) => toGeminiSchema(item, options));
+      else
+        numericConstraintHints.push("oneOf: additional union constraints omitted.");
+      continue;
+    }
+    if (!ALLOWED_SCHEMA_FIELDS.has(key))
+      continue;
     if (key === "type" && typeof value === "string") {
       result[key] = value.toUpperCase();
     } else if (key === "properties" && typeof value === "object" && value !== null) {
@@ -24299,16 +24449,15 @@ function toGeminiSchema(schema, options = {}) {
       result[key] = props;
     } else if (key === "items" && typeof value === "object") {
       result[key] = toGeminiSchema(value, options);
-    } else if ((key === "anyOf" || key === "oneOf" || key === "allOf") && Array.isArray(value)) {
+    } else if (key === "anyOf" && Array.isArray(value)) {
       result[key] = value.map((item) => toGeminiSchema(item, options));
     } else if (key === "enum" && Array.isArray(value)) {
-      result[key] = value;
-    } else if (options.moveNumericConstraintsToDescription && NUMERIC_SCHEMA_CONSTRAINTS.has(key)) {
-      if (typeof value === "string" || typeof value === "number") {
-        numericConstraintHints.push(`${key}: ${value}`);
+      if (value.every((item) => typeof item === "string")) {
+        if (typeof inputSchema.const !== "string")
+          result.enum = value;
+      } else {
+        numericConstraintHints.push(`Allowed values: ${value.map(describeValue).join(", ")}.`);
       }
-    } else if (key === "default" || key === "examples") {
-      result[key] = value;
     } else if (key === "required" && Array.isArray(value)) {
       if (propertyNames.size > 0) {
         const validRequired = value.filter((prop) => typeof prop === "string" && propertyNames.has(prop));
@@ -24318,10 +24467,23 @@ function toGeminiSchema(schema, options = {}) {
       } else {
         result[key] = value;
       }
+    } else if ((key === "minimum" || key === "maximum") && typeof result[key] === "number" && typeof value === "number") {
+      result[key] = key === "minimum" ? Math.max(result[key], value) : Math.min(result[key], value);
     } else {
       result[key] = value;
     }
   }
+  if (options.claudeValidated) {
+    result = flattenClaudeUnion(result, numericConstraintHints);
+    if (isSchemaObject(result.properties) && Array.isArray(result.required)) {
+      const properties = result.properties;
+      const required2 = result.required.filter((name) => typeof name === "string" && Object.hasOwn(properties, name));
+      if (required2.length)
+        result.required = required2;
+      else
+        delete result.required;
+    }
+  }
   if (numericConstraintHints.length > 0) {
     const hint = numericConstraintHints.join(", ");
     result.description = typeof result.description === "string" && result.description ? `${result.description} (${hint})` : hint;
@@ -36301,10 +36463,6 @@ import { appendFileSync as appendFileSync4, mkdirSync as mkdirSync7, writeFileSy
 import { tmpdir as tmpdir4 } from "node:os";
 import { join as join23 } from "node:path";
 var DUMP_STATUS_TITLE = "## Gemini Dump Status";
-var DUMP_ENABLED_TITLE = "## Gemini Dump Enabled";
-var DUMP_DISABLED_TITLE = "## Gemini Dump Disabled";
-var DUMP_USAGE_TITLE = "## Gemini Dump Usage";
-var DUMP_USAGE = "Usage: `/gemini-dump`, `/gemini-dump on`, or `/gemini-dump off`.";
 var DUMP_DIR_ENV = "OPENCODE_ANTIGRAVITY_GEMINI_DUMP_DIR";
 var DEFAULT_DUMP_DIR = join23(tmpdir4(), "opencode-antigravity-gemini-dumps");
 var DUMP_DIR_MODE = 448;
@@ -36321,8 +36479,7 @@ function createGeminiDumpState(options = {}) {
       enabled = next;
     },
     dumpRequest: (input2) => enabled ? writeGeminiDump(input2) : null,
-    buildStatusSummary: (input2) => renderGeminiDumpStatus(input2?.enabled ?? enabled),
-    executeCommand: (input2) => renderGeminiDumpCommand(input2.argumentsText, input2.enabled ?? enabled)
+    buildStatusSummary: (input2) => renderGeminiDumpStatus(input2?.enabled ?? enabled)
   };
 }
 var legacyDumpState = createGeminiDumpState();
@@ -36335,15 +36492,6 @@ function setGeminiDumpEnabled(enabled) {
 function getGeminiDumpDirectory() {
   return process.env[DUMP_DIR_ENV] || DEFAULT_DUMP_DIR;
 }
-function parseGeminiDumpCommandAction(argumentsText) {
-  const normalized = argumentsText.trim().split(/\s+/).filter(Boolean);
-  if (normalized.length === 0) return { type: "status" };
-  if (normalized.length === 1 && normalized[0] === "on")
-    return { type: "enable" };
-  if (normalized.length === 1 && normalized[0] === "off")
-    return { type: "disable" };
-  return { type: "usage" };
-}
 function renderGeminiDumpStatus(enabled) {
   return [
     DUMP_STATUS_TITLE,
@@ -36354,23 +36502,6 @@ function renderGeminiDumpStatus(enabled) {
     "- Warning: dumps contain prompt/session content; turn this off after debugging"
   ].join("\n");
 }
-function renderGeminiDumpCommand(argumentsText, enabled) {
-  const action = parseGeminiDumpCommandAction(argumentsText);
-  if (action.type === "status") return renderGeminiDumpStatus(enabled);
-  if (action.type === "enable") {
-    return [DUMP_ENABLED_TITLE, "", renderGeminiDumpStatus(true)].join("\n");
-  }
-  if (action.type === "disable") {
-    return [DUMP_DISABLED_TITLE, "", renderGeminiDumpStatus(false)].join("\n");
-  }
-  return [
-    DUMP_USAGE_TITLE,
-    "",
-    DUMP_USAGE,
-    "",
-    renderGeminiDumpStatus(enabled)
-  ].join("\n");
-}
 function hashText2(value) {
   return createHash15("sha256").update(value).digest("hex");
 }
@@ -37035,31 +37166,6 @@ function createSessionRecoveryHook(ctx, config) {
 // src/plugin/request-helpers.ts
 var log10 = createLogger4("request-helpers");
 var ANTIGRAVITY_PREVIEW_LINK = "https://goo.gle/enable-preview-features";
-var UNSUPPORTED_CONSTRAINTS = [
-  "minLength",
-  "maxLength",
-  "exclusiveMinimum",
-  "exclusiveMaximum",
-  "pattern",
-  "minItems",
-  "maxItems",
-  "format",
-  "default",
-  "examples"
-];
-var UNSUPPORTED_KEYWORDS = [
-  ...UNSUPPORTED_CONSTRAINTS,
-  "$schema",
-  "$defs",
-  "definitions",
-  "const",
-  "$ref",
-  "additionalProperties",
-  "propertyNames",
-  "title",
-  "$id",
-  "$comment"
-];
 function appendDescriptionHint(schema, hint) {
   if (!schema || typeof schema !== "object") {
     return schema;
@@ -37089,23 +37195,6 @@ function convertRefsToHints(schema) {
   }
   return result;
 }
-function convertConstToEnum(schema) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  if (Array.isArray(schema)) {
-    return schema.map((item) => convertConstToEnum(item));
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(schema)) {
-    if (key === "const" && !schema.enum) {
-      result.enum = [value];
-    } else {
-      result[key] = convertConstToEnum(value);
-    }
-  }
-  return result;
-}
 function addEnumHints(schema) {
   if (!schema || typeof schema !== "object") {
     return schema;
@@ -37114,7 +37203,7 @@ function addEnumHints(schema) {
     return schema.map((item) => addEnumHints(item));
   }
   let result = { ...schema };
-  if (Array.isArray(result.enum) && result.enum.length > 1 && result.enum.length <= 10) {
+  if (Array.isArray(result.enum) && result.enum.every((value) => typeof value === "string") && result.enum.length > 1 && result.enum.length <= 10) {
     const vals = result.enum.map((v) => String(v)).join(", ");
     result = appendDescriptionHint(result, `Allowed: ${vals}`);
   }
@@ -37125,213 +37214,6 @@ function addEnumHints(schema) {
   }
   return result;
 }
-function addAdditionalPropertiesHints(schema) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  if (Array.isArray(schema)) {
-    return schema.map((item) => addAdditionalPropertiesHints(item));
-  }
-  let result = { ...schema };
-  if (result.additionalProperties === false) {
-    result = appendDescriptionHint(result, "No extra properties allowed");
-  }
-  for (const [key, value] of Object.entries(result)) {
-    if (key !== "additionalProperties" && typeof value === "object" && value !== null) {
-      result[key] = addAdditionalPropertiesHints(value);
-    }
-  }
-  return result;
-}
-function moveConstraintsToDescription(schema) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  if (Array.isArray(schema)) {
-    return schema.map((item) => moveConstraintsToDescription(item));
-  }
-  let result = { ...schema };
-  for (const constraint of UNSUPPORTED_CONSTRAINTS) {
-    if (result[constraint] !== void 0 && typeof result[constraint] !== "object") {
-      result = appendDescriptionHint(
-        result,
-        `${constraint}: ${result[constraint]}`
-      );
-    }
-  }
-  for (const [key, value] of Object.entries(result)) {
-    if (typeof value === "object" && value !== null) {
-      result[key] = moveConstraintsToDescription(value);
-    }
-  }
-  return result;
-}
-function mergeAllOf(schema) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  if (Array.isArray(schema)) {
-    return schema.map((item) => mergeAllOf(item));
-  }
-  const result = { ...schema };
-  if (Array.isArray(result.allOf)) {
-    const merged = {};
-    const mergedRequired = [];
-    for (const item of result.allOf) {
-      if (!item || typeof item !== "object") continue;
-      if (item.properties && typeof item.properties === "object") {
-        merged.properties = { ...merged.properties, ...item.properties };
-      }
-      if (Array.isArray(item.required)) {
-        for (const req of item.required) {
-          if (!mergedRequired.includes(req)) {
-            mergedRequired.push(req);
-          }
-        }
-      }
-      for (const [key, value] of Object.entries(item)) {
-        if (key !== "properties" && key !== "required" && merged[key] === void 0) {
-          merged[key] = value;
-        }
-      }
-    }
-    if (merged.properties) {
-      result.properties = { ...result.properties, ...merged.properties };
-    }
-    if (mergedRequired.length > 0) {
-      const existingRequired = Array.isArray(result.required) ? result.required : [];
-      result.required = Array.from(
-        /* @__PURE__ */ new Set([...existingRequired, ...mergedRequired])
-      );
-    }
-    for (const [key, value] of Object.entries(merged)) {
-      if (key !== "properties" && key !== "required" && result[key] === void 0) {
-        result[key] = value;
-      }
-    }
-    delete result.allOf;
-  }
-  for (const [key, value] of Object.entries(result)) {
-    if (typeof value === "object" && value !== null) {
-      result[key] = mergeAllOf(value);
-    }
-  }
-  return result;
-}
-function scoreSchemaOption(schema) {
-  if (!schema || typeof schema !== "object") {
-    return { score: 0, typeName: "unknown" };
-  }
-  const type = schema.type;
-  if (type === "object" || schema.properties) {
-    return { score: 3, typeName: "object" };
-  }
-  if (type === "array" || schema.items) {
-    return { score: 2, typeName: "array" };
-  }
-  if (type && type !== "null") {
-    return { score: 1, typeName: type };
-  }
-  return { score: 0, typeName: type || "null" };
-}
-function tryMergeEnumFromUnion(options) {
-  if (!Array.isArray(options) || options.length === 0) {
-    return null;
-  }
-  const enumValues = [];
-  for (const option of options) {
-    if (!option || typeof option !== "object") {
-      return null;
-    }
-    if (option.const !== void 0) {
-      enumValues.push(String(option.const));
-      continue;
-    }
-    if (Array.isArray(option.enum) && option.enum.length === 1) {
-      enumValues.push(String(option.enum[0]));
-      continue;
-    }
-    if (Array.isArray(option.enum) && option.enum.length > 0) {
-      for (const val of option.enum) {
-        enumValues.push(String(val));
-      }
-      continue;
-    }
-    if (option.properties || option.items || option.anyOf || option.oneOf || option.allOf) {
-      return null;
-    }
-    if (option.type && !option.const && !option.enum) {
-      return null;
-    }
-  }
-  return enumValues.length > 0 ? enumValues : null;
-}
-function flattenAnyOfOneOf(schema) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  if (Array.isArray(schema)) {
-    return schema.map((item) => flattenAnyOfOneOf(item));
-  }
-  let result = { ...schema };
-  for (const unionKey of ["anyOf", "oneOf"]) {
-    if (Array.isArray(result[unionKey]) && result[unionKey].length > 0) {
-      const options = result[unionKey];
-      const parentDesc = typeof result.description === "string" ? result.description : "";
-      const mergedEnum = tryMergeEnumFromUnion(options);
-      if (mergedEnum !== null) {
-        const { [unionKey]: _2, ...rest2 } = result;
-        result = {
-          ...rest2,
-          type: "string",
-          enum: mergedEnum
-        };
-        if (parentDesc) {
-          result.description = parentDesc;
-        }
-        continue;
-      }
-      let bestIdx = 0;
-      let bestScore = -1;
-      const allTypes = [];
-      for (let i = 0; i < options.length; i++) {
-        const { score, typeName } = scoreSchemaOption(options[i]);
-        if (typeName) {
-          allTypes.push(typeName);
-        }
-        if (score > bestScore) {
-          bestScore = score;
-          bestIdx = i;
-        }
-      }
-      let selected = flattenAnyOfOneOf(options[bestIdx]) || { type: "string" };
-      if (parentDesc) {
-        const childDesc = typeof selected.description === "string" ? selected.description : "";
-        if (childDesc && childDesc !== parentDesc) {
-          selected = {
-            ...selected,
-            description: `${parentDesc} (${childDesc})`
-          };
-        } else if (!childDesc) {
-          selected = { ...selected, description: parentDesc };
-        }
-      }
-      if (allTypes.length > 1) {
-        const uniqueTypes = Array.from(new Set(allTypes));
-        const hint = `Accepts: ${uniqueTypes.join(" | ")}`;
-        selected = appendDescriptionHint(selected, hint);
-      }
-      const { [unionKey]: _, description: __, ...rest } = result;
-      result = { ...rest, ...selected };
-    }
-  }
-  for (const [key, value] of Object.entries(result)) {
-    if (typeof value === "object" && value !== null) {
-      result[key] = flattenAnyOfOneOf(value);
-    }
-  }
-  return result;
-}
 function flattenTypeArrays(schema, nullableFields, currentPath) {
   if (!schema || typeof schema !== "object") {
     return schema;
@@ -37400,62 +37282,6 @@ function flattenTypeArrays(schema, nullableFields, currentPath) {
   }
   return result;
 }
-function removeUnsupportedKeywords(schema, insideProperties = false) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  if (Array.isArray(schema)) {
-    return schema.map((item) => removeUnsupportedKeywords(item, false));
-  }
-  const result = {};
-  for (const [key, value] of Object.entries(schema)) {
-    if (!insideProperties && UNSUPPORTED_KEYWORDS.includes(key)) {
-      continue;
-    }
-    if (typeof value === "object" && value !== null) {
-      if (key === "properties") {
-        const propertiesResult = {};
-        for (const [propName, propSchema] of Object.entries(value)) {
-          propertiesResult[propName] = removeUnsupportedKeywords(
-            propSchema,
-            false
-          );
-        }
-        result[key] = propertiesResult;
-      } else {
-        result[key] = removeUnsupportedKeywords(value, false);
-      }
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-function cleanupRequiredFields(schema) {
-  if (!schema || typeof schema !== "object") {
-    return schema;
-  }
-  if (Array.isArray(schema)) {
-    return schema.map((item) => cleanupRequiredFields(item));
-  }
-  const result = { ...schema };
-  if (Array.isArray(result.required) && result.properties && typeof result.properties === "object") {
-    const validRequired = result.required.filter(
-      (req) => Object.hasOwn(result.properties, req)
-    );
-    if (validRequired.length === 0) {
-      delete result.required;
-    } else if (validRequired.length !== result.required.length) {
-      result.required = validRequired;
-    }
-  }
-  for (const [key, value] of Object.entries(result)) {
-    if (typeof value === "object" && value !== null) {
-      result[key] = cleanupRequiredFields(value);
-    }
-  }
-  return result;
-}
 function addEmptySchemaPlaceholder(schema) {
   if (!schema || typeof schema !== "object") {
     return schema;
@@ -37488,19 +37314,11 @@ function cleanJSONSchemaForAntigravity(schema) {
   if (!schema || typeof schema !== "object") {
     return schema;
   }
-  let result = schema;
-  result = convertRefsToHints(result);
-  result = convertConstToEnum(result);
+  let result = convertRefsToHints(schema);
   result = addEnumHints(result);
-  result = addAdditionalPropertiesHints(result);
-  result = moveConstraintsToDescription(result);
-  result = mergeAllOf(result);
-  result = flattenAnyOfOneOf(result);
   result = flattenTypeArrays(result);
-  result = removeUnsupportedKeywords(result);
-  result = cleanupRequiredFields(result);
   result = addEmptySchemaPlaceholder(result);
-  return result;
+  return toGeminiSchema(result, { claudeValidated: true });
 }
 var DEFAULT_THINKING_BUDGET = 16e3;
 function isThinkingCapableModel2(modelName) {
@@ -40196,10 +40014,10 @@ function prepareAntigravityRequestIn(wire, input2, init, accessToken, projectId,
             const normalizeSchema = (schema) => {
               const createPlaceholderSchema = (base = {}) => ({
                 ...base,
-                type: "object",
+                type: "OBJECT",
                 properties: {
                   [EMPTY_SCHEMA_PLACEHOLDER_NAME]: {
-                    type: "boolean",
+                    type: "BOOLEAN",
                     description: EMPTY_SCHEMA_PLACEHOLDER_DESCRIPTION
                   }
                 },
@@ -40215,11 +40033,11 @@ function prepareAntigravityRequestIn(wire, input2, init, accessToken, projectId,
                 return createPlaceholderSchema();
               }
               const hasProperties = cleaned.properties && typeof cleaned.properties === "object" && Object.keys(cleaned.properties).length > 0;
-              cleaned.type = "object";
+              cleaned.type = "OBJECT";
               if (!hasProperties) {
                 cleaned.properties = {
                   [EMPTY_SCHEMA_PLACEHOLDER_NAME]: {
-                    type: "boolean",
+                    type: "BOOLEAN",
                     description: EMPTY_SCHEMA_PLACEHOLDER_DESCRIPTION
                   }
                 };