opencode-antigravity-auth 1.2.0 → 1.2.2

package/dist/src/plugin/request.js

@@ -1,8 +1,8 @@
 import crypto from "node:crypto";
-import { ANTIGRAVITY_HEADERS, ANTIGRAVITY_ENDPOINT, } from "../constants";
+import { ANTIGRAVITY_HEADERS, GEMINI_CLI_HEADERS, ANTIGRAVITY_ENDPOINT, } from "../constants";
 import { cacheSignature, getCachedSignature } from "./cache";
-import { logAntigravityDebugResponse } from "./debug";
-import { extractThinkingConfig, extractUsageFromSsePayload, extractUsageMetadata, filterUnsignedThinkingBlocks, filterMessagesThinkingBlocks, isThinkingCapableModel, normalizeThinkingConfig, parseAntigravityApiBody, resolveThinkingConfig, rewriteAntigravityPreviewAccessError, transformThinkingParts, } from "./request-helpers";
+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.
@@ -11,6 +11,257 @@ import { extractThinkingConfig, extractUsageFromSsePayload, extractUsageMetadata
 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.
  */
@@ -64,12 +315,13 @@ function transformStreamingPayload(payload) {
  * transforming each line as it arrives for true real-time streaming support.
  * Optionally caches thinking signatures for Claude multi-turn conversations.
  */
-function createStreamingTransformer(sessionId) {
+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
@@ -80,7 +332,7 @@ function createStreamingTransformer(sessionId) {
             buffer = lines.pop() || "";
             for (const line of lines) {
                 // Transform and forward each line immediately
-                const transformedLine = transformSseLine(line, sessionId, thoughtBuffer);
+                const transformedLine = transformSseLine(line, sessionId, thoughtBuffer, debugText, debugState);
                 controller.enqueue(encoder.encode(transformedLine + "\n"));
             }
         },
@@ -89,7 +341,7 @@ function createStreamingTransformer(sessionId) {
             buffer += decoder.decode();
             // Process any remaining data in buffer
             if (buffer) {
-                const transformedLine = transformSseLine(buffer, sessionId, thoughtBuffer);
+                const transformedLine = transformSseLine(buffer, sessionId, thoughtBuffer, debugText, debugState);
                 controller.enqueue(encoder.encode(transformedLine));
             }
         },
@@ -99,7 +351,7 @@ function createStreamingTransformer(sessionId) {
  * Transforms a single SSE line, extracting and transforming the inner response.
  * Optionally caches thinking signatures for Claude multi-turn support.
  */
-function transformSseLine(line, sessionId, thoughtBuffer) {
+function transformSseLine(line, sessionId, thoughtBuffer, debugText, debugState) {
     if (!line.startsWith("data:")) {
         return line;
     }
@@ -110,11 +362,15 @@ function transformSseLine(line, sessionId, thoughtBuffer) {
     try {
         const parsed = JSON.parse(json);
         if (parsed.response !== undefined) {
-            // Cache thinking signatures for Claude multi-turn support
             if (sessionId && thoughtBuffer) {
                 cacheThinkingSignatures(parsed.response, sessionId, thoughtBuffer);
             }
-            const transformed = transformThinkingParts(parsed.response);
+            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)}`;
         }
     }
@@ -147,6 +403,7 @@ function cacheThinkingSignatures(response, sessionId, thoughtBuffer) {
                     const fullText = thoughtBuffer.get(index) ?? "";
                     if (fullText && sessionId) {
                         cacheSignature(sessionId, fullText, part.thoughtSignature);
+                        lastSignedThinkingBySessionId.set(sessionId, { text: fullText, signature: part.thoughtSignature });
                     }
                 }
             });
@@ -161,6 +418,7 @@ function cacheThinkingSignatures(response, sessionId, thoughtBuffer) {
             }
             if (block?.signature && thinkingText && sessionId) {
                 cacheSignature(sessionId, thinkingText, block.signature);
+                lastSignedThinkingBySessionId.set(sessionId, { text: thinkingText, signature: block.signature });
             }
         });
     }
@@ -169,7 +427,7 @@ function cacheThinkingSignatures(response, sessionId, thoughtBuffer) {
  * Rewrites OpenAI-style requests into Antigravity shape, normalizing model, headers,
  * optional cached_content, and thinking config. Also toggles streaming mode for SSE actions.
  */
-export function prepareAntigravityRequest(input, init, accessToken, projectId, endpointOverride) {
+export function prepareAntigravityRequest(input, init, accessToken, projectId, endpointOverride, headerStyle = "antigravity") {
     const baseInit = { ...init };
     const headers = new Headers(init?.headers ?? {});
     let resolvedProjectId = projectId?.trim() || "";
@@ -177,11 +435,13 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
     const toolDebugSummaries = [];
     let toolDebugPayload;
     let sessionId;
+    let needsSignedThinkingWarmup = false;
     if (!isGenerativeLanguageRequest(input)) {
         return {
             request: input,
             init: { ...baseInit, headers },
             streaming: false,
+            headerStyle,
         };
     }
     headers.set("Authorization", `Bearer ${accessToken}`);
@@ -192,11 +452,16 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
             request: input,
             init: { ...baseInit, headers },
             streaming: false,
+            headerStyle,
         };
     }
     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" : ""}`;
@@ -230,7 +495,14 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                 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);
                         }
@@ -239,6 +511,14 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                         }
                     }
                 }
+                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 {
@@ -575,6 +855,21 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
                 // 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);
                     }
@@ -637,6 +932,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 = {
@@ -678,9 +974,10 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
             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"]);
+    const selectedHeaders = headerStyle === "gemini-cli" ? GEMINI_CLI_HEADERS : ANTIGRAVITY_HEADERS;
+    headers.set("User-Agent", selectedHeaders["User-Agent"]);
+    headers.set("X-Goog-Api-Client", selectedHeaders["X-Goog-Api-Client"]);
+    headers.set("Client-Metadata", selectedHeaders["Client-Metadata"]);
     // Optional debug header to observe tool normalization on the backend if surfaced
     if (toolDebugMissing > 0) {
         headers.set("X-Opencode-Tools-Debug", String(toolDebugMissing));
@@ -693,7 +990,7 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
             body,
         },
         streaming,
-        requestedModel: rawModel,
+        requestedModel,
         effectiveModel: upstreamModel,
         projectId: resolvedProjectId,
         endpoint: transformedUrl,
@@ -701,8 +998,46 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
         toolDebugMissing,
         toolDebugSummary: toolDebugSummaries.slice(0, 20).join(" | "),
         toolDebugPayload,
+        needsSignedThinkingWarmup,
+        headerStyle,
     };
 }
+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.
@@ -710,10 +1045,13 @@ export function prepareAntigravityRequest(input, init, accessToken, projectId, e
  * 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, sessionId, 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)",
@@ -730,7 +1068,7 @@ export async function transformAntigravityResponse(response, streaming, debugCon
         });
         // 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)), {
+        return new Response(response.body.pipeThrough(createStreamingTransformer(sessionId, debugText)), {
             status: response.status,
             statusText: response.statusText,
             headers,
@@ -749,8 +1087,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,
@@ -806,7 +1145,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) {