opencode-gemini-auth 1.3.10 → 1.4.0

package/src/plugin/request/identifiers.ts

@@ -0,0 +1,100 @@
+import { randomUUID } from "node:crypto";
+
+import { isRecord, pickString } from "./shared";
+
+const PROCESS_SESSION_ID = randomUUID();
+
+function resolveUserPromptId(payload: Record<string, unknown>, request?: Record<string, unknown>): string {
+  const extra = isRecord(payload.extra_body) ? payload.extra_body : undefined;
+
+  return (
+    pickString(
+      payload.user_prompt_id,
+      payload.userPromptId,
+      payload.prompt_id,
+      payload.promptId,
+      payload.request_id,
+      payload.requestId,
+      request?.user_prompt_id,
+      request?.userPromptId,
+      request?.prompt_id,
+      request?.promptId,
+      request?.request_id,
+      request?.requestId,
+      extra?.user_prompt_id,
+      extra?.userPromptId,
+      extra?.prompt_id,
+      extra?.promptId,
+      extra?.request_id,
+      extra?.requestId,
+    ) ?? randomUUID()
+  );
+}
+
+function resolveSessionId(payload: Record<string, unknown>, request?: Record<string, unknown>): string {
+  const extra = isRecord(payload.extra_body) ? payload.extra_body : undefined;
+  return (
+    pickString(
+      request?.session_id,
+      request?.sessionId,
+      payload.session_id,
+      payload.sessionId,
+      extra?.session_id,
+      extra?.sessionId,
+    ) ?? PROCESS_SESSION_ID
+  );
+}
+
+function stripPromptIdentifierAliases(payload: Record<string, unknown>): void {
+  delete payload.user_prompt_id;
+  delete payload.userPromptId;
+  delete payload.prompt_id;
+  delete payload.promptId;
+  delete payload.request_id;
+  delete payload.requestId;
+}
+
+function stripSessionIdentifierAliases(payload: Record<string, unknown>): void {
+  delete payload.sessionId;
+}
+
+/**
+ * Applies canonical identifiers for wrapped Code Assist payloads.
+ *
+ * `user_prompt_id` and `session_id` are first-class identifiers in Gemini CLI
+ * request envelopes used for traceability, usage accounting, and support diagnostics.
+ */
+export function normalizeWrappedIdentifiers(
+  wrapped: Record<string, unknown>,
+): { userPromptId: string; sessionId: string } {
+  const request = isRecord(wrapped.request) ? { ...wrapped.request } : {};
+  const userPromptId = resolveUserPromptId(wrapped, request);
+  const sessionId = resolveSessionId(wrapped, request);
+
+  request.session_id = sessionId;
+  stripSessionIdentifierAliases(request);
+  wrapped.request = request;
+
+  wrapped.user_prompt_id = userPromptId;
+  stripPromptIdentifierAliases(wrapped);
+
+  return { userPromptId, sessionId };
+}
+
+/**
+ * Applies canonical identifiers for unwrapped request payloads before wrapping.
+ *
+ * We normalize aliases here so downstream logic has a single source of truth.
+ */
+export function normalizeRequestPayloadIdentifiers(
+  payload: Record<string, unknown>,
+): { userPromptId: string; sessionId: string } {
+  const userPromptId = resolveUserPromptId(payload);
+  const sessionId = resolveSessionId(payload);
+
+  payload.session_id = sessionId;
+  stripSessionIdentifierAliases(payload);
+  stripPromptIdentifierAliases(payload);
+
+  return { userPromptId, sessionId };
+}

package/src/plugin/request/index.ts

@@ -0,0 +1,3 @@
+export { prepareGeminiRequest } from "./prepare";
+export { transformGeminiResponse } from "./response";
+export { isGenerativeLanguageRequest } from "./shared";

package/src/plugin/request/openai.ts

