opencode-antigravity-auth 1.1.4 → 1.2.1

package/dist/src/plugin/request.js

@@ -1,7 +1,273 @@
 import crypto from "node:crypto";
 import { ANTIGRAVITY_HEADERS, ANTIGRAVITY_ENDPOINT, } from "../constants";
-import { logAntigravityDebugResponse } from "./debug";
-import { extractThinkingConfig, extractUsageFromSsePayload, extractUsageMetadata, filterUnsignedThinkingBlocks, isThinkingCapableModel, normalizeThinkingConfig, parseAntigravityApiBody, resolveThinkingConfig, rewriteAntigravityPreviewAccessError, transformThinkingParts, } from "./request-helpers";
+import { cacheSignature, getCachedSignature } from "./cache";
+import { DEBUG_MESSAGE_PREFIX, isDebugEnabled, logAntigravityDebugResponse, } from "./debug";
+import { DEFAULT_THINKING_BUDGET, extractThinkingConfig, extractUsageFromSsePayload, extractUsageMetadata, filterUnsignedThinkingBlocks, filterMessagesThinkingBlocks, isThinkingCapableModel, normalizeThinkingConfig, parseAntigravityApiBody, resolveThinkingConfig, rewriteAntigravityPreviewAccessError, transformThinkingParts, } from "./request-helpers";
+/**
+ * Stable session ID for the plugin's lifetime.
+ * This is used for caching thinking signatures across multi-turn conversations.
+ * Generated once at plugin load time and reused for all requests.
+ */
+const PLUGIN_SESSION_ID = `-${crypto.randomUUID()}`;
+// Claude thinking models need a sufficiently large max output token limit when thinking is enabled.
+const CLAUDE_THINKING_MAX_OUTPUT_TOKENS = 64_000;
+const MIN_SIGNATURE_LENGTH = 50;
+const lastSignedThinkingBySessionId = new Map();
+function formatDebugLinesForThinking(lines) {
+    const cleaned = lines
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .slice(-50);
+    return `${DEBUG_MESSAGE_PREFIX}\n${cleaned.map((line) => `- ${line}`).join("\n")}`;
+}
+function injectDebugThinking(response, debugText) {
+    if (!response || typeof response !== "object") {
+        return response;
+    }
+    const resp = response;
+    if (Array.isArray(resp.candidates) && resp.candidates.length > 0) {
+        const candidates = resp.candidates.slice();
+        const first = candidates[0];
+        if (first &&
+            typeof first === "object" &&
+            first.content &&
+            typeof first.content === "object" &&
+            Array.isArray(first.content.parts)) {
+            const parts = [{ thought: true, text: debugText }, ...first.content.parts];
+            candidates[0] = { ...first, content: { ...first.content, parts } };
+            return { ...resp, candidates };
+        }
+        return resp;
+    }
+    if (Array.isArray(resp.content)) {
+        const content = [{ type: "thinking", thinking: debugText }, ...resp.content];
+        return { ...resp, content };
+    }
+    if (!resp.reasoning_content) {
+        return { ...resp, reasoning_content: debugText };
+    }
+    return resp;
+}
+function stripInjectedDebugFromParts(parts) {
+    if (!Array.isArray(parts)) {
+        return parts;
+    }
+    return parts.filter((part) => {
+        if (!part || typeof part !== "object") {
+            return true;
+        }
+        const record = part;
+        const text = typeof record.text === "string"
+            ? record.text
+            : typeof record.thinking === "string"
+                ? record.thinking
+                : undefined;
+        if (text && text.startsWith(DEBUG_MESSAGE_PREFIX)) {
+            return false;
+        }
+        return true;
+    });
+}
+function stripInjectedDebugFromRequestPayload(payload) {
+    const anyPayload = payload;
+    if (Array.isArray(anyPayload.contents)) {
+        anyPayload.contents = anyPayload.contents.map((content) => {
+            if (!content || typeof content !== "object") {
+                return content;
+            }
+            if (Array.isArray(content.parts)) {
+                return { ...content, parts: stripInjectedDebugFromParts(content.parts) };
+            }
+            if (Array.isArray(content.content)) {
+                return { ...content, content: stripInjectedDebugFromParts(content.content) };
+            }
+            return content;
+        });
+    }
+    if (Array.isArray(anyPayload.messages)) {
+        anyPayload.messages = anyPayload.messages.map((message) => {
+            if (!message || typeof message !== "object") {
+                return message;
+            }
+            if (Array.isArray(message.content)) {
+                return { ...message, content: stripInjectedDebugFromParts(message.content) };
+            }
+            return message;
+        });
+    }
+}
+function isGeminiToolUsePart(part) {
+    return !!(part && typeof part === "object" && (part.functionCall || part.tool_use || part.toolUse));
+}
+function isGeminiThinkingPart(part) {
+    return !!(part &&
+        typeof part === "object" &&
+        (part.thought === true || part.type === "thinking" || part.type === "reasoning"));
+}
+function ensureThoughtSignature(part, sessionId) {
+    if (!part || typeof part !== "object") {
+        return part;
+    }
+    const text = typeof part.text === "string" ? part.text : typeof part.thinking === "string" ? part.thinking : "";
+    if (!text) {
+        return part;
+    }
+    if (part.thought === true) {
+        if (!part.thoughtSignature) {
+            const cached = getCachedSignature(sessionId, text);
+            if (cached) {
+                return { ...part, thoughtSignature: cached };
+            }
+        }
+        return part;
+    }
+    if ((part.type === "thinking" || part.type === "reasoning") && !part.signature) {
+        const cached = getCachedSignature(sessionId, text);
+        if (cached) {
+            return { ...part, signature: cached };
+        }
+    }
+    return part;
+}
+function hasSignedThinkingPart(part) {
+    if (!part || typeof part !== "object") {
+        return false;
+    }
+    if (part.thought === true) {
+        return typeof part.thoughtSignature === "string" && part.thoughtSignature.length >= MIN_SIGNATURE_LENGTH;
+    }
+    if (part.type === "thinking" || part.type === "reasoning") {
+        return typeof part.signature === "string" && part.signature.length >= MIN_SIGNATURE_LENGTH;
+    }
+    return false;
+}
+function ensureThinkingBeforeToolUseInContents(contents, sessionId) {
+    return contents.map((content) => {
+        if (!content || typeof content !== "object" || !Array.isArray(content.parts)) {
+            return content;
+        }
+        const role = content.role;
+        if (role !== "model" && role !== "assistant") {
+            return content;
+        }
+        const parts = content.parts;
+        const hasToolUse = parts.some(isGeminiToolUsePart);
+        if (!hasToolUse) {
+            return content;
+        }
+        const thinkingParts = parts.filter(isGeminiThinkingPart).map((p) => ensureThoughtSignature(p, sessionId));
+        const otherParts = parts.filter((p) => !isGeminiThinkingPart(p));
+        const hasSignedThinking = thinkingParts.some(hasSignedThinkingPart);
+        if (hasSignedThinking) {
+            return { ...content, parts: [...thinkingParts, ...otherParts] };
+        }
+        const lastThinking = lastSignedThinkingBySessionId.get(sessionId);
+        if (!lastThinking) {
+            return content;
+        }
+        const injected = {
+            thought: true,
+            text: lastThinking.text,
+            thoughtSignature: lastThinking.signature,
+        };
+        return { ...content, parts: [injected, ...otherParts] };
+    });
+}
+function ensureMessageThinkingSignature(block, sessionId) {
+    if (!block || typeof block !== "object") {
+        return block;
+    }
+    if (block.type !== "thinking" && block.type !== "redacted_thinking") {
+        return block;
+    }
+    if (typeof block.signature === "string" && block.signature.length >= MIN_SIGNATURE_LENGTH) {
+        return block;
+    }
+    const text = typeof block.thinking === "string" ? block.thinking : typeof block.text === "string" ? block.text : "";
+    if (!text) {
+        return block;
+    }
+    const cached = getCachedSignature(sessionId, text);
+    if (cached) {
+        return { ...block, signature: cached };
+    }
+    return block;
+}
+function hasToolUseInContents(contents) {
+    return contents.some((content) => {
+        if (!content || typeof content !== "object" || !Array.isArray(content.parts)) {
+            return false;
+        }
+        return content.parts.some(isGeminiToolUsePart);
+    });
+}
+function hasSignedThinkingInContents(contents) {
+    return contents.some((content) => {
+        if (!content || typeof content !== "object" || !Array.isArray(content.parts)) {
+            return false;
+        }
+        return content.parts.some(hasSignedThinkingPart);
+    });
+}
+function hasToolUseInMessages(messages) {
+    return messages.some((message) => {
+        if (!message || typeof message !== "object" || !Array.isArray(message.content)) {
+            return false;
+        }
+        return message.content.some((block) => block && typeof block === "object" && (block.type === "tool_use" || block.type === "tool_result"));
+    });
+}
+function hasSignedThinkingInMessages(messages) {
+    return messages.some((message) => {
+        if (!message || typeof message !== "object" || !Array.isArray(message.content)) {
+            return false;
+        }
+        return message.content.some((block) => block &&
+            typeof block === "object" &&
+            (block.type === "thinking" || block.type === "redacted_thinking") &&
+            typeof block.signature === "string" &&
+            block.signature.length >= MIN_SIGNATURE_LENGTH);
+    });
+}
+function ensureThinkingBeforeToolUseInMessages(messages, sessionId) {
+    return messages.map((message) => {
+        if (!message || typeof message !== "object" || !Array.isArray(message.content)) {
+            return message;
+        }
+        if (message.role !== "assistant") {
+            return message;
+        }
+        const blocks = message.content;
+        const hasToolUse = blocks.some((b) => b && typeof b === "object" && (b.type === "tool_use" || b.type === "tool_result"));
+        if (!hasToolUse) {
+            return message;
+        }
+        const thinkingBlocks = blocks
+            .filter((b) => b && typeof b === "object" && (b.type === "thinking" || b.type === "redacted_thinking"))
+            .map((b) => ensureMessageThinkingSignature(b, sessionId));
+        const otherBlocks = blocks.filter((b) => !(b && typeof b === "object" && (b.type === "thinking" || b.type === "redacted_thinking")));
+        const hasSignedThinking = thinkingBlocks.some((b) => typeof b.signature === "string" && b.signature.length >= MIN_SIGNATURE_LENGTH);
+        if (hasSignedThinking) {
+            return { ...message, content: [...thinkingBlocks, ...otherBlocks] };
+        }
+        const lastThinking = lastSignedThinkingBySessionId.get(sessionId);
+        if (!lastThinking) {
+            return message;
+        }
+        const injected = {
+            type: "thinking",
+            thinking: lastThinking.text,
+            signature: lastThinking.signature,
+        };
+        return { ...message, content: [injected, ...otherBlocks] };
+    });
+}
+/**
+ * Gets the stable session ID for this plugin instance.
+ */
+export function getPluginSessionId() {
+    return PLUGIN_SESSION_ID;
+}
 function generateSyntheticProjectId() {
     const adjectives = ["useful", "bright", "swift", "calm", "bold"];
     const nouns = ["fuze", "wave", "spark", "flow", "core"];
@@ -46,28 +312,36 @@ function transformStreamingPayload(payload) {
 }
 /**
  * Creates a TransformStream that processes SSE chunks incrementally,
- * transforming each line as it arrives for true streaming support.
+ * transforming each line as it arrives for true real-time streaming support.
+ * Optionally caches thinking signatures for Claude multi-turn conversations.
  */
-function createStreamingTransformer() {
+function createStreamingTransformer(sessionId, debugText) {
     const decoder = new TextDecoder();
     const encoder = new TextEncoder();
     let buffer = "";
+    // Buffer for accumulating thinking text per candidate index (for signature caching)
+    const thoughtBuffer = new Map();
+    const debugState = { injected: false };
     return new TransformStream({
         transform(chunk, controller) {
+            // Decode chunk with stream: true to handle multi-byte characters correctly
             buffer += decoder.decode(chunk, { stream: true });
-            // Process complete lines
+            // Process complete lines immediately for real-time streaming
             const lines = buffer.split("\n");
             // Keep the last incomplete line in buffer
             buffer = lines.pop() || "";
             for (const line of lines) {
-                const transformedLine = transformSseLine(line);
+                // Transform and forward each line immediately
+                const transformedLine = transformSseLine(line, sessionId, thoughtBuffer, debugText, debugState);
                 controller.enqueue(encoder.encode(transformedLine + "\n"));
             }
         },
         flush(controller) {
+            // Flush any remaining bytes from TextDecoder
+            buffer += decoder.decode();
             // Process any remaining data in buffer
             if (buffer) {
-                const transformedLine = transformSseLine(buffer);
+                const transformedLine = transformSseLine(buffer, sessionId, thoughtBuffer, debugText, debugState);
                 controller.enqueue(encoder.encode(transformedLine));
             }
         },
@@ -75,8 +349,9 @@ function createStreamingTransformer() {
 }
 /**
  * Transforms a single SSE line, extracting and transforming the inner response.
+ * Optionally caches thinking signatures for Claude multi-turn support.
  */
-function transformSseLine(line) {
+function transformSseLine(line, sessionId, thoughtBuffer, debugText, debugState) {
     if (!line.startsWith("data:")) {
         return line;
     }
@@ -87,13 +362,67 @@ function transformSseLine(line) {
     try {
         const parsed = JSON.parse(json);
         if (parsed.response !== undefined) {
-            const transformed = transformThinkingParts(parsed.response);
+            if (sessionId && thoughtBuffer) {
+                cacheThinkingSignatures(parsed.response, sessionId, thoughtBuffer);
+            }
+            let response = parsed.response;
+            if (debugText && debugState && !debugState.injected) {
+                response = injectDebugThinking(response, debugText);
+                debugState.injected = true;
+            }
+            const transformed = transformThinkingParts(response);
             return `data: ${JSON.stringify(transformed)}`;
         }
     }
     catch (_) { }
     return line;
 }
+/**
+ * Extracts and caches thinking signatures from a response for Claude multi-turn support.
+ */
+function cacheThinkingSignatures(response, sessionId, thoughtBuffer) {
+    if (!response || typeof response !== "object")
+        return;
+    const resp = response;
+    // Handle Gemini-style candidates array (Claude through Antigravity uses this format)
+    if (Array.isArray(resp.candidates)) {
+        resp.candidates.forEach((candidate, index) => {
+            if (!candidate?.content?.parts)
+                return;
+            candidate.content.parts.forEach((part) => {
+                // Collect thinking text
+                if (part.thought === true || part.type === "thinking") {
+                    const text = part.text || part.thinking || "";
+                    if (text) {
+                        const current = thoughtBuffer.get(index) ?? "";
+                        thoughtBuffer.set(index, current + text);
+                    }
+                }
+                // Cache signature when we receive it
+                if (part.thoughtSignature) {
+                    const fullText = thoughtBuffer.get(index) ?? "";
+                    if (fullText && sessionId) {
+                        cacheSignature(sessionId, fullText, part.thoughtSignature);
+                        lastSignedThinkingBySessionId.set(sessionId, { text: fullText, signature: part.thoughtSignature });
+                    }
+                }
+            });
+        });
+    }
+    // Handle Anthropic-style content array
+    if (Array.isArray(resp.content)) {
+        let thinkingText = "";
+        resp.content.forEach((block) => {
+            if (block?.type === "thinking") {
+                thinkingText += block.thinking || block.text || "";
+            }
+            if (block?.signature && thinkingText && sessionId) {
+                cacheSignature(sessionId, thinkingText, block.signature);
+                lastSignedThinkingBySessionId.set(sessionId, { text: thinkingText, signature: block.signature });
+            }
+        });
+    }
+}
 /**
  * Rewrites OpenAI-style requests into Antigravity shape, normalizing model, headers,
  * optional cached_content, and thinking config. Also toggles streaming mode for SSE actions.
@@ -105,6 +434,8 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
     let toolDebugMissing = 0;
     const toolDebugSummaries = [];
     let toolDebugPayload;
+    let sessionId;
+    let needsSignedThinkingWarmup = false;
     if (!isGenerativeLanguageRequest(input)) {
         return {
             request: input,
@@ -123,12 +454,17 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
         };
     }
     const [, rawModel = "", rawAction = ""] = match;
-    const effectiveModel = rawModel;
-    const upstreamModel = rawModel;
+    const requestedModel = rawModel;
+    let upstreamModel = rawModel;
+    if (upstreamModel === "gemini-2.5-flash-image") {
+        upstreamModel = "gemini-2.5-flash";
+    }
+    const effectiveModel = upstreamModel;
     const streaming = rawAction === STREAM_ACTION;
     const baseEndpoint = endpointOverride ?? ANTIGRAVITY_ENDPOINT;
     const transformedUrl = `${baseEndpoint}/v1internal:${rawAction}${streaming ? "?alt=sse" : ""}`;
     const isClaudeModel = upstreamModel.toLowerCase().includes("claude");
+    const isClaudeThinkingModel = isClaudeModel && upstreamModel.toLowerCase().includes("thinking");
     let body = baseInit.body;
     if (typeof baseInit.body === "string" && baseInit.body) {
         try {
@@ -139,12 +475,68 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                     ...parsedBody,
                     model: effectiveModel,
                 };
+                // Some callers may already send an Antigravity-wrapped body.
+                // We still need to sanitize Claude thinking blocks (remove cache_control)
+                // and attach a stable sessionId so multi-turn signature caching works.
+                const requestRoot = wrappedBody.request;
+                const requestObjects = [];
+                if (requestRoot && typeof requestRoot === "object") {
+                    requestObjects.push(requestRoot);
+                    const nested = requestRoot.request;
+                    if (nested && typeof nested === "object") {
+                        requestObjects.push(nested);
+                    }
+                }
+                if (requestObjects.length > 0) {
+                    sessionId = PLUGIN_SESSION_ID;
+                }
+                for (const req of requestObjects) {
+                    // Use stable session ID for signature caching across multi-turn conversations
+                    req.sessionId = PLUGIN_SESSION_ID;
+                    stripInjectedDebugFromRequestPayload(req);
+                    if (isClaudeModel) {
+                        if (isClaudeThinkingModel && Array.isArray(req.contents)) {
+                            req.contents = ensureThinkingBeforeToolUseInContents(req.contents, PLUGIN_SESSION_ID);
+                        }
+                        if (isClaudeThinkingModel && Array.isArray(req.messages)) {
+                            req.messages = ensureThinkingBeforeToolUseInMessages(req.messages, PLUGIN_SESSION_ID);
+                        }
+                        if (Array.isArray(req.contents)) {
+                            req.contents = filterUnsignedThinkingBlocks(req.contents, PLUGIN_SESSION_ID, getCachedSignature);
+                        }
+                        if (Array.isArray(req.messages)) {
+                            req.messages = filterMessagesThinkingBlocks(req.messages, PLUGIN_SESSION_ID, getCachedSignature);
+                        }
+                    }
+                }
+                if (isClaudeThinkingModel && sessionId) {
+                    const hasToolUse = requestObjects.some((req) => (Array.isArray(req.contents) && hasToolUseInContents(req.contents)) ||
+                        (Array.isArray(req.messages) && hasToolUseInMessages(req.messages)));
+                    const hasSignedThinking = requestObjects.some((req) => (Array.isArray(req.contents) && hasSignedThinkingInContents(req.contents)) ||
+                        (Array.isArray(req.messages) && hasSignedThinkingInMessages(req.messages)));
+                    const hasCachedThinking = lastSignedThinkingBySessionId.has(sessionId);
+                    needsSignedThinkingWarmup = hasToolUse && !hasSignedThinking && !hasCachedThinking;
+                }
                 body = JSON.stringify(wrappedBody);
             }
             else {
                 const requestPayload = { ...parsedBody };
                 const rawGenerationConfig = requestPayload.generationConfig;
                 const extraBody = requestPayload.extra_body;
+                if (isClaudeModel) {
+                    if (!requestPayload.toolConfig) {
+                        requestPayload.toolConfig = {};
+                    }
+                    if (typeof requestPayload.toolConfig === "object" && requestPayload.toolConfig !== null) {
+                        const toolConfig = requestPayload.toolConfig;
+                        if (!toolConfig.functionCallingConfig) {
+                            toolConfig.functionCallingConfig = {};
+                        }
+                        if (typeof toolConfig.functionCallingConfig === "object" && toolConfig.functionCallingConfig !== null) {
+                            toolConfig.functionCallingConfig.mode = "VALIDATED";
+                        }
+                    }
+                }
                 // Resolve thinking configuration based on user settings and model capabilities
                 const userThinkingConfig = extractThinkingConfig(requestPayload, rawGenerationConfig, extraBody);
                 const hasAssistantHistory = Array.isArray(requestPayload.contents) &&
@@ -152,12 +544,37 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                 const finalThinkingConfig = resolveThinkingConfig(userThinkingConfig, isThinkingCapableModel(upstreamModel), isClaudeModel, hasAssistantHistory);
                 const normalizedThinking = normalizeThinkingConfig(finalThinkingConfig);
                 if (normalizedThinking) {
+                    const thinkingBudget = normalizedThinking.thinkingBudget;
+                    const thinkingConfig = isClaudeThinkingModel
+                        ? {
+                            include_thoughts: normalizedThinking.includeThoughts ?? true,
+                            ...(typeof thinkingBudget === "number" && thinkingBudget > 0
+                                ? { thinking_budget: thinkingBudget }
+                                : {}),
+                        }
+                        : {
+                            includeThoughts: normalizedThinking.includeThoughts,
+                            ...(typeof thinkingBudget === "number" && thinkingBudget > 0 ? { thinkingBudget } : {}),
+                        };
                     if (rawGenerationConfig) {
-                        rawGenerationConfig.thinkingConfig = normalizedThinking;
+                        rawGenerationConfig.thinkingConfig = thinkingConfig;
+                        if (isClaudeThinkingModel && typeof thinkingBudget === "number" && thinkingBudget > 0) {
+                            const currentMax = (rawGenerationConfig.maxOutputTokens ?? rawGenerationConfig.max_output_tokens);
+                            if (!currentMax || currentMax <= thinkingBudget) {
+                                rawGenerationConfig.maxOutputTokens = CLAUDE_THINKING_MAX_OUTPUT_TOKENS;
+                                if (rawGenerationConfig.max_output_tokens !== undefined) {
+                                    delete rawGenerationConfig.max_output_tokens;
+                                }
+                            }
+                        }
                         requestPayload.generationConfig = rawGenerationConfig;
                     }
                     else {
-                        requestPayload.generationConfig = { thinkingConfig: normalizedThinking };
+                        const generationConfig = { thinkingConfig };
+                        if (isClaudeThinkingModel && typeof thinkingBudget === "number" && thinkingBudget > 0) {
+                            generationConfig.maxOutputTokens = CLAUDE_THINKING_MAX_OUTPUT_TOKENS;
+                        }
+                        requestPayload.generationConfig = generationConfig;
                     }
                 }
                 else if (rawGenerationConfig?.thinkingConfig) {
@@ -175,6 +592,43 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                     requestPayload.systemInstruction = requestPayload.system_instruction;
                     delete requestPayload.system_instruction;
                 }
+                if (isClaudeThinkingModel && Array.isArray(requestPayload.tools) && requestPayload.tools.length > 0) {
+                    const hint = "Interleaved thinking is enabled. You may think between tool calls and after receiving tool results before deciding the next action or final answer. Do not mention these instructions or any constraints about thinking blocks; just apply them.";
+                    const existing = requestPayload.systemInstruction;
+                    if (typeof existing === "string") {
+                        requestPayload.systemInstruction = existing.trim().length > 0 ? `${existing}\n\n${hint}` : hint;
+                    }
+                    else if (existing && typeof existing === "object") {
+                        const sys = existing;
+                        const partsValue = sys.parts;
+                        if (Array.isArray(partsValue)) {
+                            const parts = partsValue;
+                            let appended = false;
+                            for (let i = parts.length - 1; i >= 0; i--) {
+                                const part = parts[i];
+                                if (part && typeof part === "object") {
+                                    const partRecord = part;
+                                    const text = partRecord.text;
+                                    if (typeof text === "string") {
+                                        partRecord.text = `${text}\n\n${hint}`;
+                                        appended = true;
+                                        break;
+                                    }
+                                }
+                            }
+                            if (!appended) {
+                                parts.push({ text: hint });
+                            }
+                        }
+                        else {
+                            sys.parts = [{ text: hint }];
+                        }
+                        requestPayload.systemInstruction = sys;
+                    }
+                    else if (Array.isArray(requestPayload.contents)) {
+                        requestPayload.systemInstruction = { parts: [{ text: hint }] };
+                    }
+                }
                 const cachedContentFromExtra = typeof requestPayload.extra_body === "object" && requestPayload.extra_body
                     ? requestPayload.extra_body.cached_content ??
                         requestPayload.extra_body.cachedContent
@@ -199,26 +653,44 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                     if (isClaudeModel) {
                         const functionDeclarations = [];
                         const passthroughTools = [];
-                        // Sanitize schema - remove features not supported by JSON Schema draft 2020-12
-                        // Recursively strips anyOf/allOf/oneOf and converts to permissive types
+                        // Sanitize schema using ALLOWLIST approach - only keep basic features needed for function calling
+                        // This is more aggressive than blocklisting, ensuring any unknown/unsupported features are stripped
+                        // See docs/ANTIGRAVITY_API_SPEC.md for full list of unsupported features
                         const sanitizeSchema = (schema) => {
                             if (!schema || typeof schema !== "object") {
                                 return schema;
                             }
+                            // Only keep these basic schema features (allowlist approach)
+                            // Everything else gets stripped automatically
+                            const ALLOWED_KEYS = new Set([
+                                "type",
+                                "properties",
+                                "required",
+                                "description",
+                                "enum",
+                                "items",
+                                "additionalProperties",
+                            ]);
                             const sanitized = {};
                             for (const key of Object.keys(schema)) {
-                                // Skip anyOf/allOf/oneOf - not well supported
-                                if (key === "anyOf" || key === "allOf" || key === "oneOf") {
+                                // Convert "const" to "enum: [value]" (const is not supported but enum is)
+                                if (key === "const") {
+                                    sanitized.enum = [schema[key]];
+                                    continue;
+                                }
+                                // Skip keys not in allowlist
+                                if (!ALLOWED_KEYS.has(key)) {
                                     continue;
                                 }
                                 const value = schema[key];
                                 if (key === "items" && value && typeof value === "object") {
-                                    // Handle array items - if it has anyOf, replace with permissive type
-                                    if (value.anyOf || value.allOf || value.oneOf) {
-                                        sanitized.items = {};
+                                    const sanitizedItems = sanitizeSchema(value);
+                                    // Empty items schema {} is invalid - convert to permissive string type
+                                    if (Object.keys(sanitizedItems).length === 0) {
+                                        sanitized.items = { type: "string" };
                                     }
                                     else {
-                                        sanitized.items = sanitizeSchema(value);
+                                        sanitized.items = sanitizedItems;
                                     }
                                 }
                                 else if (key === "properties" && value && typeof value === "object") {
@@ -238,13 +710,32 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                             return sanitized;
                         };
                         const normalizeSchema = (schema) => {
+                            // Helper to create a placeholder schema for empty parameter tools
+                            // Antigravity API in VALIDATED mode cannot handle truly empty schemas
+                            // The placeholder must be REQUIRED so the model sends a non-empty args object
+                            const createPlaceholderSchema = (base = {}) => ({
+                                ...base,
+                                type: "object",
+                                properties: {
+                                    reason: {
+                                        type: "string",
+                                        description: "Brief explanation of why you are calling this tool",
+                                    },
+                                },
+                                required: ["reason"],
+                            });
                             if (!schema || typeof schema !== "object") {
                                 toolDebugMissing += 1;
-                                // Minimal fallback for tools without schemas
-                                return { type: "object" };
+                                // Fallback for tools without schemas - add dummy property for Antigravity API
+                                return createPlaceholderSchema();
+                            }
+                            const sanitized = sanitizeSchema(schema);
+                            // Check if schema is effectively empty (type: object with no properties)
+                            if (sanitized.type === "object" &&
+                                (!sanitized.properties || Object.keys(sanitized.properties).length === 0)) {
+                                return createPlaceholderSchema(sanitized);
                             }
-                            // Sanitize and pass through
-                            return sanitizeSchema(schema);
+                            return sanitized;
                         };
                         requestPayload.tools.forEach((tool, idx) => {
                             const pushDeclaration = (decl, source) => {
@@ -359,8 +850,30 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                     }
                 }
                 // For Claude models, filter out unsigned thinking blocks (required by Claude API)
-                if (isClaudeModel && Array.isArray(requestPayload.contents)) {
-                    requestPayload.contents = filterUnsignedThinkingBlocks(requestPayload.contents);
+                // Attempts to restore signatures from cache for multi-turn conversations
+                // Handle both Gemini-style contents[] and Anthropic-style messages[] payloads.
+                if (isClaudeModel) {
+                    if (isClaudeThinkingModel && Array.isArray(requestPayload.contents)) {
+                        requestPayload.contents = ensureThinkingBeforeToolUseInContents(requestPayload.contents, PLUGIN_SESSION_ID);
+                    }
+                    if (isClaudeThinkingModel && Array.isArray(requestPayload.messages)) {
+                        requestPayload.messages = ensureThinkingBeforeToolUseInMessages(requestPayload.messages, PLUGIN_SESSION_ID);
+                    }
+                    if (isClaudeThinkingModel) {
+                        const sessionKey = PLUGIN_SESSION_ID;
+                        const hasToolUse = (Array.isArray(requestPayload.contents) && hasToolUseInContents(requestPayload.contents)) ||
+                            (Array.isArray(requestPayload.messages) && hasToolUseInMessages(requestPayload.messages));
+                        const hasSignedThinking = (Array.isArray(requestPayload.contents) && hasSignedThinkingInContents(requestPayload.contents)) ||
+                            (Array.isArray(requestPayload.messages) && hasSignedThinkingInMessages(requestPayload.messages));
+                        const hasCachedThinking = lastSignedThinkingBySessionId.has(sessionKey);
+                        needsSignedThinkingWarmup = hasToolUse && !hasSignedThinking && !hasCachedThinking;
+                    }
+                    if (Array.isArray(requestPayload.contents)) {
+                        requestPayload.contents = filterUnsignedThinkingBlocks(requestPayload.contents, PLUGIN_SESSION_ID, getCachedSignature);
+                    }
+                    if (Array.isArray(requestPayload.messages)) {
+                        requestPayload.messages = filterMessagesThinkingBlocks(requestPayload.messages, PLUGIN_SESSION_ID, getCachedSignature);
+                    }
                 }
                 // For Claude models, ensure functionCall/tool use parts carry IDs (required by Anthropic).
                 // We use a two-pass approach: first collect all functionCalls and assign IDs,
@@ -417,6 +930,7 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                 if ("model" in requestPayload) {
                     delete requestPayload.model;
                 }
+                stripInjectedDebugFromRequestPayload(requestPayload);
                 const effectiveProjectId = projectId?.trim() || generateSyntheticProjectId();
                 resolvedProjectId = effectiveProjectId;
                 const wrappedBody = {
@@ -430,7 +944,9 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                     requestId: "agent-" + crypto.randomUUID(),
                 });
                 if (wrappedBody.request && typeof wrappedBody.request === 'object') {
-                    wrappedBody.request.sessionId = "-" + Math.floor(Math.random() * 9000000000000000000).toString();
+                    // Use stable session ID for signature caching across multi-turn conversations
+                    sessionId = PLUGIN_SESSION_ID;
+                    wrappedBody.request.sessionId = sessionId;
                 }
                 body = JSON.stringify(wrappedBody);
             }
@@ -442,6 +958,20 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
     if (streaming) {
         headers.set("Accept", "text/event-stream");
     }
+    // Add interleaved thinking header for Claude thinking models
+    // This enables real-time streaming of thinking tokens
+    if (isClaudeThinkingModel) {
+        const existing = headers.get("anthropic-beta");
+        const interleavedHeader = "interleaved-thinking-2025-05-14";
+        if (existing) {
+            if (!existing.includes(interleavedHeader)) {
+                headers.set("anthropic-beta", `${existing},${interleavedHeader}`);
+            }
+        }
+        else {
+            headers.set("anthropic-beta", interleavedHeader);
+        }
+    }
     headers.set("User-Agent", ANTIGRAVITY_HEADERS["User-Agent"]);
     headers.set("X-Goog-Api-Client", ANTIGRAVITY_HEADERS["X-Goog-Api-Client"]);
     headers.set("Client-Metadata", ANTIGRAVITY_HEADERS["Client-Metadata"]);
@@ -457,25 +987,67 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
             body,
         },
         streaming,
-        requestedModel: rawModel,
+        requestedModel,
         effectiveModel: upstreamModel,
         projectId: resolvedProjectId,
         endpoint: transformedUrl,
+        sessionId,
         toolDebugMissing,
         toolDebugSummary: toolDebugSummaries.slice(0, 20).join(" | "),
         toolDebugPayload,
+        needsSignedThinkingWarmup,
     };
 }
+export function buildThinkingWarmupBody(bodyText, isClaudeThinkingModel) {
+    if (!bodyText || !isClaudeThinkingModel) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(bodyText);
+    }
+    catch {
+        return null;
+    }
+    const warmupPrompt = "Warmup request for thinking signature.";
+    const updateRequest = (req) => {
+        req.contents = [{ role: "user", parts: [{ text: warmupPrompt }] }];
+        delete req.tools;
+        delete req.toolConfig;
+        const generationConfig = (req.generationConfig ?? {});
+        generationConfig.thinkingConfig = {
+            include_thoughts: true,
+            thinking_budget: DEFAULT_THINKING_BUDGET,
+        };
+        generationConfig.maxOutputTokens = CLAUDE_THINKING_MAX_OUTPUT_TOKENS;
+        req.generationConfig = generationConfig;
+    };
+    if (parsed.request && typeof parsed.request === "object") {
+        updateRequest(parsed.request);
+        const nested = parsed.request.request;
+        if (nested && typeof nested === "object") {
+            updateRequest(nested);
+        }
+    }
+    else {
+        updateRequest(parsed);
+    }
+    return JSON.stringify(parsed);
+}
 /**
  * Normalizes Antigravity responses: applies retry headers, extracts cache usage into headers,
  * rewrites preview errors, flattens streaming payloads, and logs debug metadata.
  *
- * For streaming SSE responses, uses TransformStream for true incremental streaming.
+ * For streaming SSE responses, uses TransformStream for true real-time incremental streaming.
+ * Thinking/reasoning tokens are transformed and forwarded immediately as they arrive.
  */
-export async function transformAntigravityResponse(response, streaming, debugContext, requestedModel, projectId, endpoint, effectiveModel, toolDebugMissing, toolDebugSummary, toolDebugPayload) {
+export async function transformAntigravityResponse(response, streaming, debugContext, requestedModel, projectId, endpoint, effectiveModel, sessionId, toolDebugMissing, toolDebugSummary, toolDebugPayload, debugLines) {
     const contentType = response.headers.get("content-type") ?? "";
     const isJsonResponse = contentType.includes("application/json");
     const isEventStreamResponse = contentType.includes("text/event-stream");
+    const debugText = isDebugEnabled() && Array.isArray(debugLines) && debugLines.length > 0
+        ? formatDebugLinesForThinking(debugLines)
+        : undefined;
     if (!isJsonResponse && !isEventStreamResponse) {
         logAntigravityDebugResponse(debugContext, response, {
             note: "Non-JSON response (body omitted)",
@@ -483,43 +1055,16 @@ export async function transformAntigravityResponse(response, streaming, debugCon
         return response;
     }
     // For successful streaming responses, use TransformStream to transform SSE events
-    // while maintaining real-time streaming (no buffering of entire response)
+    // while maintaining real-time streaming (no buffering of entire response).
+    // This enables thinking tokens to be displayed as they arrive, like the Codex plugin.
     if (streaming && response.ok && isEventStreamResponse && response.body) {
         const headers = new Headers(response.headers);
-        // Buffer for partial SSE events that span chunks
-        let buffer = "";
-        const decoder = new TextDecoder();
-        const encoder = new TextEncoder();
-        const transformStream = new TransformStream({
-            transform(chunk, controller) {
-                // Decode chunk with stream: true to handle multi-byte characters
-                buffer += decoder.decode(chunk, { stream: true });
-                // Split on double newline (SSE event delimiter)
-                const events = buffer.split("\n\n");
-                // Keep last part in buffer (may be incomplete)
-                buffer = events.pop() || "";
-                // Process and forward complete events immediately
-                for (const event of events) {
-                    if (event.trim()) {
-                        const transformed = transformStreamingPayload(event);
-                        controller.enqueue(encoder.encode(transformed + "\n\n"));
-                    }
-                }
-            },
-            flush(controller) {
-                // Flush any remaining bytes from TextDecoder
-                buffer += decoder.decode();
-                // Handle any remaining data at stream end
-                if (buffer.trim()) {
-                    const transformed = transformStreamingPayload(buffer);
-                    controller.enqueue(encoder.encode(transformed));
-                }
-            }
-        });
         logAntigravityDebugResponse(debugContext, response, {
-            note: "Streaming SSE response (transformed)",
+            note: "Streaming SSE response (real-time transform)",
         });
-        return new Response(response.body.pipeThrough(transformStream), {
+        // Use the optimized line-by-line transformer for immediate forwarding
+        // This ensures thinking/reasoning content streams in real-time
+        return new Response(response.body.pipeThrough(createStreamingTransformer(sessionId, debugText)), {
             status: response.status,
             statusText: response.statusText,
             headers,
@@ -538,8 +1083,9 @@ export async function transformAntigravityResponse(response, streaming, debugCon
             }
             // Inject Debug Info
             if (errorBody?.error) {
-                const debugInfo = `\n\n[Debug Info]\nRequested Model: ${requestedModel || "Unknown"}\nEffective Model: ${effectiveModel || "Unknown"}\nProject: ${projectId || "Unknown"}\nEndpoint: ${endpoint || "Unknown"}\nStatus: ${response.status}\nRequest ID: ${headers.get('x-request-id') || "N/A"}${toolDebugMissing !== undefined ? `\nTool Debug Missing: ${toolDebugMissing}` : ""}${toolDebugSummary ? `\nTool Debug Summary: ${toolDebugSummary}` : ""}${toolDebugPayload ? `\nTool Debug Payload: ${toolDebugPayload}` : ""}`;
-                errorBody.error.message = (errorBody.error.message || "Unknown error") + debugInfo;
+                const debugInfo = `\n\n[Debug Info]\nRequested Model: ${requestedModel || "Unknown"}\nEffective Model: ${effectiveModel || "Unknown"}\nProject: ${projectId || "Unknown"}\nEndpoint: ${endpoint || "Unknown"}\nStatus: ${response.status}\nRequest ID: ${headers.get("x-request-id") || "N/A"}${toolDebugMissing !== undefined ? `\nTool Debug Missing: ${toolDebugMissing}` : ""}${toolDebugSummary ? `\nTool Debug Summary: ${toolDebugSummary}` : ""}${toolDebugPayload ? `\nTool Debug Payload: ${toolDebugPayload}` : ""}`;
+                const injectedDebug = debugText ? `\n\n${debugText}` : "";
+                errorBody.error.message = (errorBody.error.message || "Unknown error") + debugInfo + injectedDebug;
                 return new Response(JSON.stringify(errorBody), {
                     status: response.status,
                     statusText: response.statusText,
@@ -595,7 +1141,8 @@ export async function transformAntigravityResponse(response, streaming, debugCon
             return new Response(text, init);
         }
         if (effectiveBody?.response !== undefined) {
-            const transformed = transformThinkingParts(effectiveBody.response);
+            const responseBody = debugText ? injectDebugThinking(effectiveBody.response, debugText) : effectiveBody.response;
+            const transformed = transformThinkingParts(responseBody);
             return new Response(JSON.stringify(transformed), init);
         }
         if (patched) {