opencode-antigravity-auth 1.2.2 → 1.2.4

package/dist/src/plugin/request-helpers.js

@@ -1,4 +1,495 @@
+import { KEEP_THINKING_BLOCKS } from "../constants.js";
 const ANTIGRAVITY_PREVIEW_LINK = "https://goo.gle/enable-preview-features"; // TODO: Update to Antigravity link if available
+// ============================================================================
+// JSON SCHEMA CLEANING FOR ANTIGRAVITY API
+// Ported from CLIProxyAPI's CleanJSONSchemaForAntigravity (gemini_schema.go)
+// ============================================================================
+/**
+ * Unsupported constraint keywords that should be moved to description hints.
+ * Claude/Gemini reject these in VALIDATED mode.
+ */
+const UNSUPPORTED_CONSTRAINTS = [
+    "minLength", "maxLength", "exclusiveMinimum", "exclusiveMaximum",
+    "pattern", "minItems", "maxItems", "format",
+    "default", "examples",
+];
+/**
+ * Keywords that should be removed after hint extraction.
+ */
+const UNSUPPORTED_KEYWORDS = [
+    ...UNSUPPORTED_CONSTRAINTS,
+    "$schema", "$defs", "definitions", "const", "$ref", "additionalProperties",
+    "propertyNames", "title", "$id", "$comment",
+];
+/**
+ * Appends a hint to a schema's description field.
+ */
+function appendDescriptionHint(schema, hint) {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    const existing = typeof schema.description === "string" ? schema.description : "";
+    const newDescription = existing ? `${existing} (${hint})` : hint;
+    return { ...schema, description: newDescription };
+}
+/**
+ * Phase 1a: Converts $ref to description hints.
+ * $ref: "#/$defs/Foo" → { type: "object", description: "See: Foo" }
+ */
+function convertRefsToHints(schema) {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map(item => convertRefsToHints(item));
+    }
+    // If this object has $ref, replace it with a hint
+    if (typeof schema.$ref === "string") {
+        const refVal = schema.$ref;
+        const defName = refVal.includes("/") ? refVal.split("/").pop() : refVal;
+        const hint = `See: ${defName}`;
+        const existingDesc = typeof schema.description === "string" ? schema.description : "";
+        const newDescription = existingDesc ? `${existingDesc} (${hint})` : hint;
+        return { type: "object", description: newDescription };
+    }
+    // Recursively process all properties
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        result[key] = convertRefsToHints(value);
+    }
+    return result;
+}
+/**
+ * Phase 1b: Converts const to enum.
+ * { const: "foo" } → { enum: ["foo"] }
+ */
+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;
+}
+/**
+ * Phase 1c: Adds enum hints to description.
+ * { enum: ["a", "b", "c"] } → adds "(Allowed: a, b, c)" to description
+ */
+function addEnumHints(schema) {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map(item => addEnumHints(item));
+    }
+    let result = { ...schema };
+    // Add enum hint if enum has 2-10 items
+    if (Array.isArray(result.enum) && result.enum.length > 1 && result.enum.length <= 10) {
+        const vals = result.enum.map((v) => String(v)).join(", ");
+        result = appendDescriptionHint(result, `Allowed: ${vals}`);
+    }
+    // Recursively process nested objects
+    for (const [key, value] of Object.entries(result)) {
+        if (key !== "enum" && typeof value === "object" && value !== null) {
+            result[key] = addEnumHints(value);
+        }
+    }
+    return result;
+}
+/**
+ * Phase 1d: Adds additionalProperties hints.
+ * { additionalProperties: false } → adds "(No extra properties allowed)" to description
+ */
+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");
+    }
+    // Recursively process nested objects
+    for (const [key, value] of Object.entries(result)) {
+        if (key !== "additionalProperties" && typeof value === "object" && value !== null) {
+            result[key] = addAdditionalPropertiesHints(value);
+        }
+    }
+    return result;
+}
+/**
+ * Phase 1e: Moves unsupported constraints to description hints.
+ * { minLength: 1, maxLength: 100 } → adds "(minLength: 1) (maxLength: 100)" to description
+ */
+function moveConstraintsToDescription(schema) {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map(item => moveConstraintsToDescription(item));
+    }
+    let result = { ...schema };
+    // Move constraint values to description
+    for (const constraint of UNSUPPORTED_CONSTRAINTS) {
+        if (result[constraint] !== undefined && typeof result[constraint] !== "object") {
+            result = appendDescriptionHint(result, `${constraint}: ${result[constraint]}`);
+        }
+    }
+    // Recursively process nested objects
+    for (const [key, value] of Object.entries(result)) {
+        if (typeof value === "object" && value !== null) {
+            result[key] = moveConstraintsToDescription(value);
+        }
+    }
+    return result;
+}
+/**
+ * Phase 2a: Merges allOf schemas into a single object.
+ * { allOf: [{ properties: { a: ... } }, { properties: { b: ... } }] }
+ * → { properties: { a: ..., b: ... } }
+ */
+function mergeAllOf(schema) {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map(item => mergeAllOf(item));
+    }
+    let result = { ...schema };
+    // If this object has allOf, merge its contents
+    if (Array.isArray(result.allOf)) {
+        const merged = {};
+        const mergedRequired = [];
+        for (const item of result.allOf) {
+            if (!item || typeof item !== "object")
+                continue;
+            // Merge properties
+            if (item.properties && typeof item.properties === "object") {
+                merged.properties = { ...merged.properties, ...item.properties };
+            }
+            // Merge required arrays
+            if (Array.isArray(item.required)) {
+                for (const req of item.required) {
+                    if (!mergedRequired.includes(req)) {
+                        mergedRequired.push(req);
+                    }
+                }
+            }
+            // Copy other fields from allOf items
+            for (const [key, value] of Object.entries(item)) {
+                if (key !== "properties" && key !== "required" && merged[key] === undefined) {
+                    merged[key] = value;
+                }
+            }
+        }
+        // Apply merged content to result
+        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(new Set([...existingRequired, ...mergedRequired]));
+        }
+        // Copy other merged fields
+        for (const [key, value] of Object.entries(merged)) {
+            if (key !== "properties" && key !== "required" && result[key] === undefined) {
+                result[key] = value;
+            }
+        }
+        delete result.allOf;
+    }
+    // Recursively process nested objects
+    for (const [key, value] of Object.entries(result)) {
+        if (typeof value === "object" && value !== null) {
+            result[key] = mergeAllOf(value);
+        }
+    }
+    return result;
+}
+/**
+ * Scores a schema option for selection in anyOf/oneOf flattening.
+ * Higher score = more preferred.
+ */
+function scoreSchemaOption(schema) {
+    if (!schema || typeof schema !== "object") {
+        return { score: 0, typeName: "unknown" };
+    }
+    const type = schema.type;
+    // Object or has properties = highest priority
+    if (type === "object" || schema.properties) {
+        return { score: 3, typeName: "object" };
+    }
+    // Array or has items = second priority
+    if (type === "array" || schema.items) {
+        return { score: 2, typeName: "array" };
+    }
+    // Any other non-null type
+    if (type && type !== "null") {
+        return { score: 1, typeName: type };
+    }
+    // Null or no type
+    return { score: 0, typeName: type || "null" };
+}
+/**
+ * Phase 2b: Flattens anyOf/oneOf to the best option with type hints.
+ * { anyOf: [{ type: "string" }, { type: "number" }] }
+ * → { type: "string", description: "(Accepts: string | number)" }
+ */
+function flattenAnyOfOneOf(schema) {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map(item => flattenAnyOfOneOf(item));
+    }
+    let result = { ...schema };
+    // Process anyOf or oneOf
+    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 : "";
+            // Score each option and find the best
+            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;
+                }
+            }
+            // Select the best option and flatten it recursively
+            let selected = flattenAnyOfOneOf(options[bestIdx]) || { type: "string" };
+            // Preserve parent description
+            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);
+            }
+            // Replace result with selected schema, preserving other fields
+            const { [unionKey]: _, description: __, ...rest } = result;
+            result = { ...rest, ...selected };
+        }
+    }
+    // Recursively process nested objects
+    for (const [key, value] of Object.entries(result)) {
+        if (typeof value === "object" && value !== null) {
+            result[key] = flattenAnyOfOneOf(value);
+        }
+    }
+    return result;
+}
+/**
+ * Phase 2c: Flattens type arrays to single type with nullable hint.
+ * { type: ["string", "null"] } → { type: "string", description: "(nullable)" }
+ */
+function flattenTypeArrays(schema, nullableFields, currentPath) {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map((item, idx) => flattenTypeArrays(item, nullableFields, `${currentPath || ""}[${idx}]`));
+    }
+    let result = { ...schema };
+    const localNullableFields = nullableFields || new Map();
+    // Handle type array
+    if (Array.isArray(result.type)) {
+        const types = result.type;
+        const hasNull = types.includes("null");
+        const nonNullTypes = types.filter(t => t !== "null" && t);
+        // Select first non-null type, or "string" as fallback
+        const firstType = nonNullTypes.length > 0 ? nonNullTypes[0] : "string";
+        result.type = firstType;
+        // Add hint for multiple types
+        if (nonNullTypes.length > 1) {
+            result = appendDescriptionHint(result, `Accepts: ${nonNullTypes.join(" | ")}`);
+        }
+        // Add nullable hint
+        if (hasNull) {
+            result = appendDescriptionHint(result, "nullable");
+        }
+    }
+    // Recursively process properties
+    if (result.properties && typeof result.properties === "object") {
+        const newProps = {};
+        for (const [propKey, propValue] of Object.entries(result.properties)) {
+            const propPath = currentPath ? `${currentPath}.properties.${propKey}` : `properties.${propKey}`;
+            const processed = flattenTypeArrays(propValue, localNullableFields, propPath);
+            newProps[propKey] = processed;
+            // Track nullable fields for required array cleanup
+            if (processed && typeof processed === "object" &&
+                typeof processed.description === "string" &&
+                processed.description.includes("nullable")) {
+                const objectPath = currentPath || "";
+                const existing = localNullableFields.get(objectPath) || [];
+                existing.push(propKey);
+                localNullableFields.set(objectPath, existing);
+            }
+        }
+        result.properties = newProps;
+    }
+    // Remove nullable fields from required array
+    if (Array.isArray(result.required) && !nullableFields) {
+        // Only at root level, filter out nullable fields
+        const nullableAtRoot = localNullableFields.get("") || [];
+        if (nullableAtRoot.length > 0) {
+            result.required = result.required.filter((r) => !nullableAtRoot.includes(r));
+            if (result.required.length === 0) {
+                delete result.required;
+            }
+        }
+    }
+    // Recursively process other nested objects
+    for (const [key, value] of Object.entries(result)) {
+        if (key !== "properties" && typeof value === "object" && value !== null) {
+            result[key] = flattenTypeArrays(value, localNullableFields, `${currentPath || ""}.${key}`);
+        }
+    }
+    return result;
+}
+/**
+ * Phase 3: Removes unsupported keywords after hints have been extracted.
+ */
+function removeUnsupportedKeywords(schema) {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map(item => removeUnsupportedKeywords(item));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(schema)) {
+        // Skip unsupported keywords
+        if (UNSUPPORTED_KEYWORDS.includes(key)) {
+            continue;
+        }
+        // Recursively process nested objects
+        if (typeof value === "object" && value !== null) {
+            result[key] = removeUnsupportedKeywords(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Phase 3b: Cleans up required fields - removes entries that don't exist in properties.
+ */
+function cleanupRequiredFields(schema) {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map(item => cleanupRequiredFields(item));
+    }
+    let result = { ...schema };
+    // Clean up required array if properties exist
+    if (Array.isArray(result.required) && result.properties && typeof result.properties === "object") {
+        const validRequired = result.required.filter((req) => Object.prototype.hasOwnProperty.call(result.properties, req));
+        if (validRequired.length === 0) {
+            delete result.required;
+        }
+        else if (validRequired.length !== result.required.length) {
+            result.required = validRequired;
+        }
+    }
+    // Recursively process nested objects
+    for (const [key, value] of Object.entries(result)) {
+        if (typeof value === "object" && value !== null) {
+            result[key] = cleanupRequiredFields(value);
+        }
+    }
+    return result;
+}
+/**
+ * Phase 4: Adds placeholder property for empty object schemas.
+ * Claude VALIDATED mode requires at least one property.
+ */
+function addEmptySchemaPlaceholder(schema) {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    if (Array.isArray(schema)) {
+        return schema.map(item => addEmptySchemaPlaceholder(item));
+    }
+    let result = { ...schema };
+    // Check if this is an empty object schema
+    if (result.type === "object") {
+        const hasProperties = result.properties &&
+            typeof result.properties === "object" &&
+            Object.keys(result.properties).length > 0;
+        if (!hasProperties) {
+            result.properties = {
+                reason: {
+                    type: "string",
+                    description: "Brief explanation of why you are calling this tool",
+                },
+            };
+            result.required = ["reason"];
+        }
+    }
+    // Recursively process nested objects
+    for (const [key, value] of Object.entries(result)) {
+        if (typeof value === "object" && value !== null) {
+            result[key] = addEmptySchemaPlaceholder(value);
+        }
+    }
+    return result;
+}
+/**
+ * Cleans a JSON schema for Antigravity API compatibility.
+ * Transforms unsupported features into description hints while preserving semantic information.
+ *
+ * Ported from CLIProxyAPI's CleanJSONSchemaForAntigravity (gemini_schema.go)
+ */
+export function cleanJSONSchemaForAntigravity(schema) {
+    if (!schema || typeof schema !== "object") {
+        return schema;
+    }
+    let result = schema;
+    // Phase 1: Convert and add hints
+    result = convertRefsToHints(result);
+    result = convertConstToEnum(result);
+    result = addEnumHints(result);
+    result = addAdditionalPropertiesHints(result);
+    result = moveConstraintsToDescription(result);
+    // Phase 2: Flatten complex structures
+    result = mergeAllOf(result);
+    result = flattenAnyOfOneOf(result);
+    result = flattenTypeArrays(result);
+    // Phase 3: Cleanup
+    result = removeUnsupportedKeywords(result);
+    result = cleanupRequiredFields(result);
+    // Phase 4: Add placeholder for empty object schemas
+    result = addEmptySchemaPlaceholder(result);
+    return result;
+}
 /**
  * Default token budget for thinking/reasoning. 16000 tokens provides sufficient
  * space for complex reasoning while staying within typical model limits.
@@ -60,18 +551,70 @@ export function resolveThinkingConfig(userConfig, isThinkingModel, _isClaudeMode
  */
 function isThinkingPart(part) {
     return part.type === "thinking"
+        || part.type === "redacted_thinking"
         || part.type === "reasoning"
         || part.thinking !== undefined
         || part.thought === true;
 }
+/**
+ * Checks if a part has a signature field (thinking block signature).
+ * Used to detect foreign thinking blocks that might have unknown type values.
+ */
+function hasSignatureField(part) {
+    return part.signature !== undefined || part.thoughtSignature !== undefined;
+}
+/**
+ * Checks if a part is a tool block (tool_use or tool_result).
+ * Tool blocks must never be filtered - they're required for tool call/result pairing.
+ * Handles multiple formats:
+ * - Anthropic: { type: "tool_use" }, { type: "tool_result", tool_use_id }
+ * - Nested: { tool_result: { tool_use_id } }, { tool_use: { id } }
+ * - Gemini: { functionCall }, { functionResponse }
+ */
+function isToolBlock(part) {
+    return part.type === "tool_use"
+        || part.type === "tool_result"
+        || part.tool_use_id !== undefined
+        || part.tool_call_id !== undefined
+        || part.tool_result !== undefined
+        || part.tool_use !== undefined
+        || part.toolUse !== undefined
+        || part.functionCall !== undefined
+        || part.functionResponse !== undefined;
+}
+/**
+ * Unconditionally strips ALL thinking/reasoning blocks from a content array.
+ * Used for Claude models to avoid signature validation errors entirely.
+ * Claude will generate fresh thinking for each turn.
+ */
+function stripAllThinkingBlocks(contentArray) {
+    return contentArray.filter(item => {
+        if (!item || typeof item !== "object")
+            return true;
+        if (isToolBlock(item))
+            return true;
+        if (isThinkingPart(item))
+            return false;
+        if (hasSignatureField(item))
+            return false;
+        return true;
+    });
+}
 /**
  * Removes trailing thinking blocks from a content array.
  * Claude API requires that assistant messages don't end with thinking blocks.
  * Only removes unsigned thinking blocks; preserves those with valid signatures.
  */
-function removeTrailingThinkingBlocks(contentArray) {
+function removeTrailingThinkingBlocks(contentArray, sessionId, getCachedSignatureFn) {
     const result = [...contentArray];
-    while (result.length > 0 && isThinkingPart(result[result.length - 1]) && !hasValidSignature(result[result.length - 1])) {
+    while (result.length > 0 && isThinkingPart(result[result.length - 1])) {
+        const part = result[result.length - 1];
+        const isValid = sessionId && getCachedSignatureFn
+            ? isOurCachedSignature(part, sessionId, getCachedSignatureFn)
+            : hasValidSignature(part);
+        if (isValid) {
+            break;
+        }
         result.pop();
     }
     return result;
@@ -84,6 +627,33 @@ function hasValidSignature(part) {
     const signature = part.thought === true ? part.thoughtSignature : part.signature;
     return typeof signature === "string" && signature.length >= 50;
 }
+/**
+ * Gets the signature from a thinking part, if present.
+ */
+function getSignature(part) {
+    const signature = part.thought === true ? part.thoughtSignature : part.signature;
+    return typeof signature === "string" ? signature : undefined;
+}
+/**
+ * Checks if a thinking part's signature was generated by our plugin (exists in our cache).
+ * This prevents accepting signatures from other providers (e.g., direct Anthropic API, OpenAI)
+ * which would cause "Invalid signature" errors when sent to Antigravity Claude.
+ */
+function isOurCachedSignature(part, sessionId, getCachedSignatureFn) {
+    if (!sessionId || !getCachedSignatureFn) {
+        return false;
+    }
+    const text = getThinkingText(part);
+    if (!text) {
+        return false;
+    }
+    const partSignature = getSignature(part);
+    if (!partSignature) {
+        return false;
+    }
+    const cachedSignature = getCachedSignatureFn(sessionId, text);
+    return cachedSignature === partSignature;
+}
 /**
  * Gets the text content from a thinking part.
  */
@@ -92,7 +662,11 @@ function getThinkingText(part) {
         return part.text;
     if (typeof part.thinking === "string")
         return part.thinking;
-    // Some SDKs wrap thinking in an object like { text: "...", cache_control: {...} }
+    if (part.text && typeof part.text === "object") {
+        const maybeText = part.text.text;
+        if (typeof maybeText === "string")
+            return maybeText;
+    }
     if (part.thinking && typeof part.thinking === "object") {
         const maybeText = part.thinking.text ?? part.thinking.thinking;
         if (typeof maybeText === "string")
@@ -128,7 +702,6 @@ function sanitizeThinkingPart(part) {
     if (part.thought === true) {
         const sanitized = { thought: true };
         if (part.text !== undefined) {
-            // If text is wrapped, extract the inner string.
             if (typeof part.text === "object" && part.text !== null) {
                 const maybeText = part.text.text;
                 sanitized.text = typeof maybeText === "string" ? maybeText : part.text;
@@ -141,9 +714,9 @@ function sanitizeThinkingPart(part) {
             sanitized.thoughtSignature = part.thoughtSignature;
         return sanitized;
     }
-    // Anthropic-style thinking blocks: { type: "thinking", thinking, signature }
-    if (part.type === "thinking" || part.thinking !== undefined) {
-        const sanitized = { type: "thinking" };
+    // Anthropic-style thinking/redacted_thinking blocks: { type: "thinking"|"redacted_thinking", thinking, signature }
+    if (part.type === "thinking" || part.type === "redacted_thinking" || part.thinking !== undefined) {
+        const sanitized = { type: part.type === "redacted_thinking" ? "redacted_thinking" : "thinking" };
         let thinkingContent = part.thinking ?? part.text;
         if (thinkingContent !== undefined && typeof thinkingContent === "object" && thinkingContent !== null) {
             const maybeText = thinkingContent.text ?? thinkingContent.thinking;
@@ -155,21 +728,48 @@ function sanitizeThinkingPart(part) {
             sanitized.signature = part.signature;
         return sanitized;
     }
+    // Reasoning blocks (OpenCode format): { type: "reasoning", text, signature }
+    if (part.type === "reasoning") {
+        const sanitized = { type: "reasoning" };
+        if (part.text !== undefined) {
+            if (typeof part.text === "object" && part.text !== null) {
+                const maybeText = part.text.text;
+                sanitized.text = typeof maybeText === "string" ? maybeText : part.text;
+            }
+            else {
+                sanitized.text = part.text;
+            }
+        }
+        if (part.signature !== undefined)
+            sanitized.signature = part.signature;
+        return sanitized;
+    }
     // Fallback: strip cache_control recursively.
     return stripCacheControlRecursively(part);
 }
-function filterContentArray(contentArray, sessionId, getCachedSignatureFn) {
+function filterContentArray(contentArray, sessionId, getCachedSignatureFn, isClaudeModel) {
+    // For Claude models, strip thinking blocks by default for reliability
+    // User can opt-in to keep thinking via OPENCODE_ANTIGRAVITY_KEEP_THINKING=1
+    if (isClaudeModel && !KEEP_THINKING_BLOCKS) {
+        return stripAllThinkingBlocks(contentArray);
+    }
     const filtered = [];
     for (const item of contentArray) {
         if (!item || typeof item !== "object") {
             filtered.push(item);
             continue;
         }
-        if (!isThinkingPart(item)) {
+        if (isToolBlock(item)) {
             filtered.push(item);
             continue;
         }
-        if (hasValidSignature(item)) {
+        const isThinking = isThinkingPart(item);
+        const hasSignature = hasSignatureField(item);
+        if (!isThinking && !hasSignature) {
+            filtered.push(item);
+            continue;
+        }
+        if (isOurCachedSignature(item, sessionId, getCachedSignatureFn)) {
             filtered.push(sanitizeThinkingPart(item));
             continue;
         }
@@ -190,63 +790,85 @@ function filterContentArray(contentArray, sessionId, getCachedSignatureFn) {
                 }
             }
         }
-        // Drop unsigned/invalid thinking blocks.
     }
     return filtered;
 }
 /**
- * Filters out unsigned thinking blocks from contents (required by Claude API).
- * Attempts to restore signatures from cache for thinking blocks that lack valid signatures.
+ * Filters thinking blocks from contents unless the signature matches our cache.
+ * Attempts to restore signatures from cache for thinking blocks that lack signatures.
  *
  * @param contents - The contents array from the request
  * @param sessionId - Optional session ID for signature cache lookup
  * @param getCachedSignatureFn - Optional function to retrieve cached signatures
  */
-export function filterUnsignedThinkingBlocks(contents, sessionId, getCachedSignatureFn) {
+export function filterUnsignedThinkingBlocks(contents, sessionId, getCachedSignatureFn, isClaudeModel) {
     return contents.map((content) => {
         if (!content || typeof content !== "object") {
             return content;
         }
-        // Gemini format: contents[].parts[]
         if (Array.isArray(content.parts)) {
-            let filteredParts = filterContentArray(content.parts, sessionId, getCachedSignatureFn);
-            // Remove trailing thinking blocks for model role (assistant equivalent in Gemini)
-            if (content.role === "model") {
-                filteredParts = removeTrailingThinkingBlocks(filteredParts);
-            }
-            return { ...content, parts: filteredParts };
+            const filteredParts = filterContentArray(content.parts, sessionId, getCachedSignatureFn, isClaudeModel);
+            const trimmedParts = content.role === "model" && !isClaudeModel
+                ? removeTrailingThinkingBlocks(filteredParts, sessionId, getCachedSignatureFn)
+                : filteredParts;
+            return { ...content, parts: trimmedParts };
         }
-        // Some Anthropic-style payloads may appear here as contents[].content[]
         if (Array.isArray(content.content)) {
-            let filteredContent = filterContentArray(content.content, sessionId, getCachedSignatureFn);
-            // Claude API requires assistant messages don't end with thinking blocks
-            if (content.role === "assistant") {
-                filteredContent = removeTrailingThinkingBlocks(filteredContent);
-            }
-            return { ...content, content: filteredContent };
+            const isAssistantRole = content.role === "assistant";
+            const filteredContent = filterContentArray(content.content, sessionId, getCachedSignatureFn, isClaudeModel);
+            const trimmedContent = isAssistantRole && !isClaudeModel
+                ? removeTrailingThinkingBlocks(filteredContent, sessionId, getCachedSignatureFn)
+                : filteredContent;
+            return { ...content, content: trimmedContent };
         }
         return content;
     });
 }
 /**
- * Filters thinking blocks from Anthropic-style messages[] payloads.
+ * Filters thinking blocks from Anthropic-style messages[] payloads using cached signatures.
  */
-export function filterMessagesThinkingBlocks(messages, sessionId, getCachedSignatureFn) {
+export function filterMessagesThinkingBlocks(messages, sessionId, getCachedSignatureFn, isClaudeModel) {
     return messages.map((message) => {
         if (!message || typeof message !== "object") {
             return message;
         }
         if (Array.isArray(message.content)) {
-            let filteredContent = filterContentArray(message.content, sessionId, getCachedSignatureFn);
-            // Claude API requires assistant messages don't end with thinking blocks
-            if (message.role === "assistant") {
-                filteredContent = removeTrailingThinkingBlocks(filteredContent);
-            }
-            return { ...message, content: filteredContent };
+            const isAssistantRole = message.role === "assistant";
+            const filteredContent = filterContentArray(message.content, sessionId, getCachedSignatureFn, isClaudeModel);
+            const trimmedContent = isAssistantRole && !isClaudeModel
+                ? removeTrailingThinkingBlocks(filteredContent, sessionId, getCachedSignatureFn)
+                : filteredContent;
+            return { ...message, content: trimmedContent };
         }
         return message;
     });
 }
+export function deepFilterThinkingBlocks(payload, sessionId, getCachedSignatureFn, isClaudeModel) {
+    const visited = new WeakSet();
+    const walk = (value) => {
+        if (!value || typeof value !== "object") {
+            return;
+        }
+        if (visited.has(value)) {
+            return;
+        }
+        visited.add(value);
+        if (Array.isArray(value)) {
+            value.forEach((item) => walk(item));
+            return;
+        }
+        const obj = value;
+        if (Array.isArray(obj.contents)) {
+            obj.contents = filterUnsignedThinkingBlocks(obj.contents, sessionId, getCachedSignatureFn, isClaudeModel);
+        }
+        if (Array.isArray(obj.messages)) {
+            obj.messages = filterMessagesThinkingBlocks(obj.messages, sessionId, getCachedSignatureFn, isClaudeModel);
+        }
+        Object.keys(obj).forEach((key) => walk(obj[key]));
+    };
+    walk(payload);
+    return payload;
+}
 /**
  * Transforms Gemini-style thought parts (thought: true) and Anthropic-style
  * thinking parts (type: "thinking") to reasoning format.