@@ -0,0 +1,128 @@
+interface GeminiFunctionCallPart {
+  functionCall?: {
+    name: string;
+    args?: Record<string, unknown>;
+    [key: string]: unknown;
+  };
+  thoughtSignature?: string;
+  [key: string]: unknown;
+}
+
+interface OpenAIToolCall {
+  function?: {
+    name?: string;
+    arguments?: string;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+
+interface OpenAIMessage {
+  content?: string | null;
+  tool_calls?: OpenAIToolCall[];
+  [key: string]: unknown;
+}
+
+/**
+ * Transforms OpenAI `tool_calls` to Gemini `functionCall` parts.
+ */
+export function transformOpenAIToolCalls(requestPayload: Record<string, unknown>): void {
+  const messages = requestPayload.messages;
+  if (!messages || !Array.isArray(messages)) {
+    return;
+  }
+
+  for (const message of messages) {
+    if (!message || typeof message !== "object") {
+      continue;
+    }
+
+    const msgObj = message as OpenAIMessage;
+    const toolCalls = msgObj.tool_calls;
+    if (!toolCalls || !Array.isArray(toolCalls) || toolCalls.length === 0) {
+      continue;
+    }
+
+    const parts: GeminiFunctionCallPart[] = [];
+    if (typeof msgObj.content === "string" && msgObj.content.length > 0) {
+      parts.push({ text: msgObj.content });
+    }
+
+    for (const toolCall of toolCalls) {
+      if (!toolCall || typeof toolCall !== "object") {
+        continue;
+      }
+
+      const fn = toolCall.function;
+      if (!fn || typeof fn !== "object") {
+        continue;
+      }
+
+      const name = fn.name;
+      const args = parseJsonObject(fn.arguments);
+      parts.push({
+        functionCall: {
+          name: name ?? "",
+          args,
+        },
+        thoughtSignature: "skip_thought_signature_validator",
+      });
+    }
+
+    msgObj.parts = parts;
+    delete msgObj.tool_calls;
+    delete msgObj.content;
+  }
+}
+
+/**
+ * Adds synthetic thoughtSignature to function calls in both flat and wrapped payloads.
+ */
+export function addThoughtSignaturesToFunctionCalls(requestPayload: Record<string, unknown>): void {
+  const processContents = (contents: unknown): void => {
+    if (!contents || !Array.isArray(contents)) {
+      return;
+    }
+
+    for (const content of contents) {
+      if (!content || typeof content !== "object") {
+        continue;
+      }
+
+      const parts = (content as Record<string, unknown>).parts;
+      if (!parts || !Array.isArray(parts)) {
+        continue;
+      }
+
+      for (const part of parts) {
+        if (!part || typeof part !== "object") {
+          continue;
+        }
+        const partObj = part as Record<string, unknown>;
+        if (partObj.functionCall && !partObj.thoughtSignature) {
+          partObj.thoughtSignature = "skip_thought_signature_validator";
+        }
+      }
+    }
+  };
+
+  processContents(requestPayload.contents);
+  if (requestPayload.request && typeof requestPayload.request === "object") {
+    processContents((requestPayload.request as Record<string, unknown>).contents);
+  }
+}
+
+function parseJsonObject(value: unknown): Record<string, unknown> {
+  if (typeof value !== "string") {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (parsed && typeof parsed === "object") {
+      return parsed as Record<string, unknown>;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}

package/src/plugin/request/prepare.ts

@@ -0,0 +1,190 @@
+import { randomUUID } from "node:crypto";
+
+import { CODE_ASSIST_HEADERS, GEMINI_CODE_ASSIST_ENDPOINT } from "../../constants";
+import { normalizeThinkingConfig } from "../request-helpers";
+import { normalizeRequestPayloadIdentifiers, normalizeWrappedIdentifiers } from "./identifiers";
+import { addThoughtSignaturesToFunctionCalls, transformOpenAIToolCalls } from "./openai";
+import { isGenerativeLanguageRequest, toRequestUrlString } from "./shared";
+
+const STREAM_ACTION = "streamGenerateContent";
+const MODEL_FALLBACKS: Record<string, string> = {
+  "gemini-2.5-flash-image": "gemini-2.5-flash",
+};
+
+/**
+ * Rewrites OpenAI-style requests into Gemini Code Assist request shape.
+ */
+export function prepareGeminiRequest(
+  input: RequestInfo,
+  init: RequestInit | undefined,
+  accessToken: string,
+  projectId: string,
+): {
+  request: RequestInfo;
+  init: RequestInit;
+  streaming: boolean;
+  requestedModel?: string;
+} {
+  const baseInit: RequestInit = { ...init };
+  const headers = new Headers(init?.headers ?? {});
+
+  if (!isGenerativeLanguageRequest(input)) {
+    return {
+      request: input,
+      init: { ...baseInit, headers },
+      streaming: false,
+    };
+  }
+
+  headers.set("Authorization", `Bearer ${accessToken}`);
+  headers.delete("x-api-key");
+
+  const match = toRequestUrlString(input).match(/\/models\/([^:]+):(\w+)/);
+  if (!match) {
+    return {
+      request: input,
+      init: { ...baseInit, headers },
+      streaming: false,
+    };
+  }
+
+  const [, rawModel = "", rawAction = ""] = match;
+  const effectiveModel = MODEL_FALLBACKS[rawModel] ?? rawModel;
+  const streaming = rawAction === STREAM_ACTION;
+  const transformedUrl = `${GEMINI_CODE_ASSIST_ENDPOINT}/v1internal:${rawAction}${
+    streaming ? "?alt=sse" : ""
+  }`;
+
+  let body = baseInit.body;
+  let requestIdentifier: string = randomUUID();
+
+  if (typeof baseInit.body === "string" && baseInit.body) {
+    const transformed = transformRequestBody(baseInit.body, projectId, effectiveModel);
+    if (transformed.body) {
+      body = transformed.body;
+      requestIdentifier = transformed.userPromptId;
+    }
+  }
+
+  if (streaming) {
+    headers.set("Accept", "text/event-stream");
+  }
+
+  headers.set("User-Agent", CODE_ASSIST_HEADERS["User-Agent"]);
+  headers.set("X-Goog-Api-Client", CODE_ASSIST_HEADERS["X-Goog-Api-Client"]);
+  headers.set("Client-Metadata", CODE_ASSIST_HEADERS["Client-Metadata"]);
+  /**
+   * Request-scoped identifier used by Gemini CLI tooling and backend traces.
+   * We keep this aligned so quota/debug triage can correlate client and server events.
+   */
+  headers.set("x-activity-request-id", requestIdentifier);
+
+  return {
+    request: transformedUrl,
+    init: {
+      ...baseInit,
+      headers,
+      body,
+    },
+    streaming,
+    requestedModel: rawModel,
+  };
+}
+
+function transformRequestBody(
+  body: string,
+  projectId: string,
+  effectiveModel: string,
+): { body?: string; userPromptId: string } {
+  const fallbackId = randomUUID();
+  try {
+    const parsedBody = JSON.parse(body) as Record<string, unknown>;
+    const isWrapped = typeof parsedBody.project === "string" && "request" in parsedBody;
+
+    if (isWrapped) {
+      const wrappedBody = {
+        ...parsedBody,
+        model: effectiveModel,
+      } as Record<string, unknown>;
+      const { userPromptId } = normalizeWrappedIdentifiers(wrappedBody);
+      return { body: JSON.stringify(wrappedBody), userPromptId };
+    }
+
+    const requestPayload = { ...parsedBody };
+    transformOpenAIToolCalls(requestPayload);
+    addThoughtSignaturesToFunctionCalls(requestPayload);
+    normalizeThinking(requestPayload);
+    normalizeSystemInstruction(requestPayload);
+    normalizeCachedContent(requestPayload);
+
+    if ("model" in requestPayload) {
+      delete requestPayload.model;
+    }
+
+    const { userPromptId } = normalizeRequestPayloadIdentifiers(requestPayload);
+    const wrappedBody = {
+      project: projectId,
+      model: effectiveModel,
+      user_prompt_id: userPromptId,
+      request: requestPayload,
+    };
+
+    return { body: JSON.stringify(wrappedBody), userPromptId };
+  } catch (error) {
+    console.error("Failed to transform Gemini request body:", error);
+    return { userPromptId: fallbackId };
+  }
+}
+
+function normalizeThinking(requestPayload: Record<string, unknown>): void {
+  const rawGenerationConfig = requestPayload.generationConfig as Record<string, unknown> | undefined;
+  const normalizedThinking = normalizeThinkingConfig(rawGenerationConfig?.thinkingConfig);
+  if (normalizedThinking) {
+    if (rawGenerationConfig) {
+      rawGenerationConfig.thinkingConfig = normalizedThinking;
+      requestPayload.generationConfig = rawGenerationConfig;
+    } else {
+      requestPayload.generationConfig = { thinkingConfig: normalizedThinking };
+    }
+    return;
+  }
+
+  if (rawGenerationConfig?.thinkingConfig) {
+    delete rawGenerationConfig.thinkingConfig;
+    requestPayload.generationConfig = rawGenerationConfig;
+  }
+}
+
+function normalizeSystemInstruction(requestPayload: Record<string, unknown>): void {
+  if ("system_instruction" in requestPayload) {
+    requestPayload.systemInstruction = requestPayload.system_instruction;
+    delete requestPayload.system_instruction;
+  }
+}
+
+function normalizeCachedContent(requestPayload: Record<string, unknown>): void {
+  const extraBody =
+    requestPayload.extra_body && typeof requestPayload.extra_body === "object"
+      ? (requestPayload.extra_body as Record<string, unknown>)
+      : undefined;
+  const cachedContentFromExtra = extraBody?.cached_content ?? extraBody?.cachedContent;
+  const cachedContent =
+    (requestPayload.cached_content as string | undefined) ??
+    (requestPayload.cachedContent as string | undefined) ??
+    (cachedContentFromExtra as string | undefined);
+
+  if (cachedContent) {
+    requestPayload.cachedContent = cachedContent;
+  }
+
+  delete requestPayload.cached_content;
+  if (!extraBody) {
+    return;
+  }
+
+  delete extraBody.cached_content;
+  delete extraBody.cachedContent;
+  if (Object.keys(extraBody).length === 0) {
+    delete requestPayload.extra_body;
+  }
+}

package/src/plugin/request/response.ts

@@ -0,0 +1,191 @@
+import { logGeminiDebugResponse, type GeminiDebugContext } from "../debug";
+import {
+  enhanceGeminiErrorResponse,
+  extractUsageMetadata,
+  parseGeminiApiBody,
+  rewriteGeminiPreviewAccessError,
+  type GeminiApiBody,
+} from "../request-helpers";
+import { injectResponseIdFromTrace } from "./shared";
+
+/**
+ * Normalizes Gemini responses, preserving request metadata and usage counters.
+ */
+export async function transformGeminiResponse(
+  response: Response,
+  streaming: boolean,
+  debugContext?: GeminiDebugContext | null,
+  requestedModel?: string,
+): Promise<Response> {
+  const contentType = response.headers.get("content-type") ?? "";
+  const isJsonResponse = contentType.includes("application/json");
+  const isEventStreamResponse = contentType.includes("text/event-stream");
+
+  if (!isJsonResponse && !isEventStreamResponse) {
+    logGeminiDebugResponse(debugContext, response, {
+      note: "Non-JSON response (body omitted)",
+    });
+    return response;
+  }
+
+  try {
+    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();
+    const init = {
+      status: response.status,
+      statusText: response.statusText,
+      headers,
+    };
+
+    const parsed: GeminiApiBody | null = !streaming || !isEventStreamResponse ? parseGeminiApiBody(text) : null;
+    const enhanced = !response.ok && parsed ? enhanceGeminiErrorResponse(parsed, response.status) : null;
+    if (enhanced?.retryAfterMs) {
+      const retryAfterSec = Math.ceil(enhanced.retryAfterMs / 1000).toString();
+      headers.set("Retry-After", retryAfterSec);
+      headers.set("retry-after-ms", String(enhanced.retryAfterMs));
+    }
+
+    const previewPatched = parsed
+      ? rewriteGeminiPreviewAccessError(enhanced?.body ?? parsed, response.status, requestedModel)
+      : null;
+
+    const effectiveBodyRaw = previewPatched ?? enhanced?.body ?? parsed ?? undefined;
+    const effectiveBody =
+      effectiveBodyRaw && typeof effectiveBodyRaw === "object"
+        ? injectResponseIdFromTrace(effectiveBodyRaw as Record<string, unknown>)
+        : effectiveBodyRaw;
+
+    attachUsageHeaders(headers, effectiveBody);
+
+    logGeminiDebugResponse(debugContext, response, {
+      body: text,
+      note: streaming ? "Streaming SSE payload (buffered)" : undefined,
+      headersOverride: headers,
+    });
+
+    if (!parsed) {
+      return new Response(text, init);
+    }
+
+    if (effectiveBody && typeof effectiveBody === "object" && "response" in effectiveBody) {
+      return new Response(JSON.stringify((effectiveBody as { response: unknown }).response), init);
+    }
+    if (previewPatched) {
+      return new Response(JSON.stringify(previewPatched), init);
+    }
+
+    return new Response(text, init);
+  } catch (error) {
+    logGeminiDebugResponse(debugContext, response, {
+      error,
+      note: "Failed to transform Gemini response",
+    });
+    console.error("Failed to transform Gemini response:", error);
+    return response;
+  }
+}
+
+function attachUsageHeaders(headers: Headers, effectiveBody: unknown): void {
+  if (!effectiveBody || typeof effectiveBody !== "object") {
+    return;
+  }
+  const usage = extractUsageMetadata(effectiveBody as GeminiApiBody);
+  if (usage?.cachedContentTokenCount === undefined) {
+    return;
+  }
+
+  headers.set("x-gemini-cached-content-token-count", String(usage.cachedContentTokenCount));
+  if (usage.totalTokenCount !== undefined) {
+    headers.set("x-gemini-total-token-count", String(usage.totalTokenCount));
+  }
+  if (usage.promptTokenCount !== undefined) {
+    headers.set("x-gemini-prompt-token-count", String(usage.promptTokenCount));
+  }
+  if (usage.candidatesTokenCount !== undefined) {
+    headers.set("x-gemini-candidates-token-count", String(usage.candidatesTokenCount));
+  }
+}
+
+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 hasCr = line.endsWith("\r");
+              const rawLine = hasCr ? line.slice(0, -1) : line;
+              const transformed = transformStreamingLine(rawLine);
+              controller.enqueue(encoder.encode(`${transformed}${hasCr ? "\r\n" : "\n"}`));
+              newlineIndex = buffer.indexOf("\n");
+            }
+            pump();
+          })
+          .catch((error) => {
+            controller.error(error);
+          });
+      };
+      pump();
+    },
+    cancel(reason) {
+      if (reader) {
+        reader.cancel(reason).catch(() => {});
+      }
+    },
+  });
+}
+
+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 Record<string, unknown>;
+    const patched = injectResponseIdFromTrace(parsed);
+    if (patched.response !== undefined) {
+      return `data: ${JSON.stringify(patched.response)}`;
+    }
+  } catch {
+    return line;
+  }
+  return line;
+}

package/src/plugin/request/shared.ts

@@ -0,0 +1,72 @@
+/**
+ * Returns a URL string for supported RequestInfo inputs.
+ */
+export 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();
+}
+
+/**
+ * Detects Gemini/Generative Language API requests by URL.
+ */
+export function isGenerativeLanguageRequest(input: RequestInfo): input is string {
+  return toRequestUrlString(input).includes("generativelanguage.googleapis.com");
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object";
+}
+
+export function readString(value: unknown): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+}
+
+export function pickString(...values: unknown[]): string | undefined {
+  for (const value of values) {
+    const str = readString(value);
+    if (str) {
+      return str;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Preserves Cloud Code trace identity for downstream clients by mapping traceId -> responseId.
+ */
+export function injectResponseIdFromTrace<T extends Record<string, unknown>>(body: T): T {
+  const traceId = readString(body.traceId);
+  if (!traceId) {
+    return body;
+  }
+
+  const response = body.response;
+  if (!isRecord(response)) {
+    return body;
+  }
+
+  if (readString(response.responseId)) {
+    return body;
+  }
+
+  return {
+    ...body,
+    response: {
+      ...response,
+      responseId: traceId,
+    },
+  };
+}