feat: add debug_tui configuration option and resolve thinking issues

Author: NoeFabris

src/plugin/config/loader.ts

@@ -129,6 +129,11 @@ function applyEnvOverrides(config: AntigravityConfig): AntigravityConfig {
       ? env.OPENCODE_ANTIGRAVITY_DEBUG !== "0" && env.OPENCODE_ANTIGRAVITY_DEBUG !== "false"
       : config.debug,
 
+    // OPENCODE_ANTIGRAVITY_DEBUG_TUI=1
+    debug_tui: env.OPENCODE_ANTIGRAVITY_DEBUG_TUI === "1" || env.OPENCODE_ANTIGRAVITY_DEBUG_TUI === "true"
+      ? true
+      : config.debug_tui,
+
     // OPENCODE_ANTIGRAVITY_LOG_DIR=/path/to/logs
     log_dir: env.OPENCODE_ANTIGRAVITY_LOG_DIR || config.log_dir,
 

src/plugin/config/schema.ts

@@ -96,6 +96,14 @@ export const AntigravityConfigSchema = z.object({
    * @default false
    */
   debug: z.boolean().default(false),
+
+  /**
+   * Show debug logs in the TUI log panel.
+   * Requires `debug: true` to have any effect.
+   * Env override: OPENCODE_ANTIGRAVITY_DEBUG_TUI=1
+   * @default false
+   */
+  debug_tui: z.boolean().default(false),
 
   /**
    * Custom directory for debug logs.
@@ -435,6 +443,7 @@ export const DEFAULT_CONFIG: AntigravityConfig = {
   quiet_mode: false,
   toast_scope: 'root_only',
   debug: false,
+  debug_tui: false,
   keep_thinking: false,
   session_recovery: true,
   auto_resume: true,

src/plugin/debug.ts

@@ -17,6 +17,7 @@ export const DEBUG_MESSAGE_PREFIX = "[opencode-antigravity-auth debug]";
 interface DebugState {
   debugLevel: number;
   debugEnabled: boolean;
+  debugTuiEnabled: boolean;
   verboseEnabled: boolean;
   logFilePath: string | undefined;
   logWriter: (line: string) => void;
@@ -101,6 +102,7 @@ export function initializeDebug(config: AntigravityConfig): void {
   const debugLevel = config.debug ? (envDebugFlag === "2" || envDebugFlag === "verbose" ? 2 : 1) : parseDebugLevel(envDebugFlag);
   const debugEnabled = debugLevel >= 1;
   const verboseEnabled = debugLevel >= 2;
+  const debugTuiEnabled = debugEnabled && (config.debug_tui || env.OPENCODE_ANTIGRAVITY_DEBUG_TUI === "1" || env.OPENCODE_ANTIGRAVITY_DEBUG_TUI === "true");
   const logFilePath = debugEnabled ? createLogFilePath(config.log_dir) : undefined;
   const logWriter = createLogWriter(logFilePath);
 
@@ -111,6 +113,7 @@ export function initializeDebug(config: AntigravityConfig): void {
   debugState = {
     debugLevel,
     debugEnabled,
+    debugTuiEnabled,
     verboseEnabled,
     logFilePath,
     logWriter,
@@ -128,12 +131,14 @@ function getDebugState(): DebugState {
     const debugLevel = parseDebugLevel(envDebugFlag);
     const debugEnabled = debugLevel >= 1;
     const verboseEnabled = debugLevel >= 2;
+    const debugTuiEnabled = debugEnabled && (env.OPENCODE_ANTIGRAVITY_DEBUG_TUI === "1" || env.OPENCODE_ANTIGRAVITY_DEBUG_TUI === "true");
     const logFilePath = debugEnabled ? createLogFilePath() : undefined;
     const logWriter = createLogWriter(logFilePath);
 
     debugState = {
       debugLevel,
       debugEnabled,
+      debugTuiEnabled,
       verboseEnabled,
       logFilePath,
       logWriter,
@@ -150,6 +155,10 @@ export function isDebugEnabled(): boolean {
   return getDebugState().debugEnabled;
 }
 
+export function isDebugTuiEnabled(): boolean {
+  return getDebugState().debugTuiEnabled;
+}
+
 export function isVerboseEnabled(): boolean {
   return getDebugState().verboseEnabled;
 }

src/plugin/logger.ts

@@ -4,12 +4,12 @@
  * Logging behavior:
  * - debug disabled → no logs anywhere
  * - debug enabled → log files only (via debug.ts logWriter)
- * - debug enabled → log files + TUI log panel
+ * - debug_tui enabled → log files + TUI log panel
  * - OPENCODE_ANTIGRAVITY_CONSOLE_LOG=1 → console output (independent of debug flags)
  */
 
 import type { PluginClient } from "./types";
-import { isDebugEnabled } from "./debug";
+import { isDebugTuiEnabled } from "./debug";
 
 type LogLevel = "debug" | "info" | "warn" | "error";
 
@@ -65,8 +65,8 @@ export function createLogger(module: string): Logger {
   const service = `antigravity.${module}`;
 
   const log = (level: LogLevel, message: string, extra?: Record<string, unknown>): void => {
-    // TUI logging: only when debug is enabled
-    if (isDebugEnabled()) {
+    // TUI logging: only when debug TUI is enabled
+    if (isDebugTuiEnabled()) {
       const app = _client?.app;
       if (app && typeof app.log === "function") {
         app

src/plugin/recovery.test.ts

@@ -74,6 +74,14 @@ describe("detectErrorType", () => {
       const error = { message: "Rate limit exceeded. Retry after 5s" };
       expect(detectErrorType(error)).toBeNull();
     });
+
+    it("returns null for generic INVALID_ARGUMENT with debug expected/found metadata", () => {
+      const error = {
+        message:
+          "Request contains an invalid argument. [Debug Info] Requested Model: antigravity-claude-opus-4-6-thinking Tool Debug Summary: expected=1 found=0",
+      };
+      expect(detectErrorType(error)).toBeNull();
+    });
   });
 });
 

src/plugin/recovery.ts

@@ -85,6 +85,9 @@ function extractMessageIndex(error: unknown): number | null {
  */
 export function detectErrorType(error: unknown): RecoveryErrorType {
   const message = getErrorMessage(error);
+  const hasExpectedFoundThinkingOrder =
+    (message.includes("expected thinking") || message.includes("expected a thinking")) &&
+    message.includes("found");
 
   // tool_result_missing: Happens when ESC is pressed during tool execution
   if (message.includes("tool_use") && message.includes("tool_result")) {
@@ -97,7 +100,8 @@ export function detectErrorType(error: unknown): RecoveryErrorType {
     (message.includes("first block") ||
       message.includes("must start with") ||
       message.includes("preceeding") ||
-      (message.includes("expected") && message.includes("found")))
+      message.includes("preceding") ||
+      hasExpectedFoundThinkingOrder)
   ) {
     return "thinking_block_order";
   }

src/plugin/request.test.ts

@@ -518,31 +518,6 @@ describe("request.ts", () => {
   });
 
   describe("prepareAntigravityRequest", () => {
-    it("copies thoughtSignature to all functionCall parts in the same turn", () => {
-      const mockPayload = {
-        contents: [
-          {
-            role: "model",
-            parts: [
-              { functionCall: { name: "foo", args: {} }, thoughtSignature: "signature-123" },
-              { functionCall: { name: "bar", args: {} } }
-            ]
-          }
-        ]
-      };
-      
-      const result = prepareAntigravityRequest(
-        "https://generativelanguage.googleapis.com/v1beta/models/gemini-3.1-pro:generateContent",
-        { method: "POST", body: JSON.stringify(mockPayload) },
-        "test-token",
-        "test-project"
-      );
-      
-      const parsedBody = JSON.parse(result.init.body as string);
-      expect(parsedBody.request.contents[0].parts[0].thoughtSignature).toBe("signature-123");
-      expect(parsedBody.request.contents[0].parts[1].thoughtSignature).toBe("signature-123");
-    });
-
     const mockAccessToken = "test-token";
     const mockProjectId = "test-project";
 

src/plugin/request.ts

@@ -369,7 +369,37 @@ function sanitizeRequestPayloadForAntigravity(payload: Record<string, unknown>):
 
         const contentRecord = content as Record<string, unknown>;
         const rawParts = Array.isArray(contentRecord.parts) ? contentRecord.parts : [];
-        const sanitizedParts = rawParts.filter(isValidRequestPart);
+        let foundFirstFunctionCall = false;
+
+        const sanitizedParts = rawParts.filter(isValidRequestPart).map((part: any) => {
+          if (part && typeof part === "object" && part.functionCall) {
+            let sig = part.thoughtSignature || part.thought_signature;
+
+            // Only the first functionCall part in a block should have the signature.
+            // If it's the first one and missing a valid signature, inject the sentinel
+            // to prevent the API from rejecting the request with a 400 error.
+            if (!foundFirstFunctionCall) {
+              foundFirstFunctionCall = true;
+              if (!sig || sig.length < MIN_SIGNATURE_LENGTH) {
+                sig = SKIP_THOUGHT_SIGNATURE;
+              }
+            } else {
+              // Parallel function calls MUST NOT have a signature
+              sig = undefined;
+            }
+
+            if (sig) {
+              return { ...part, thought_signature: sig, thoughtSignature: sig };
+            }
+            
+            // If not the first part, just return the part without adding any signature keys
+            const newPart = { ...part };
+            delete newPart.thoughtSignature;
+            delete newPart.thought_signature;
+            return newPart;
+          }
+          return part;
+        });
 
         if (sanitizedParts.length === 0) {
           return null;
@@ -1237,29 +1267,6 @@ export function prepareAntigravityRequest(
         const conversationKey = resolveConversationKey(requestPayload);
         signatureSessionKey = buildSignatureSessionKey(PLUGIN_SESSION_ID, effectiveModel, conversationKey, resolveProjectKey(projectId));
 
-        // Ensure thoughtSignature is present on all functionCall parts if at least one part has it
-        // This is required by Gemini 3.1 Pro which otherwise fails with 400 Bad Request
-        if (Array.isArray(requestPayload.contents)) {
-          requestPayload.contents = requestPayload.contents.map((content: any) => {
-            if (!content || !Array.isArray(content.parts)) return content;
-            
-            // Find if any part has a thoughtSignature
-            const signature = content.parts.find((p: any) => p && typeof p === "object" && typeof p.thoughtSignature === "string")?.thoughtSignature;
-            
-            if (signature) {
-              const newParts = content.parts.map((p: any) => {
-                if (p && typeof p === "object" && p.functionCall && !p.thoughtSignature) {
-                  return { ...p, thoughtSignature: signature };
-                }
-                return p;
-              });
-              return { ...content, parts: newParts };
-            }
-            
-            return content;
-          });
-        }
-
         // For Claude models, filter out unsigned thinking blocks (required by Claude API)
         // Attempts to restore signatures from cache for multi-turn conversations
         // Handle both Gemini-style contents[] and Anthropic-style messages[] payloads.