Merge branch 'main' of github.com:tctinh/opencode-antigravity-auth

Author: tctinh

src/plugin/request-helpers.ts

@@ -153,23 +153,9 @@ export function filterUnsignedThinkingBlocks(contents: any[]): any[] {
 }
 
 /**
- * Transforms Anthropic-style thinking blocks (type: "thinking") to reasoning format.
- */
-function transformAnthropicThinkingBlocks(content: any[]): any[] {
-  return content.map((block: any) => {
-    if (block && typeof block === "object" && block.type === "thinking") {
-      return {
-        type: "reasoning",
-        text: block.text || "",
-        ...(block.signature ? { signature: block.signature } : {}),
-      };
-    }
-    return block;
-  });
-}
-
-/**
- * Transforms Gemini-style thought parts (thought: true) to reasoning format.
+ * Transforms Gemini-style thought parts (thought: true) and Anthropic-style
+ * thinking parts (type: "thinking") to reasoning format.
+ * Claude responses through Antigravity may use candidates structure with Anthropic-style parts.
  */
 function transformGeminiCandidate(candidate: any): any {
   if (!candidate || typeof candidate !== "object") {
@@ -183,10 +169,28 @@ function transformGeminiCandidate(candidate: any): any {
 
   const thinkingTexts: string[] = [];
   const transformedParts = content.parts.map((part: any) => {
-    if (part && typeof part === "object" && part.thought === true) {
+    if (!part || typeof part !== "object") {
+      return part;
+    }
+
+    // Handle Gemini-style: thought: true
+    if (part.thought === true) {
       thinkingTexts.push(part.text || "");
       return { ...part, type: "reasoning" };
     }
+
+    // Handle Anthropic-style in candidates: type: "thinking"
+    if (part.type === "thinking") {
+      const thinkingText = part.thinking || part.text || "";
+      thinkingTexts.push(thinkingText);
+      return {
+        ...part,
+        type: "reasoning",
+        text: thinkingText,
+        thought: true,
+      };
+    }
+
     return part;
   });
 
@@ -200,6 +204,7 @@ function transformGeminiCandidate(candidate: any): any {
 /**
  * Transforms thinking/reasoning content in response parts to OpenCode's expected format.
  * Handles both Gemini-style (thought: true) and Anthropic-style (type: "thinking") formats.
+ * Also extracts reasoning_content for Anthropic-style responses.
  */
 export function transformThinkingParts(response: unknown): unknown {
   if (!response || typeof response !== "object") {
@@ -208,15 +213,38 @@ export function transformThinkingParts(response: unknown): unknown {
 
   const resp = response as Record<string, unknown>;
   const result: Record<string, unknown> = { ...resp };
+  const reasoningTexts: string[] = [];
 
+  // Handle Anthropic-style content array (type: "thinking")
   if (Array.isArray(resp.content)) {
-    result.content = transformAnthropicThinkingBlocks(resp.content);
+    const transformedContent: any[] = [];
+    for (const block of resp.content) {
+      if (block && typeof block === "object" && (block as any).type === "thinking") {
+        const thinkingText = (block as any).thinking || (block as any).text || "";
+        reasoningTexts.push(thinkingText);
+        transformedContent.push({
+          ...block,
+          type: "reasoning",
+          text: thinkingText,
+          thought: true,
+        });
+      } else {
+        transformedContent.push(block);
+      }
+    }
+    result.content = transformedContent;
   }
 
+  // Handle Gemini-style candidates array
   if (Array.isArray(resp.candidates)) {
     result.candidates = resp.candidates.map(transformGeminiCandidate);
   }
 
+  // Add reasoning_content if we found any thinking blocks (for Anthropic-style)
+  if (reasoningTexts.length > 0 && !result.reasoning_content) {
+    result.reasoning_content = reasoningTexts.join("\n\n");
+  }
+
   return result;
 }
 

src/plugin/request.ts

@@ -63,6 +63,60 @@ function transformStreamingPayload(payload: string): string {
     .join("\n");
 }
 
+/**
+ * Creates a TransformStream that processes SSE chunks incrementally,
+ * transforming each line as it arrives for true streaming support.
+ */
+function createStreamingTransformer(): TransformStream<Uint8Array, Uint8Array> {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let buffer = "";
+
+  return new TransformStream({
+    transform(chunk, controller) {
+      buffer += decoder.decode(chunk, { stream: true });
+
+      // Process complete lines
+      const lines = buffer.split("\n");
+      // Keep the last incomplete line in buffer
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        const transformedLine = transformSseLine(line);
+        controller.enqueue(encoder.encode(transformedLine + "\n"));
+      }
+    },
+    flush(controller) {
+      // Process any remaining data in buffer
+      if (buffer) {
+        const transformedLine = transformSseLine(buffer);
+        controller.enqueue(encoder.encode(transformedLine));
+      }
+    },
+  });
+}
+
+/**
+ * Transforms a single SSE line, extracting and transforming the inner response.
+ */
+function transformSseLine(line: string): string {
+  if (!line.startsWith("data:")) {
+    return line;
+  }
+  const json = line.slice(5).trim();
+  if (!json) {
+    return line;
+  }
+  try {
+    const parsed = JSON.parse(json) as { response?: unknown };
+    if (parsed.response !== undefined) {
+      const transformed = transformThinkingParts(parsed.response);
+      return `data: ${JSON.stringify(transformed)}`;
+    }
+  } catch (_) { }
+  return line;
+}
+
 /**
  * Rewrites OpenAI-style requests into Antigravity shape, normalizing model, headers,
  * optional cached_content, and thinking config. Also toggles streaming mode for SSE actions.
@@ -509,6 +563,8 @@ export function prepareAntigravityRequest(
 /**
  * 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.
  */
 export async function transformAntigravityResponse(
   response: Response,
@@ -587,7 +643,6 @@ export async function transformAntigravityResponse(
 
   try {
     const text = await response.text();
-    const headers = new Headers(response.headers);
 
     if (!response.ok) {
       let errorBody;