opencode-gemini-auth 1.3.4 → 1.3.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-gemini-auth",
   "module": "index.ts",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "author": "jenslys",
   "repository": "https://github.com/jenslys/opencode-gemini-auth",
   "files": [

package/src/plugin/request-helpers.ts

@@ -120,34 +120,6 @@ export function extractUsageMetadata(body: GeminiApiBody): GeminiUsageMetadata |
   };
 }
 
-/**
- * Walks SSE lines to find a usage-bearing response chunk.
- */
-export function extractUsageFromSsePayload(payload: string): GeminiUsageMetadata | null {
-  const lines = payload.split("\n");
-  for (const line of lines) {
-    if (!line.startsWith("data:")) {
-      continue;
-    }
-    const jsonText = line.slice(5).trim();
-    if (!jsonText) {
-      continue;
-    }
-    try {
-      const parsed = JSON.parse(jsonText);
-      if (parsed && typeof parsed === "object") {
-        const usage = extractUsageMetadata({ response: (parsed as Record<string, unknown>).response });
-        if (usage) {
-          return usage;
-        }
-      }
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-
 /**
  * Enhances 404 errors for Gemini 3 models with a direct preview-access message.
  */

package/src/plugin/request.ts

@@ -1,7 +1,6 @@
 import { CODE_ASSIST_HEADERS, GEMINI_CODE_ASSIST_ENDPOINT } from "../constants";
 import { logGeminiDebugResponse, type GeminiDebugContext } from "./debug";
 import {
-  extractUsageFromSsePayload,
   extractUsageMetadata,
   normalizeThinkingConfig,
   parseGeminiApiBody,
@@ -20,32 +19,85 @@ const MODEL_FALLBACKS: Record<string, string> = {
  * @returns True when the URL targets generativelanguage.googleapis.com.
  */
 export function isGenerativeLanguageRequest(input: RequestInfo): input is string {
-  return typeof input === "string" && input.includes("generativelanguage.googleapis.com");
+  return toRequestUrlString(input).includes("generativelanguage.googleapis.com");
 }
 
 /**
- * Rewrites SSE payloads so downstream consumers see only the inner `response` objects.
+ * Rewrites SSE payload lines so downstream consumers see only the inner `response` objects.
  */
-function transformStreamingPayload(payload: string): string {
-  return payload
-    .split("\n")
-    .map((line) => {
-      if (!line.startsWith("data:")) {
-        return line;
-      }
-      const json = line.slice(5).trim();
-      if (!json) {
-        return line;
+function transformStreamingLine(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) {
+      return `data: ${JSON.stringify(parsed.response)}`;
+    }
+  } catch (_) {}
+  return line;
+}
+
+/**
+ * Streams SSE payloads, rewriting data lines on the fly.
+ */
+function transformStreamingPayloadStream(
+  stream: ReadableStream<Uint8Array>,
+): ReadableStream<Uint8Array> {
+  const decoder = new TextDecoder();
+  const encoder = new TextEncoder();
+  let buffer = "";
+  let reader: ReadableStreamDefaultReader<Uint8Array> | null = null;
+
+  return new ReadableStream<Uint8Array>({
+    start(controller) {
+      reader = stream.getReader();
+      const pump = (): void => {
+        reader!
+          .read()
+          .then(({ done, value }) => {
+            if (done) {
+              buffer += decoder.decode();
+              if (buffer.length > 0) {
+                controller.enqueue(encoder.encode(transformStreamingLine(buffer)));
+              }
+              controller.close();
+              return;
+            }
+
+            buffer += decoder.decode(value, { stream: true });
+
+            let newlineIndex = buffer.indexOf("\n");
+            while (newlineIndex !== -1) {
+              const line = buffer.slice(0, newlineIndex);
+              buffer = buffer.slice(newlineIndex + 1);
+              const hasCarriageReturn = line.endsWith("\r");
+              const rawLine = hasCarriageReturn ? line.slice(0, -1) : line;
+              const transformed = transformStreamingLine(rawLine);
+              const suffix = hasCarriageReturn ? "\r\n" : "\n";
+              controller.enqueue(encoder.encode(`${transformed}${suffix}`));
+              newlineIndex = buffer.indexOf("\n");
+            }
+
+            pump();
+          })
+          .catch((error) => {
+            controller.error(error);
+          });
+      };
+
+      pump();
+    },
+    cancel(reason) {
+      if (reader) {
+        reader.cancel(reason).catch(() => {});
       }
-      try {
-        const parsed = JSON.parse(json) as { response?: unknown };
-        if (parsed.response !== undefined) {
-          return `data: ${JSON.stringify(parsed.response)}`;
-        }
-      } catch (_) {}
-      return line;
-    })
-    .join("\n");
+    },
+  });
 }
 
 /**
@@ -72,7 +124,7 @@ export function prepareGeminiRequest(
   headers.set("Authorization", `Bearer ${accessToken}`);
   headers.delete("x-api-key");
 
-  const match = input.match(/\/models\/([^:]+):(\w+)/);
+  const match = toRequestUrlString(input).match(/\/models\/([^:]+):(\w+)/);
   if (!match) {
     return {
       request: input,
@@ -136,7 +188,6 @@ export function prepareGeminiRequest(
         }
 
         delete requestPayload.cached_content;
-        delete requestPayload.cachedContent;
         if (requestPayload.extra_body && typeof requestPayload.extra_body === "object") {
           delete (requestPayload.extra_body as Record<string, unknown>).cached_content;
           delete (requestPayload.extra_body as Record<string, unknown>).cachedContent;
@@ -182,9 +233,23 @@ export function prepareGeminiRequest(
   };
 }
 
+function toRequestUrlString(value: RequestInfo): string {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof URL) {
+    return value.toString();
+  }
+  const candidate = (value as Request).url;
+  if (candidate) {
+    return candidate;
+  }
+  return value.toString();
+}
+
 /**
  * Normalizes Gemini responses: applies retry headers, extracts cache usage into headers,
- * rewrites preview errors, flattens streaming payloads, and logs debug metadata.
+ * rewrites preview errors, rewrites streaming payloads, and logs debug metadata.
  */
 export async function transformGeminiResponse(
   response: Response,
@@ -204,8 +269,22 @@ export async function transformGeminiResponse(
   }
 
   try {
-    const text = await response.text();
     const headers = new Headers(response.headers);
+
+    if (streaming && response.ok && isEventStreamResponse && response.body) {
+      logGeminiDebugResponse(debugContext, response, {
+        note: "Streaming SSE payload (body omitted)",
+        headersOverride: headers,
+      });
+
+      return new Response(transformStreamingPayloadStream(response.body), {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+      });
+    }
+
+    const text = await response.text();
     
     if (!response.ok && text) {
       try {
@@ -238,12 +317,11 @@ export async function transformGeminiResponse(
       headers,
     };
 
-    const usageFromSse = streaming && isEventStreamResponse ? extractUsageFromSsePayload(text) : null;
     const parsed: GeminiApiBody | null = !streaming || !isEventStreamResponse ? parseGeminiApiBody(text) : null;
     const patched = parsed ? rewriteGeminiPreviewAccessError(parsed, response.status, requestedModel) : null;
     const effectiveBody = patched ?? parsed ?? undefined;
 
-    const usage = usageFromSse ?? (effectiveBody ? extractUsageMetadata(effectiveBody) : null);
+    const usage = effectiveBody ? extractUsageMetadata(effectiveBody) : null;
     if (usage?.cachedContentTokenCount !== undefined) {
       headers.set("x-gemini-cached-content-token-count", String(usage.cachedContentTokenCount));
       if (usage.totalTokenCount !== undefined) {
@@ -259,14 +337,10 @@ export async function transformGeminiResponse(
 
     logGeminiDebugResponse(debugContext, response, {
       body: text,
-      note: streaming ? "Streaming SSE payload" : undefined,
+      note: streaming ? "Streaming SSE payload (buffered)" : undefined,
       headersOverride: headers,
     });
 
-    if (streaming && response.ok && isEventStreamResponse) {
-      return new Response(transformStreamingPayload(text), init);
-    }
-
     if (!parsed) {
       return new Response(text, init);
     }