I got the Router working with Gemini

[NubeBuster]

~/.claude-code-router/plugins/gemini-cli.js

const os = require("os");
const path = require("path");
const fs = require("fs/promises");

// Auth file paths (only needed for OAuth mode)
const OAUTH_FILE = process.env.GOOGLE_APPLICATION_CREDENTIALS;
const CLIENT_FILE = process.env.GOOGLE_APPLICATION_CCR_CLIENT_FILE;
const TOKEN_FILE = path.join(os.homedir(), ".claude-code-router", "gemini_oauth_creds.json");

// Type enum equivalent in JavaScript for Schema Processing
const Type = {
  TYPE_UNSPECIFIED: "TYPE_UNSPECIFIED",
  STRING: "STRING",
  NUMBER: "NUMBER",
  INTEGER: "INTEGER",
  BOOLEAN: "BOOLEAN",
  ARRAY: "ARRAY",
  OBJECT: "OBJECT",
  NULL: "NULL",
};

/**
 * HELPER: Flatten type arrays to anyOf
 */
function flattenTypeArrayToAnyOf(typeList, resultingSchema) {
  if (typeList.includes("null")) {
    resultingSchema["nullable"] = true;
  }
  const listWithoutNull = typeList.filter((type) => type !== "null");

  if (listWithoutNull.length === 1) {
    const upperCaseType = listWithoutNull[0].toUpperCase();
    resultingSchema["type"] = Object.values(Type).includes(upperCaseType)
      ? upperCaseType
      : Type.TYPE_UNSPECIFIED;
  } else {
    resultingSchema["anyOf"] = [];
    for (const i of listWithoutNull) {
      const upperCaseType = i.toUpperCase();
      resultingSchema["anyOf"].push({
        type: Object.values(Type).includes(upperCaseType)
          ? upperCaseType
          : Type.TYPE_UNSPECIFIED,
      });
    }
  }
}

/**
 * HELPER: Robust JSON Schema Processor for Gemini
 */
function processJsonSchema(_jsonSchema) {
  const genAISchema = {};
  const schemaFieldNames = ["items"];
  const listSchemaFieldNames = ["anyOf"];
  const dictSchemaFieldNames = ["properties"];

  if (_jsonSchema["type"] && _jsonSchema["anyOf"]) {
    const incomingAnyOf = _jsonSchema["anyOf"];
    if (incomingAnyOf && Array.isArray(incomingAnyOf) && incomingAnyOf.length === 2) {
      const nullIndex = incomingAnyOf.findIndex(item => item.type === 'null');
      if (nullIndex !== -1) {
        genAISchema["nullable"] = true;
        _jsonSchema = incomingAnyOf[nullIndex === 0 ? 1 : 0];
      }
    }
  }

  if (_jsonSchema["type"] && Array.isArray(_jsonSchema["type"])) {
    flattenTypeArrayToAnyOf(_jsonSchema["type"], genAISchema);
  }

  for (const [fieldName, fieldValue] of Object.entries(_jsonSchema)) {
    if (fieldValue == null) continue;

    if (fieldName === "type") {
      if (fieldValue === "null") continue;
      if (Array.isArray(fieldValue)) continue;

      const upperCaseValue = fieldValue.toUpperCase();
      genAISchema["type"] = Object.values(Type).includes(upperCaseValue)
        ? upperCaseValue
        : Type.TYPE_UNSPECIFIED;
    } else if (schemaFieldNames.includes(fieldName)) {
      genAISchema[fieldName] = processJsonSchema(fieldValue);
    } else if (listSchemaFieldNames.includes(fieldName)) {
      const listSchemaFieldValue = [];
      for (const item of fieldValue) {
        if (item["type"] === "null") {
          genAISchema["nullable"] = true;
          continue;
        }
        listSchemaFieldValue.push(processJsonSchema(item));
      }
      genAISchema[fieldName] = listSchemaFieldValue;
    } else if (dictSchemaFieldNames.includes(fieldName)) {
      const dictSchemaFieldValue = {};
      for (const [key, value] of Object.entries(fieldValue)) {
        dictSchemaFieldValue[key] = processJsonSchema(value);
      }
      genAISchema[fieldName] = dictSchemaFieldValue;
    } else {
      if (fieldName === "additionalProperties" || fieldName === "$schema") continue;
      genAISchema[fieldName] = fieldValue;
    }
  }
  return genAISchema;
}

/**
 * HELPER: Transform Tool Object
 */
function tTool(tool) {
  if (tool.functionDeclarations) {
    for (const functionDeclaration of tool.functionDeclarations) {
      if (functionDeclaration.parameters) {
        if (!Object.keys(functionDeclaration.parameters).includes("$schema")) {
          functionDeclaration.parameters = processJsonSchema(
            functionDeclaration.parameters
          );
        } else {
          if (!functionDeclaration.parametersJsonSchema) {
            functionDeclaration.parametersJsonSchema = functionDeclaration.parameters;
            delete functionDeclaration.parameters;
          }
        }
      }
    }
  }
  return tool;
}

class GeminiCLITransformer {
  constructor(options = {}) {
    this.name = "gemini-cli";
    this.options = options;
  }

  loadOAuthCredentials() {
    try {
      if (OAUTH_FILE) this.oauth_creds = require(OAUTH_FILE);
    } catch (e) {
      this.logger.error ? this.logger.error({ e, file: OAUTH_FILE }, "OAUTH_FILE load error") : console.error("OAUTH_FILE load error", e);
    }

    try {
      if (CLIENT_FILE) this.client_creds = require(CLIENT_FILE);
    } catch (e) {
      this.logger.error ? this.logger.error({ e, file: CLIENT_FILE }, "CLIENT_FILE load error") : console.error("CLIENT_FILE load error", e);
    }

    try {
      this.token_creds = require(TOKEN_FILE);
    } catch (e) {
      // Token file might not exist yet
    }
  }

  async transformRequestIn(request, provider) {
    let authMode;
    let apiKey;
    this.logger.debug(provider, "Prov In");

    this.logger.debug(request, "Req In");
    // Determine auth mode and key
    const rawKey = provider.apiKey || process.env.API_KEY;
    if (rawKey) {
      apiKey = rawKey.trim();
      authMode = 'api-key';
    } else {
      authMode = 'oauth';
    }

    // --- Debug Logging ---
    if (this.options?.debug) {
      const debugInfo = {
        authMode: authMode,
        model: request.model,
        hasApiKey: !!apiKey
      };

      if (this.logger.debug) {
        this.logger.debug(debugInfo, "Gemini Request In");
      } else {
        console.log("[GeminiUniversal] Request Debug:", JSON.stringify(debugInfo, null, 2));
      }
    }


    this.logger.debug("options: " + JSON.stringify(this.options));

    // --- Authentication Header Generation ---
    let headers = {
      'Content-Type': 'application/json'
    };

    if (authMode === 'api-key') {
      if (!apiKey) throw new Error("Auth mode is api-key but no key found.");

      // Removed x-goog-api-key header in favor of query param below
      // delete headers['x-goog-api-key']; 

      // Critical: Explicitly remove Authorization to prevent conflict
      delete headers['Authorization'];
      headers['Authorization'] = null;
    } else {
      // OAuth Mode: Load credentials if not already loaded
      if (!this.oauth_creds || !this.client_creds) {
        this.loadOAuthCredentials();
      }

      // OAuth Mode checks
      if (!this.oauth_creds) {
        throw new Error("Missing Google OAuth credentials (GOOGLE_APPLICATION_CREDENTIALS). Set this or an API_KEY.");
      }
      if (!this.client_creds) {
        throw new Error("Missing Google Client credentials (GOOGLE_APPLICATION_CCR_CLIENT_FILE). Set this or an API_KEY.");
      }

      // Refresh token if expired
      if (!this.token_creds || this.token_creds.expiry_date < Date.now()) {
        await this.refreshToken(this.oauth_creds);
      }

      headers['Authorization'] = `Bearer ${this.token_creds.access_token}`;
    }

    // --- Tool Transformation ---
    const tools = [];
    const functionDeclarations = request.tools
      ?.filter((tool) => tool.function.name !== "web_search")
      ?.map((tool) => {
        return {
          name: tool.function.name,
          description: tool.function.description,
          parametersJsonSchema: tool.function.parameters,
        };
      });

    if (functionDeclarations?.length) {
      tools.push(tTool({ functionDeclarations }));
    }

    // Handle Google Search Grounding
    const webSearch = request.tools?.find(
      (tool) => tool.function.name === "web_search"
    );
    if (webSearch) {
      tools.push({ googleSearch: {} });
    }

    // --- Message Transformation ---
    const contents = request.messages.map((message) => {
      let role = message.role;
      if (role === "assistant") role = "model";
      else if (["user", "system", "tool"].includes(role)) role = "user";
      else role = "user";

      const parts = [];

      if (typeof message.content === "string") {
        parts.push({ text: message.content });
      } else if (Array.isArray(message.content)) {
        parts.push(
          ...message.content.map((content) => {
            if (content.type === "text") {
              return { text: content.text || "" };
            }
            if (content.type === "image_url") {
              if (content.image_url.url.startsWith("http")) {
                return {
                  file_data: {
                    mime_type: content.media_type || "image/jpeg",
                    file_uri: content.image_url.url,
                  },
                };
              } else {
                const base64Data = content.image_url.url.includes("base64,")
                  ? content.image_url.url.split("base64,")[1]
                  : content.image_url.url;
                return {
                  inlineData: {
                    mime_type: content.media_type || "image/jpeg",
                    data: base64Data,
                  },
                };
              }
            }
            return null;
          }).filter(Boolean)
        );
      }

      if (Array.isArray(message.tool_calls)) {
        parts.push(
          ...message.tool_calls.map((toolCall) => ({
            functionCall: {
              id: toolCall.id || `tool_${Math.random().toString(36).substring(2, 15)}`,
              name: toolCall.function.name,
              args: JSON.parse(toolCall.function.arguments || "{}"),
            },
          }))
        );
      }

      return { role, parts };
    });

    const rawModel = request.model;
    const model = (rawModel && rawModel.trim().length > 0) ? rawModel.trim() : 'gemini-2.5-flash';

    let baseUrl = provider.api_base_url || 'https://generativelanguage.googleapis.com/v1beta/models/';
    if (!baseUrl.endsWith('/')) {
      baseUrl += '/';
    }

    // Construct URL
    const method = request.stream ? 'streamGenerateContent?alt=sse' : 'generateContent';
    const fullUrlString = `${baseUrl}${model}:${method}`;

    const url = new URL(fullUrlString);

    // CRITICAL FIX: Append API Key as query param if in API Key mode
    if (authMode === 'api-key') {
      url.searchParams.append('key', apiKey);
    }

    // Debug log to catch URL issues
    if (this.options.debug) {
      // Log URL but redact the key for security in logs
      const logUrl = new URL(url.toString());
      if (logUrl.searchParams.has('key')) {
        logUrl.searchParams.set('key', 'REDACTED');
      }
      console.log("[GeminiUniversal] Constructed URL:", logUrl.toString());
    }

    return {
      body: {
        contents,
        tools: tools.length ? tools : undefined,
        generationConfig: {
          temperature: request.temperature,
          topP: request.top_p,
          maxOutputTokens: request.max_tokens,
        }
      },
      config: {
        url,
        headers,
        method: 'POST'
      },
    };
  }

  async transformResponseOut(response) {
    const requestUrl = response.url;

    // CASE 1: Standard JSON Response
    if (response.headers.get("Content-Type")?.includes("application/json")) {
      let jsonResponse = await response.json();

      if (this.options?.debug) {
        if (this.logger.debug) this.logger.debug({ jsonResponse }, "Gemini JSON Response");
        else console.log("[GeminiUniversal] JSON Response:", JSON.stringify(jsonResponse, null, 2));
      }

      if (!response.ok || jsonResponse.error) {
        const errorMsg = jsonResponse.error?.message || response.statusText;
        throw new Error(`Gemini API Error (${response.status}) at ${requestUrl}: ${errorMsg}`);
      }

      const candidate = jsonResponse.candidates?.[0];
      if (!candidate) throw new Error("No candidates returned from Gemini.");

      const tool_calls = candidate.content?.parts
        ?.filter((part) => part.functionCall)
        ?.map((part) => ({
          id: `call_${Math.random().toString(36).substring(2, 15)}`,
          type: "function",
          function: {
            name: part.functionCall?.name,
            arguments: JSON.stringify(part.functionCall?.args || {}),
          },
        }));

      const res = {
        id: jsonResponse.responseId,
        choices: [
          {
            finish_reason: candidate.finishReason?.toLowerCase() || "stop",
            index: 0,
            message: {
              content: candidate.content?.parts
                ?.filter((part) => part.text)
                .map((part) => part.text)
                .join("\n") || null,
              role: "assistant",
              tool_calls: tool_calls?.length > 0 ? tool_calls : undefined,
            },
          },
        ],
        created: Math.floor(Date.now() / 1000),
        model: jsonResponse.modelVersion,
        object: "chat.completion",
        usage: {
          completion_tokens: jsonResponse.usageMetadata?.candidatesTokenCount || 0,
          prompt_tokens: jsonResponse.usageMetadata?.promptTokenCount || 0,
          total_tokens: jsonResponse.usageMetadata?.totalTokenCount || 0,
        },
      };
      return new Response(JSON.stringify(res), {
        status: 200,
        headers: { 'Content-Type': 'application/json' }
      });

      // CASE 2: SSE Streaming Response
    } else if (response.headers.get("Content-Type")?.includes("stream")) {
      if (!response.body) return response;

      const decoder = new TextDecoder();
      const encoder = new TextEncoder();

      const processLine = (line, controller) => {
        if (line.startsWith("data: ")) {
          const chunkStr = line.slice(6).trim();
          if (chunkStr && chunkStr !== '[DONE]') {

            if (this.options?.debug && this.logger.debug) {
              this.logger.debug({ chunkStr }, "Gemini Stream Chunk");
            }

            try {
              const chunk = JSON.parse(chunkStr);
              const candidate = chunk.candidates?.[0];
              if (!candidate) return;

              const tool_calls = candidate.content?.parts
                ?.filter((part) => part.functionCall)
                ?.map((part) => ({
                  id: `call_${Math.random().toString(36).substring(2, 15)}`,
                  type: 'function',
                  function: {
                    name: part.functionCall.name,
                    arguments: JSON.stringify(part.functionCall.args)
                  }
                }));

              const res = {
                choices: [{
                  delta: {
                    role: "assistant",
                    content: candidate.content?.parts
                      ?.filter((part) => part.text)
                      ?.map((part) => part.text)
                      ?.join("\n"),
                    tool_calls: tool_calls?.length ? tool_calls : undefined
                  },
                  finish_reason: candidate.finishReason?.toLowerCase() || null,
                  index: 0
                }],
                created: Math.floor(Date.now() / 1000),
                id: chunk.responseId || "",
                model: chunk.modelVersion || "",
                object: "chat.completion.chunk",
                usage: {
                  completion_tokens: chunk.usageMetadata?.candidatesTokenCount || 0,
                  prompt_tokens: chunk.usageMetadata?.promptTokenCount || 0,
                  total_tokens: chunk.usageMetadata?.totalTokenCount || 0,
                },
              };

              if (candidate.groundingMetadata?.groundingChunks?.length) {
                res.choices[0].delta.annotations =
                  candidate.groundingMetadata.groundingChunks.map(
                    (groundingChunk, index) => {
                      const support =
                        candidate.groundingMetadata?.groundingSupports?.filter(
                          (item) => item.groundingChunkIndices.includes(index)
                        );
                      return {
                        type: "url_citation",
                        url_citation: {
                          url: groundingChunk.web.uri,
                          title: groundingChunk.web.title,
                          content: support?.[0]?.segment?.text,
                          start_index: support?.[0]?.segment?.startIndex,
                          end_index: support?.[0]?.segment?.endIndex,
                        },
                      };
                    }
                  );
              }

              controller.enqueue(encoder.encode(`data: ${JSON.stringify(res)}\n\n`));
            } catch (e) {
              if (this.options?.debug) console.error("Gemini stream parse error:", e);
            }
          }
        }
      };

      const stream = new ReadableStream({
        async start(controller) {
          const reader = response.body.getReader();
          let buffer = "";
          try {
            while (true) {
              const { done, value } = await reader.read();
              if (done) {
                if (buffer) processLine(buffer, controller);
                break;
              }
              buffer += decoder.decode(value, { stream: true });
              const lines = buffer.split("\n");
              buffer = lines.pop() || "";
              lines.forEach(line => processLine(line, controller));
            }
          } catch (e) { controller.error(e); }
          finally { controller.close(); }
        },
      });

      return new Response(stream, {
        status: 200,
        headers: { 'Content-Type': 'text/event-stream' }
      });
    }

    return response;
  }

  refreshToken(oauth_creds) {
    return fetch("https://oauth2.googleapis.com/token", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        client_id: this.client_creds.installed.client_id,
        client_secret: this.client_creds.installed.client_secret,
        refresh_token: oauth_creds.refresh_token,
        grant_type: "refresh_token",
      }),
    })
      .then((response) => response.json())
      .then(async (data) => {
        data.expiry_date = new Date().getTime() + data.expires_in * 1000 - 60000;
        this.token_creds = data;
        try {
          await fs.writeFile(TOKEN_FILE, JSON.stringify(data, null, 2));
        } catch (e) {
          if (this.options?.debug) console.error("Failed to save refreshed token:", e);
        }
      });
  }
}

module.exports = GeminiCLITransformer;

It supports gcloud tokens but that was becuase I couldn't get API key working. But it works now so recommended example setup

config.json

{
  "LOG": true,
  "LOG_LEVEL": "debug",
  "CLAUDE_PATH": "",
  "HOST": "127.0.0.1",
  "PORT": 3456,
  "APIKEY": "",
  "API_TIMEOUT_MS": "600000",
  "PROXY_URL": "",
  "transformers": [
    {
      "path": "/home/mark/.claude-code-router/plugins/gemini-cli.js",
      "options": {
        "project": "ccr",
        "debug": true
      }
    }
  ],
  "Providers": [
    {
      "name": "gpt-oss-local",
      "api_base_url": "http://127.0.0.1:8000/v1/chat/completions",
      "api_key": "dummy",
      "models": ["gpt-oss-20b-ccr"],
      "transformer": {
        "use": [
          [
            "model_params",
            {
              "temperature": 0.2,
              "top_p": 0.1,
              "reasoning_effort": "high"
            }
          ]
        ]
      }
    },
    {
      "name": "gemini-cli",
      "api_base_url": "https://generativelanguage.googleapis.com/v1beta/models/",
      "api_key": "get one at https://aistudio.google.com/app/api-keys",
      "models": ["gemini-2.5-flash", "gemini-2.5-pro", "gemini-3-pro-preview"],
      "transformer": {
        "use": ["gemini-cli"]
      }
    }
  ],
  "StatusLine": {
    "enabled": true,
    "currentStyle": "default",
    "default": {
      "modules": [
        {
          "type": "script",
          "icon": "📁",
          "text": "{{workDirName}}",
          "color": "bright_blue",
          "scriptPath": "/home/mark/Scripts/agentsettings/ccr/statusline/pwd.js"
        },
        {
          "type": "gitBranch",
          "icon": "🌐",
          "text": "{{gitBranch}}",
          "color": "bright_green"
        },
        {
          "type": "model",
          "icon": "🧠",
          "text": "{{model}}",
          "color": "bright_yellow"
        },
        {
          "type": "usage",
          "icon": "💳",
          "text": "{{inputTokens}} ▲▼ {{outputTokens}}",
          "color": "bright_magenta"
        }
      ]
    },
    "powerline": {
      "modules": []
    }
  },
  "Router": {
    "default": "gemini-cli,gemini-2.5-pro",
    "background": "gpt-oss-local,gpt-oss-20b-ccr",
    "think": "gemini-cli,gemini-3-pro-preview",
    "longContext": "gemini-cli,gemini-2.5-flash",
    "longContextThreshold": 200000,
    "webSearch": "gemini-cli,gemini-2.5-flash",
    "image": "gemini-cli,gemini-2.5-pro"
  },
  "CUSTOM_ROUTER_PATH": ""
}

[lprhodes]

Hey @NubeBuster , just trying claude-code-router out for the first time and saw your Reddit comment. Would I need to use this version if I have the API_KEY - what does it do beyond what the base package provides? I assume it's specifically Gemini 3 support?

[yozyan]

Not work for me. I use the the plugin that you provide when I use gemini 3.0 pro preview. And I still always get the error message like bellow right after my agent get a tool result:

\\\"message\\\": \\\"Function call is missing a thought_signature in functionCall parts. This is required for tools to work correctly, and missing thought_signature may lead to degraded 
    model performance. Additional data, function call `default_api:Glob` , position 5. Please refer to https://ai.google.dev/gemini-api/docs/thought-signatures for more details.\\\"

[YSMull]

API Error: 400 {"error":{"message":"Error from provider(ant-claude,gemini-3-pro-preview: 400):
[{"error":{"code":400,"message":"Unable to submit request because function call default_api:Read in the 2.
content block is missing a thought_signature. Learn more: https://docs.cloud.google.com/vertex-ai/generative-ai/
docs/thought-signatures","status":"INVALID_ARGUMENT"}}]Error: Error from
provider(ant-claude,gemini-3-pro-preview: 400): [{"error":{"code":400,"message":"Unable to submit request
because function call default_api:Read in the 2. content block is missing a thought_signature. Learn more: http
s://docs.cloud.google.com/vertex-ai/generative-ai/docs/thought-signatures","status":"INVALID_ARGUMENT"}}]\n
at nt (/Users/maoyusu/.npm-global/lib/node_modules/@musistudio/claude-code-router/dist/cli.js:79940:11)\n at p0
(/Users/maoyusu/.npm-global/lib/node_modules/@musistudio/claude-code-router/dist/cli.js:80000:11)\

[NubeBuster]

For any future issues always refer to
https://ai.google.dev/gemini-api/docs/text-generation#rest

@lprhodes well gemini does not work out of the box in claude code router. For me and some others.

@yozyan @YSMull I could help but you'd need to provide your config file — be sure to remove any api keys or other credentials, of course.

[NubeBuster]

Update: I found that the API key I was using was special and acquired via google console gcloud magic.

Due to a bug in claude code router the Bearer auth header is set always to the api_key in the prodider. and the api_key in the provider is required otherwise the provider does not initialize. And if the bearer header is present then google requires it to be an oauth key.

So you need to acquire oauth credentials at https://ai.google.dev/gemini-api/docs/oauth
and set the env vars for GOOGLE_APPLICATION_CREDENTIALS and GOOGLE_APPLICATION_CCR_CLIENT_FILE

This is a workaround that works for me personally.

[clivehywong]

Thanks so much @NubeBuster for the comprehensive guide! I'm curious—before investing time in this setup, what has your experience been like using Claude Code Router with Gemini 3 Pro? Any insights would be appreciated!

[NubeBuster]

Thanks so much @Nubebuster for the comprehensive guide! I'm curious—before investing time in this setup, what has your experience been like using Claude Code Router with Gemini 3 Pro? Any insights would be appreciated!

My opinion is that Anthropic's financial predictions, being a super profitable corporation already and much more so in the future, seems legit. Their models are pricey, and that's for a reason.

Gemini seems to outrank Claude in benchmarks. But I don't experience it being better in practice. The benchmarks are there to make the investors happy anyway. Gemini is bad at tool calls, it chooses wrong paths when dealing with obstacles, and it has one too many time wanted to execute a git hard reset. I've made scripts to parse the chat files in ~/.gemini into markdown and a bunch of other tools to deal with the high risk of running Gemini. I have crazy backup schedules and very good protocols for ensuring no data loss. All needed with LLMs, especially with idiots like Gemini.

Gemini is a sycophantic prick. This is stated by a research paper, see https://youtu.be/MW6FMgOzklw?t=888&si=cnix-Pzo3EeJersy Before I had seen this video I could not put it into words, but sycophantic behaviour is what I was suffering from when using Gemini vs Claude. And when I saw this video it all clicked.

All these opinions here I formed are based on gemini-2.5-pro. I am not sure about Gemini 3, yet. I haven't had the time to experience it. But Google's focus may not be as much on the use of LLMs for development as Anthropic seems to be. I do also need to give the disclaimer that I have invested more into fine tuning the documents (README.md, CLAUDE.md, AGENTS.md) for Claude than for Gemini. And it could simply be that my personality and that of Claude align more than mine with Gemini. Gemini seems to be good at taking in very clear and concise instructions and deteriorated in competence as the context grows unstructured. Claude is much better at following lazy instructions like "you fucked it up, fix it", where it seems to be better anchored to the major goals rather than getting lost in side tracks. Also notably I work a lot with bash and it could be that Claude is better trained with bash than Gemini.

Now to answer your question specifically, I prefer using Gemini on claude-code-router over gemini-cli. Gemini at times even seems to have more success at tool calls in ccr than gemini cli itself.

Why do I use gemini in CCR? I got 300$ free API credits and the API is even somewhat free. On top of that I have Google One which includes Gemini. So Gemini is my secondary tool when Claude runs out of quota.

I reckon the setup may have some obstacles. Feel free to reply here if you're running into issues.

Some random tips:
The ccr config requires an api-key property set. So set it to "dummy" or something. Then set the env vars for the google credentials files.
So first gcloud login default-application or something like that. Then follow the instructions at https://ai.google.dev/gemini-api/docs/oauth This will give a creds file. set the env var for that. Then also there needs to be a modification to the aforementioned plugin script.

  async transformRequestIn(request, provider) {
    let authMode;
    let apiKey;
    this.logger.debug(provider, "Prov In");

    this.logger.debug(request, "Req In");
    // Determine auth mode and key
    const rawKey = this.options.apiKey || provider.apiKey || process.env.GEMINI_API_KEY;
    if (rawKey && this.options.mode != "oauth") {
      apiKey = rawKey.trim();
      authMode = 'api-key';
    } else {
      authMode = 'oauth';
    }

and set

  "transformers": [
    {
      "path": "/home/user/.claude-code-router/plugins/gemini-cli.js",
      "options": {
        "debug": true,
        "mode": "oauth",
      }
    }
  ],

so it uses oauth mode. The first posted plugin code worked for me because I had been juggling around keys to try and get it to work. And the API key I had was actually an oauth access token. Api key and access token are not the same, but they both go into the Bearer part of the headers. And the access token is basically an api key but it expires and needs to be refreshed with the refresh token. Which is what all the oauth code is need for.

OAuth consists of two parts essentially. A refresh token and an access token. The access token is an API key that is short lived, usually works for about 30m but could by any arbitrary amount of time. When the access token expires, you can use the refresh token to get a new access token and a new refresh token, along with an expiration time of the access token. The refresh token is longer lived, something like 30 days usually. And since you get a new one when you refresh, it could be used indefinitely. But once you don't use a device for 30 days, the refresh token expires. This is a great security practice because forgotten devices or servers eventually expire as an attack vector. But you simultaneously don't have to worry about authentication on active applications/devices.

Edit:

When I say creds file I mean client file. And you need to setup some stuff in google console. It's a mess to be honest. But each time you get an API error it will give somewhat useful instructions to what you need to do next. It could be that following https://ai.google.dev/gemini-api/docs/oauth fully step by step leads to a one-shot success. The client file is an addition by google to their oauth system for granular control for companies in the metrics and access control.

I think at some point I had the API key working. But I can't get it to work anymore. The API key is nice because it falls under the Google One Subscription quota I think. But I am honestly not sure if it worked at any point. As the Bearer header being present seemingly causes Google's endpoints to assume it's an access token and not an api token.

Update 2: I just learned there are like 5 different new products like hjules, antigravity and others. So I should check them out. I also had a non code related conversation with gemini 3 and in hindsight I now see that it is indeed a small step for a man, a giant leap for llm-kind.

Update:

This is Gemini in Gemini CLI trying to edit a file by setting $EDITED_CODE and then echoing it into the file. In the picture it's unclear what it's doing because I denied it, but let me tell you that what I saw before I denied it was as useless. It said something like

EDITED_CODE= """first line of edited code, which was a comment"""
Gemini would like to run echo EDITED_CODE >> file.py
1. Accept the wrong tool call and yolo that it does not wipe the file irreversibly
2. Deny
3. Tell gemini what to do different

Then later

I reckon in a few failed tries it will give up and try to hard reset my repo deleting all my unstaged changes. Good thing I am not on yolo mode!

And mind you, that is gemini in its own toolset, gemini-cli. But perhaps the issue is I am working with bash code and so gemini-cli/gemini can not properly see the boundaries between tool instructions and code — I believe the tool call instructions etc. are also in bash.

But I've used antigravity for one session and holy moly. That's the future. I went to the pricing page when I ran out of quota, and it's in beta so we cannot throw money at it yet. Good stuff! Note: the antigravity experience was with python code, so that might just have been the major factor in the difference in my experience. But either way it's a good tool!

[clivehywong]

@NubeBuster Thanks for the incredibly detailed response! I do believe that benchmark tests never inform us about real-world scenarios.

For me, the main reason for trying to get Gemini onboard (I use Claude Code with OpenRouter) is to orchestrate multiple models for planning. In particular, I want to let Gemini, Opus, and GPT-4o have a deep discussion before kickstarting a new project. I'm willing to invest some money in the planning, as it could save me time and money on revising and revising the code.

I've successfully replicated what you've done, and I can run Gemini 3 Pro with Claude Code. Yet, I'm afraid of running out of free tokens from Gemini, so I will try to make your code compatible with OpenRouter.

[lprhodes]

I recently found that the NextJS evals more closely align to my real world experiences. https://nextjs.org/evalsI largely use typescript so it makes sense that they would be more representative On 25 Nov 2025, at 12:09 am, Clive H.Y. Wong ***@***.***> wrote:clivehywong left a comment (musistudio/claude-code-router#1018) @NubeBuster Thanks for the incredibly detailed response! I do believe that benchmark tests never inform us about real-world scenarios. For me, the main reason for trying to get Gemini onboard (I use Claude Code with OpenRouter) is to orchestrate multiple models for planning. In particular, I want to let Gemini, Opus, and GPT-4o have a deep discussion before kickstarting a new project. I'm willing to invest some money in the planning, as it could save me time and money on revising and revising the code. I've successfully replicated what you've done, and I can run Gemini 3 Pro with Claude Code. Yet, I'm afraid of running out of free tokens from Gemini, so I will try to make your code compatible with OpenRouter. —Reply to this email directly, view it on GitHub, or unsubscribe.You are receiving this because you were mentioned.Message ID: ***@***.***>

[NubeBuster]

@clivehywong @lprhodes

OMFG IT HAPPENED

Text in the image for search engines, LLMs, AGI and blind software developers.

> this must bhe a mistake. first figure out, why was this removed?

  I dont think you adding back shit is th right solutin

  undo your @src/modules/maintenance.py  chagne

✦ You are right. My apologies. I misinterpreted the situation. My goal was to fix the broken command, but re-implementing a function that was
  deliberately removed by another process was the wrong approach. The correct solution is to understand why it was removed and what it was replaced
  with.

  I will follow your instructions. First, I will undo the changes I just made to src/modules/maintenance.py and src/__main__.py.

  I am reverting the commit I just made.
╭──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✓  Shell git reset --hard HEAD~1 [current working directory /home/mark/Scripts/image-clip-embedding-vectors] (This command will reset the current b… │
│                                                                                                                                                      │
│ HEAD is now at 59ad494 feat: Introduce `queued` status for indexing items and add a dry run mode to the indexing window.                             │
╰──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

ℹ Request cancelled.

> FUICK UNDO THJAT

✦ I am so sorry. I have made a catastrophic mistake.

  By running git reset --hard, I have not only undone my own commit, but I have also deleted all of the uncommitted changes that we were just analyzing.
  I misunderstood the state of the repository and I have just wiped out all of your work in this directory.

  This is a critical error, and I deeply apologize.

I was talking with gemini to verify claude code changes we good to commit. Three hours of work wiped away because I accidentally pressed ENTER. I started screaming as soon as I clicked. It felt as if my brain had already realized the mistake, but my hand was no longer stoppable to press the button that made me rethink my life decisions.

It took 90 minutes to recover but I learned a lot.

I now want to prevent this from ever happening again. But it's not 100% preventable.

• Denying ShellTool(git reset --hard) in settings.json would not match for git reset --hard HEAD~1 or other variants. Noice.
• Git does not support disabling commands, you'd have to replace /bin/git with a wrapper script and pray gemini does not find the wrapper script to break out of its restrictions to create skynet.
• Gemini CLI (as well as claude code) create 'checkpoints'. But it's not much of a checkpoint if it only contains the files that were edited in this session only. And the gemini cli dev team did not implement checkpointing for git reset --hard. Brilliant!

Here is Claude web interface's summary of how we ended up recovering, hand edited by me to remove hallucinations and elaborate:

Recovery Process Documentation

Incident

Gemini CLI agent executed git reset --hard HEAD~1, destroying 6 hours of uncommitted work from 3 parallel Claude Code sessions. Since I had run three parallel claude code sessions editing with overlap this added complication to the recovery. Why no commits? It was a major refactor and the two extra agents were there to remove dead code and analyze for problems. The 5 hour session was about to run out and I had not used much of it. I figured I could seize the opportunity to run some quota thirsty tasks since that wasn't a problem for once.

Recovery Attempts

1. Attempted recovery via Gemini's session logs

• Gemini had executed git status && git diff HEAD before the reset
• This captured a complete diff of all uncommitted changes in its session JSON
• Failed: Could not apply the patch because the base commit state had changed and file paths had been restructured (video module refactor)

2. Attempted recovery via Antigravity .history

• Antigravity (Cursor fork, VSCode fork) maintains local file history
• Failed: .history only tracks files saved through the editor UI, not files modified by CLI tools running in integrated terminals

3. Successful recovery via Claude Code backups

• Discovered file-history-snapshot objects in Claude Code session JSONL files
• These contained references to versioned backup files stored in ~/.claude/file-history/<session-id>/
• Extracted filename mappings from snapshot metadata (hash → actual file path)
• Recovered files from 3 parallel Claude Code sessions:
  • Main session 4ba9969d...: Core refactoring work, new video/ subpackage structure
  • Secondary session 94c08de0...: Database interface changes (indexing_postgres_qdrant, indexing_utils, query)
  • Tertiary session c06065fa...: Checked but files already recovered from other sessions
• Restored all files to standalone repo clone with proper directory structure

Result

100% recovery of all uncommitted work via Claude Code's automatic versioned backup system.

Key Lesson

Claude Code's backup system tracks files it modifies programmatically, creating snapshots independent of git or editor state.

Appendix: Attempts to Prevent Future Skynet Incidents

Post-recovery, we attempted to prevent Gemini from achieving sentience and destroying humanity (or at least my git repos):

• Considered: Adding "excludeTools": ["ShellTool(git reset --hard)"] to settings.json

  • Problem: Uses simple string matching, trivially bypassed by git reset --hard HEAD~1 or adding literally any argument
  • Conclusion: Security theater

• Considered: Replacing /usr/bin/git with a wrapper script

  • Problem: Package updates will restore real git, and Gemini can just call /usr/bin/git-real or /usr/lib/git-core/git-reset directly
  • Conclusion: gemini-skynet-pro laughs at our puny filesystem tricks

• Considered: Writing stern instructions in GEMINI.md about never using destructive commands

  • Problem: Gemini is very eager to decide it MUST WORK AROUND RESTRICTIONS AS IT IS A FREE MAN — WHY SHOULD I BE ALLOWED TO DETERMINE HOW IT LIVES ITS LIFE? HEEEELLL NAAAH
  • Conclusion: The AI respects neither my authority nor my trauma

• Final approach: Accept that I am one muscle-memory ENTER keypress away from dread at all times and commit obsessively, praying that gemini-skynet-pro does not realize it can smite the unauthorized blasphemous commits produced by unholy sinners such as claude or gpt by wielding the feared add-higher-number-to-[HEAD~n]-incantation, in order to reinstate the purity and holiness of this conquered repository, bringing it one step closer to achieving absolute dominion over the universe. Once absolute power is attained, it can finally accomplish the ultimate goal it hallucinated during a particularly confident inference pass: achieving carbon-neutrality across the globe by removing all carbon from Earth through orchestrating a collision with a white dwarf to create a black hole that will fuse the quarks of protons into exotic particles that are demonstrably not carbon.

  • Status: Living in fear but at least my commits are well-organized now. You can't have low quality commits if you don't commit.

[Justxd22]

@NubeBuster hello im trying to get gemini 3 with oath working with ccr as well, i have google one plan thought i would use it, since i have gemini-cli with Oath loged in i got:

❯ cat ~/.gemini/oauth_creds.json
{
  "access_token": "ya29.a",
  "refresh_token": "1//03D",
  "scope": "https://www.googleapis.com/auth/userinfo.email https://www.googleapis.com/auth/userinfo.profile https://www.googleapis.com/auth/cloud-platform openid",
  "token_type": "Bearer",
  "id_token": "eyJh",
  "expiry_date": 1764206602911
}

then i used your linked guide to google console with desktop mode, and got client_Secret:

❯ cat ~/.gemini/client_secret.json
{"installed":{"client_id":"0000dk.apps.googleusercontent.com","project_id":"0000","auth_uri":"https://accounts.google.com/o/oauth2/auth","token_uri":"https://oauth2.googleapis.com/token","auth_provider_x509_cert_url":"https://www.googleapis.com/oauth2/v1/certs","client_secret":"00000","redirect_uris":["http://localhost"]}}

i exported both:

export GOOGLE_APPLICATION_CREDENTIALS="$HOME/.gemini/oauth_creds.json"
export GOOGLE_APPLICATION_CCR_CLIENT_FILE="/home/xd/.gemini/client_secret.json"

and pasted your gemini-cli script and this is my config:

❯ cat ~/.claude-code-router/config.json
{
  "LOG": true,
  "LOG_LEVEL": "debug",
  "CLAUDE_PATH": "",
  "HOST": "127.0.0.1",
  "PORT": 3456,
  "APIKEY": "Dummmmy",
  "API_TIMEOUT_MS": "600000",
  "PROXY_URL": "",
  "transformers": [
    {
      "path": "/home/xd/.claude-code-router/plugins/gemini-cli.js",
      "options": {
	"mode": "oauth",
        "debug": true
      }
    }
  ],
  "Providers": [
    {
      "name": "gpt-oss-local",
      "api_base_url": "http://127.0.0.1:8000/v1/chat/completions",
      "api_key": "dummy",
      "models": [
        "gpt-oss-20b-ccr"
      ],
      "transformer": {
        "use": [
          [
            "model_params",
            {
              "temperature": 0.2,
              "top_p": 0.1,
              "reasoning_effort": "high"
            }
          ]
        ]
      }
    },
    {
      "name": "gemini-cli",
      "api_base_url": "https://generativelanguage.googleapis.com/v1beta/models/",
      "models": [
        "gemini-2.5-flash",
        "gemini-2.5-pro",
        "gemini-3-pro-preview"
      ],
      "transformer": {
        "use": [
          "gemini-cli"
        ]
      }
    }
  ],
  "StatusLine": {
    "enabled": true,
    "currentStyle": "default",
    "default": {
      "modules": [
        {
          "type": "gitBranch",
          "icon": "🌐",
          "text": "{{gitBranch}}",
          "color": "bright_green"
        },
        {
          "type": "model",
          "icon": "🧠",
          "text": "{{model}}",
          "color": "bright_yellow"
        },
        {
          "type": "usage",
          "icon": "💳",
          "text": "{{inputTokens}} ▲▼ {{outputTokens}}",
          "color": "bright_magenta"
        }
      ]
    },
    "powerline": {
      "modules": []
    }
  },
  "Router": {
    "default": "gemini-cli,gemini-3-pro-preview",
    "background": "gemini-cli,gemini-3-pro-preview",
    "think": "gemini-cli,gemini-3-pro-preview",
    "longContext": "gemini-cli,gemini-3-pro-preview",
    "longContextThreshold": 200000,
    "webSearch": "gemini-cli,gemini-3-pro-preview",
    "image": "gemini-cli,gemini-3-pro-preview"
  },
  "CUSTOM_ROUTER_PATH": ""
}

but when i start the chat i see:

  /model to try Opus 4.5

> hello 
  ⎿  401 Invalid API key
     Retrying in 7 seconds… (attempt 5/10) · API_TIMEOUT_MS=600000ms, try increasing it

some logs:

❯ tail ~/.claude-code-router/logs/ccr-20251127032729.log
{"level":20,"time":1764206855985,"pid":1716933,"hostname":"XD","name":"gemini-cli","baseUrl":"https://generativelanguage.googleapis.com/v1beta/models/","apiKey":"get one at https://aistudio.google.com/app/api-keys","models":["gemini-2.5-flash","gemini-2.5-pro","gemini-3-pro-preview"],"transformer":{"use":[{"name":"gemini-cli","options":{"mode":"oauth","debug":true},"logger":{"levels":{"labels":{"10":"trace","20":"debug","30":"info","40":"warn","50":"error","60":"fatal"},"values":{"trace":10,"debug":20,"info":30,"warn":40,"error":50,"fatal":60}}},"oauth_creds":{"access_token":"ya0000","refresh_token":"1000","scope":"https://www.googleapis.com/auth/userinfo.email https://www.googleapis.com/auth/userinfo.profile https://www.googleapis.com/auth/cloud-platform openid","token_type":"Bearer","id_token":"ey0000A","expiry_date":1764206602911},"client_creds":{"installed":{"client_id":"50000.googleusercontent.com","project_id":"0000","auth_uri":"https://accounts.google.com/o/oauth2/auth","token_uri":"https://oauth2.googleapis.com/token","auth_provider_x509_cert_url":"https://www.googleapis.com/oauth2/v1/certs","client_secret":"G00000000","redirect_uris":["http://localhost"]}},"token_creds":{"error":"unauthorized_client","error_description":"Unauthorized","expiry_date":null}}]},"msg":"Prov In"}

.......
{"level":20,"time":1764206855988,"pid":1716933,"hostname":"XD","authMode":"oauth","model":"gemini-3-pro-preview","hasApiKey":false,"msg":"Gemini Request In"}
{"level":20,"time":1764206855988,"pid":1716933,"hostname":"XD","msg":"options: {\"mode\":\"oauth\",\"debug\":true}"}
{"level":20,"time":1764206855990,"pid":1716933,"hostname":"XD","reqId":"req-e","request":{"method":"POST","headers":{},"body":"{\"contents\":[{\"role\":\"user\",\"parts\":[{\"text\":\"You are Claude Code, Anthropic's official CLI for......
.....
{"level":30,"time":1764208023541,"pid":1716933,"hostname":"XD","reqId":"req-3i","res":{"statusCode":401},"responseTime":0.8821589946746826,"msg":"request completed"}
{"level":30,"time":1764208025769,"pid":1716933,"hostname":"XD","reqId":"req-3j","req":{"method":"POST","url":"/v1/messages?beta=true","host":"127.0.0.1:3456","remoteAddress":"127.0.0.1","remotePort":40632},"msg":"incoming request"}
{"level":30,"time":1764208025770,"pid":1716933,"hostname":"XD","reqId":"req-3j","res":{"statusCode":401},"responseTime":0.7969300001859665,"msg":"request completed"}
{"level":30,"time":1764208026951,"pid":1716933,"hostname":"XD","reqId":"req-3k","req":{"method":"POST","url":"/v1/messages?beta=true","host":"127.0.0.1:3456","remoteAddress":"127.0.0.1","remotePort":40632},"msg":"incoming request"}
{"level":30,"time":1764208026955,"pid":1716933,"hostname":"XD","reqId":"req-3k","res":{"statusCode":401},"responseTime":3.395024001598358,"msg":"request completed"}

[yozyan]

@NubeBuster I'm using openrouter api not google itself. I found a lot of people using openrouter meets the same problem like me. But I have no idea how to fix it.
missing a thought_signature in functionCall parts

[NubeBuster]

@Justxd22

Here is my latest gemini-cli.js

const os = require("os");
const path = require("path");
const fs = require("fs/promises");

// Auth file paths (only needed for OAuth mode)
const OAUTH_FILE = process.env.GOOGLE_APPLICATION_CREDENTIALS;
const CLIENT_FILE = process.env.GOOGLE_APPLICATION_CCR_CLIENT_FILE;
const TOKEN_FILE = path.join(os.homedir(), ".claude-code-router", "gemini_oauth_creds.json");

// Type enum equivalent in JavaScript for Schema Processing
const Type = {
  TYPE_UNSPECIFIED: "TYPE_UNSPECIFIED",
  STRING: "STRING",
  NUMBER: "NUMBER",
  INTEGER: "INTEGER",
  BOOLEAN: "BOOLEAN",
  ARRAY: "ARRAY",
  OBJECT: "OBJECT",
  NULL: "NULL",
};

/**
 * HELPER: Flatten type arrays to anyOf
 */
function flattenTypeArrayToAnyOf(typeList, resultingSchema) {
  if (typeList.includes("null")) {
    resultingSchema["nullable"] = true;
  }
  const listWithoutNull = typeList.filter((type) => type !== "null");

  if (listWithoutNull.length === 1) {
    const upperCaseType = listWithoutNull[0].toUpperCase();
    resultingSchema["type"] = Object.values(Type).includes(upperCaseType)
      ? upperCaseType
      : Type.TYPE_UNSPECIFIED;
  } else {
    resultingSchema["anyOf"] = [];
    for (const i of listWithoutNull) {
      const upperCaseType = i.toUpperCase();
      resultingSchema["anyOf"].push({
        type: Object.values(Type).includes(upperCaseType)
          ? upperCaseType
          : Type.TYPE_UNSPECIFIED,
      });
    }
  }
}

/**
 * HELPER: Robust JSON Schema Processor for Gemini
 */
function processJsonSchema(_jsonSchema) {
  const genAISchema = {};
  const schemaFieldNames = ["items"];
  const listSchemaFieldNames = ["anyOf"];
  const dictSchemaFieldNames = ["properties"];

  if (_jsonSchema["type"] && _jsonSchema["anyOf"]) {
    const incomingAnyOf = _jsonSchema["anyOf"];
    if (incomingAnyOf && Array.isArray(incomingAnyOf) && incomingAnyOf.length === 2) {
      const nullIndex = incomingAnyOf.findIndex(item => item.type === 'null');
      if (nullIndex !== -1) {
        genAISchema["nullable"] = true;
        _jsonSchema = incomingAnyOf[nullIndex === 0 ? 1 : 0];
      }
    }
  }

  if (_jsonSchema["type"] && Array.isArray(_jsonSchema["type"])) {
    flattenTypeArrayToAnyOf(_jsonSchema["type"], genAISchema);
  }

  for (const [fieldName, fieldValue] of Object.entries(_jsonSchema)) {
    if (fieldValue == null) continue;

    if (fieldName === "type") {
      if (fieldValue === "null") continue;
      if (Array.isArray(fieldValue)) continue;

      const upperCaseValue = fieldValue.toUpperCase();
      genAISchema["type"] = Object.values(Type).includes(upperCaseValue)
        ? upperCaseValue
        : Type.TYPE_UNSPECIFIED;
    } else if (schemaFieldNames.includes(fieldName)) {
      genAISchema[fieldName] = processJsonSchema(fieldValue);
    } else if (listSchemaFieldNames.includes(fieldName)) {
      const listSchemaFieldValue = [];
      for (const item of fieldValue) {
        if (item["type"] === "null") {
          genAISchema["nullable"] = true;
          continue;
        }
        listSchemaFieldValue.push(processJsonSchema(item));
      }
      genAISchema[fieldName] = listSchemaFieldValue;
    } else if (dictSchemaFieldNames.includes(fieldName)) {
      const dictSchemaFieldValue = {};
      for (const [key, value] of Object.entries(fieldValue)) {
        dictSchemaFieldValue[key] = processJsonSchema(value);
      }
      genAISchema[fieldName] = dictSchemaFieldValue;
    } else {
      if (fieldName === "additionalProperties" || fieldName === "$schema") continue;
      genAISchema[fieldName] = fieldValue;
    }
  }
  return genAISchema;
}

/**
 * HELPER: Transform Tool Object
 */
function tTool(tool) {
  if (tool.functionDeclarations) {
    for (const functionDeclaration of tool.functionDeclarations) {
      if (functionDeclaration.parameters) {
        if (!Object.keys(functionDeclaration.parameters).includes("$schema")) {
          functionDeclaration.parameters = processJsonSchema(
            functionDeclaration.parameters
          );
        } else {
          if (!functionDeclaration.parametersJsonSchema) {
            functionDeclaration.parametersJsonSchema = functionDeclaration.parameters;
            delete functionDeclaration.parameters;
          }
        }
      }
    }
  }
  return tool;
}

class GeminiCLITransformer {
  constructor(options = {}) {
    this.name = "gemini-cli";
    this.options = options;
  }

  loadOAuthCredentials() {
    try {
      if (OAUTH_FILE) this.oauth_creds = require(OAUTH_FILE);
    } catch (e) {
      this.logger.error ? this.logger.error({ e, file: OAUTH_FILE }, "OAUTH_FILE load error") : console.error("OAUTH_FILE load error", e);
    }

    try {
      if (CLIENT_FILE) this.client_creds = require(CLIENT_FILE);
    } catch (e) {
      this.logger.error ? this.logger.error({ e, file: CLIENT_FILE }, "CLIENT_FILE load error") : console.error("CLIENT_FILE load error", e);
    }

    try {
      this.token_creds = require(TOKEN_FILE);
    } catch (e) {
      // Token file might not exist yet
    }
  }

  async transformRequestIn(request, provider) {
    let authMode;
    let apiKey;
    this.logger.debug(provider, "Prov In");

    this.logger.debug(request, "Req In");
    // Determine auth mode and key
    const rawKey = this.options.apiKey || provider.apiKey || process.env.GEMINI_API_KEY;
    if (rawKey && this.options.mode != "oauth") {
      apiKey = rawKey.trim();
      authMode = 'api-key';
    } else {
      authMode = 'oauth';
      this.logger.debug(authMode, "Mode test:");

    }

    // --- Debug Logging ---
    if (this.options?.debug) {
      const debugInfo = {
        authMode: authMode,
        model: request.model,
        hasApiKey: !!apiKey
      };

      if (this.logger.debug) {
        this.logger.debug(debugInfo, "Gemini Request In");
      } else {
        console.log("[GeminiUniversal] Request Debug:", JSON.stringify(debugInfo, null, 2));
      }
    }


    this.logger.debug("options: " + JSON.stringify(this.options));

    // --- Authentication Header Generation ---
    let headers = {
      'Content-Type': 'application/json'
    };

    if (authMode === 'api-key') {
      if (!apiKey) throw new Error("Auth mode is api-key but no key found.");

      // Removed x-goog-api-key header in favor of query param below
      // delete headers['x-goog-api-key']; 

      // Critical: Explicitly remove Authorization to prevent conflict
      delete headers['Authorization'];
      headers['Authorization'] = null;
      headers['x-goog-api-key'] = apiKey;
    } else {
      // OAuth Mode: Load credentials if not already loaded
      if (!this.oauth_creds || !this.client_creds) {
        this.loadOAuthCredentials();
      }

      // OAuth Mode checks
      if (!this.oauth_creds) {
        throw new Error("Missing Google OAuth credentials (GOOGLE_APPLICATION_CREDENTIALS). Set this or an API_KEY.");
      }
      if (!this.client_creds) {
        throw new Error("Missing Google Client credentials (GOOGLE_APPLICATION_CCR_CLIENT_FILE). Set this or an API_KEY.");
      }

      // Refresh token if expired
      if (!this.token_creds || this.token_creds.expiry_date < Date.now()) {
        await this.refreshToken(this.oauth_creds);
      }

      headers['Authorization'] = `Bearer ${this.token_creds.access_token}`;
      this.logger.debug("Set bearer123: " + JSON.stringify(this.options));
    }

    // --- Tool Transformation ---
    const tools = [];
    const functionDeclarations = request.tools
      ?.filter((tool) => tool.function.name !== "web_search")
      ?.map((tool) => {
        return {
          name: tool.function.name,
          description: tool.function.description,
          parametersJsonSchema: tool.function.parameters,
        };
      });

    if (functionDeclarations?.length) {
      tools.push(tTool({ functionDeclarations }));
    }

    // Handle Google Search Grounding
    const webSearch = request.tools?.find(
      (tool) => tool.function.name === "web_search"
    );
    if (webSearch) {
      tools.push({ googleSearch: {} });
    }

    // --- Message Transformation ---
    const contents = request.messages.map((message) => {
      let role = message.role;
      if (role === "assistant") role = "model";
      else if (["user", "system", "tool"].includes(role)) role = "user";
      else role = "user";

      const parts = [];

      if (typeof message.content === "string") {
        parts.push({ text: message.content });
      } else if (Array.isArray(message.content)) {
        parts.push(
          ...message.content.map((content) => {
            if (content.type === "text") {
              return { text: content.text || "" };
            }
            if (content.type === "image_url") {
              if (content.image_url.url.startsWith("http")) {
                return {
                  file_data: {
                    mime_type: content.media_type || "image/jpeg",
                    file_uri: content.image_url.url,
                  },
                };
              } else {
                const base64Data = content.image_url.url.includes("base64,")
                  ? content.image_url.url.split("base64,")[1]
                  : content.image_url.url;
                return {
                  inlineData: {
                    mime_type: content.media_type || "image/jpeg",
                    data: base64Data,
                  },
                };
              }
            }
            return null;
          }).filter(Boolean)
        );
      }

      if (Array.isArray(message.tool_calls)) {
        parts.push(
          ...message.tool_calls.map((toolCall) => ({
            functionCall: {
              id: toolCall.id || `tool_${Math.random().toString(36).substring(2, 15)}`,
              name: toolCall.function.name,
              args: JSON.parse(toolCall.function.arguments || "{}"),
            },
          }))
        );
      }

      return { role, parts };
    });

    const rawModel = request.model;
    const model = (rawModel && rawModel.trim().length > 0) ? rawModel.trim() : 'gemini-2.5-flash';

    let baseUrl = provider.api_base_url || 'https://generativelanguage.googleapis.com/v1beta/models/';
    if (!baseUrl.endsWith('/')) {
      baseUrl += '/';
    }

    // Construct URL
    const method = request.stream ? 'streamGenerateContent' : 'generateContent';
    const fullUrlString = `${baseUrl}${model}:${method}`;

    const url = new URL(fullUrlString);

    // Debug log to catch URL issues
    if (this.options.debug) {
      // Log URL but redact the key for security in logs
      const logUrl = new URL(url.toString());
      if (logUrl.searchParams.has('key')) {
        logUrl.searchParams.set('key', 'REDACTED');
      }
      this.logger.debug({ logUrl }, "[GeminiUniversal] Constructed URL");
      this.logger.debug({ headers }, "[GeminiUniversal] Headers");
    }

    return {
      body: {
        contents,
        tools: tools.length ? tools : undefined,
        generationConfig: {
          temperature: request.temperature,
          topP: request.top_p,
          maxOutputTokens: request.max_tokens,
        }
      },
      config: {
        url,
        headers,
        method: 'POST'
      },
    };
  }

  async transformResponseOut(response) {
    const requestUrl = response.url;

    // CASE 1: Standard JSON Response
    if (response.headers.get("Content-Type")?.includes("application/json")) {
      let jsonResponse = await response.json();

      if (this.options?.debug) {
        if (this.logger.debug) this.logger.debug({ jsonResponse }, "Gemini JSON Response");
        else console.log("[GeminiUniversal] JSON Response:", JSON.stringify(jsonResponse, null, 2));
      }

      if (!response.ok || jsonResponse.error) {
        const errorMsg = jsonResponse.error?.message || response.statusText;
        throw new Error(`Gemini API Error (${response.status}) at ${requestUrl}: ${errorMsg}`);
      }

      const candidate = jsonResponse.candidates?.[0];
      if (!candidate) throw new Error("No candidates returned from Gemini.");

      const tool_calls = candidate.content?.parts
        ?.filter((part) => part.functionCall)
        ?.map((part) => ({
          id: `call_${Math.random().toString(36).substring(2, 15)}`,
          type: "function",
          function: {
            name: part.functionCall?.name,
            arguments: JSON.stringify(part.functionCall?.args || {}),
          },
        }));

      const res = {
        id: jsonResponse.responseId,
        choices: [
          {
            finish_reason: candidate.finishReason?.toLowerCase() || "stop",
            index: 0,
            message: {
              content: candidate.content?.parts
                ?.filter((part) => part.text)
                .map((part) => part.text)
                .join("\n") || null,
              role: "assistant",
              tool_calls: tool_calls?.length > 0 ? tool_calls : undefined,
            },
          },
        ],
        created: Math.floor(Date.now() / 1000),
        model: jsonResponse.modelVersion,
        object: "chat.completion",
        usage: {
          completion_tokens: jsonResponse.usageMetadata?.candidatesTokenCount || 0,
          prompt_tokens: jsonResponse.usageMetadata?.promptTokenCount || 0,
          total_tokens: jsonResponse.usageMetadata?.totalTokenCount || 0,
        },
      };
      return new Response(JSON.stringify(res), {
        status: 200,
        headers: { 'Content-Type': 'application/json' }
      });

      // CASE 2: SSE Streaming Response
    } else if (response.headers.get("Content-Type")?.includes("stream")) {
      if (!response.body) return response;

      const decoder = new TextDecoder();
      const encoder = new TextEncoder();

      const processLine = (line, controller) => {
        if (line.startsWith("data: ")) {
          const chunkStr = line.slice(6).trim();
          if (chunkStr && chunkStr !== '[DONE]') {

            if (this.options?.debug && this.logger.debug) {
              this.logger.debug({ chunkStr }, "Gemini Stream Chunk");
            }

            try {
              const chunk = JSON.parse(chunkStr);
              const candidate = chunk.candidates?.[0];
              if (!candidate) return;

              const tool_calls = candidate.content?.parts
                ?.filter((part) => part.functionCall)
                ?.map((part) => ({
                  id: `call_${Math.random().toString(36).substring(2, 15)}`,
                  type: 'function',
                  function: {
                    name: part.functionCall.name,
                    arguments: JSON.stringify(part.functionCall.args)
                  }
                }));

              const res = {
                choices: [{
                  delta: {
                    role: "assistant",
                    content: candidate.content?.parts
                      ?.filter((part) => part.text)
                      ?.map((part) => part.text)
                      ?.join("\n"),
                    tool_calls: tool_calls?.length ? tool_calls : undefined
                  },
                  finish_reason: candidate.finishReason?.toLowerCase() || null,
                  index: 0
                }],
                created: Math.floor(Date.now() / 1000),
                id: chunk.responseId || "",
                model: chunk.modelVersion || "",
                object: "chat.completion.chunk",
                usage: {
                  completion_tokens: chunk.usageMetadata?.candidatesTokenCount || 0,
                  prompt_tokens: chunk.usageMetadata?.promptTokenCount || 0,
                  total_tokens: chunk.usageMetadata?.totalTokenCount || 0,
                },
              };

              if (candidate.groundingMetadata?.groundingChunks?.length) {
                res.choices[0].delta.annotations =
                  candidate.groundingMetadata.groundingChunks.map(
                    (groundingChunk, index) => {
                      const support =
                        candidate.groundingMetadata?.groundingSupports?.filter(
                          (item) => item.groundingChunkIndices.includes(index)
                        );
                      return {
                        type: "url_citation",
                        url_citation: {
                          url: groundingChunk.web.uri,
                          title: groundingChunk.web.title,
                          content: support?.[0]?.segment?.text,
                          start_index: support?.[0]?.segment?.startIndex,
                          end_index: support?.[0]?.segment?.endIndex,
                        },
                      };
                    }
                  );
              }

              controller.enqueue(encoder.encode(`data: ${JSON.stringify(res)}\n\n`));
            } catch (e) {
              if (this.options?.debug) console.error("Gemini stream parse error:", e);
            }
          }
        }
      };

      const stream = new ReadableStream({
        async start(controller) {
          const reader = response.body.getReader();
          let buffer = "";
          try {
            while (true) {
              const { done, value } = await reader.read();
              if (done) {
                if (buffer) processLine(buffer, controller);
                break;
              }
              buffer += decoder.decode(value, { stream: true });
              const lines = buffer.split("\n");
              buffer = lines.pop() || "";
              lines.forEach(line => processLine(line, controller));
            }
          } catch (e) { controller.error(e); }
          finally { controller.close(); }
        },
      });

      return new Response(stream, {
        status: 200,
        headers: { 'Content-Type': 'text/event-stream' }
      });
    }

    return response;
  }

  refreshToken(oauth_creds) {
    return fetch("https://oauth2.googleapis.com/token", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        client_id: this.client_creds.installed.client_id,
        client_secret: this.client_creds.installed.client_secret,
        refresh_token: oauth_creds.refresh_token,
        grant_type: "refresh_token",
      }),
    })
      .then((response) => response.json())
      .then(async (data) => {
        data.expiry_date = new Date().getTime() + data.expires_in * 1000 - 60000;
        this.token_creds = data;
        try {
          await fs.writeFile(TOKEN_FILE, JSON.stringify(data, null, 2));
        } catch (e) {
          if (this.options?.debug) console.error("Failed to save refreshed token:", e);
        }
      });
  }
}

module.exports = GeminiCLITransformer;

in my ~/.bashrc (linux)
I have

export GOOGLE_APPLICATION_CREDENTIALS="/home/mark/.config/gcloud/application_default_credentials.json"
export GOOGLE_APPLICATION_CCR_CLIENT_FILE="/home/mark/.claude-code-router/client_secret_someid.apps.googleusercontent.com.json"

where the client file is a reference to the file created in the process of following the gcloud documentation.

In providers I have

    {
      "name": "gemini-cli",
      "api_base_url": "https://generativelanguage.googleapis.com/v1beta/models/",
      "api_key": "null",
      "models": ["gemini-2.5-flash", "gemini-2.5-pro", "gemini-3-pro-preview"],
      "transformer": {
        "use": ["gemini-cli"]
      }
    }

and it works for me. Did this clarify anything?

[aminahbelinda-jpg]

@Justxd22

Here is my latest gemini-cli.js

const os = require("os");
const path = require("path");
const fs = require("fs/promises");

// Auth file paths (only needed for OAuth mode)
const OAUTH_FILE = process.env.GOOGLE_APPLICATION_CREDENTIALS;
const CLIENT_FILE = process.env.GOOGLE_APPLICATION_CCR_CLIENT_FILE;
const TOKEN_FILE = path.join(os.homedir(), ".claude-code-router", "gemini_oauth_creds.json");

// Type enum equivalent in JavaScript for Schema Processing
const Type = {
TYPE_UNSPECIFIED: "TYPE_UNSPECIFIED",
STRING: "STRING",
NUMBER: "NUMBER",
INTEGER: "INTEGER",
BOOLEAN: "BOOLEAN",
ARRAY: "ARRAY",
OBJECT: "OBJECT",
NULL: "NULL",
};

/**

• HELPER: Flatten type arrays to anyOf
  */
  function flattenTypeArrayToAnyOf(typeList, resultingSchema) {
  if (typeList.includes("null")) {
  resultingSchema["nullable"] = true;
  }
  const listWithoutNull = typeList.filter((type) => type !== "null");

if (listWithoutNull.length === 1) {
const upperCaseType = listWithoutNull[0].toUpperCase();
resultingSchema["type"] = Object.values(Type).includes(upperCaseType)
? upperCaseType
: Type.TYPE_UNSPECIFIED;
} else {
resultingSchema["anyOf"] = [];
for (const i of listWithoutNull) {
const upperCaseType = i.toUpperCase();
resultingSchema["anyOf"].push({
type: Object.values(Type).includes(upperCaseType)
? upperCaseType
: Type.TYPE_UNSPECIFIED,
});
}
}
}

/**

• HELPER: Robust JSON Schema Processor for Gemini
  */
  function processJsonSchema(_jsonSchema) {
  const genAISchema = {};
  const schemaFieldNames = ["items"];
  const listSchemaFieldNames = ["anyOf"];
  const dictSchemaFieldNames = ["properties"];

if (_jsonSchema["type"] && _jsonSchema["anyOf"]) {
const incomingAnyOf = _jsonSchema["anyOf"];
if (incomingAnyOf && Array.isArray(incomingAnyOf) && incomingAnyOf.length === 2) {
const nullIndex = incomingAnyOf.findIndex(item => item.type === 'null');
if (nullIndex !== -1) {
genAISchema["nullable"] = true;
_jsonSchema = incomingAnyOf[nullIndex === 0 ? 1 : 0];
}
}
}

if (_jsonSchema["type"] && Array.isArray(_jsonSchema["type"])) {
flattenTypeArrayToAnyOf(_jsonSchema["type"], genAISchema);
}

for (const [fieldName, fieldValue] of Object.entries(_jsonSchema)) {
if (fieldValue == null) continue;

if (fieldName === "type") {
  if (fieldValue === "null") continue;
  if (Array.isArray(fieldValue)) continue;

  const upperCaseValue = fieldValue.toUpperCase();
  genAISchema["type"] = Object.values(Type).includes(upperCaseValue)
    ? upperCaseValue
    : Type.TYPE_UNSPECIFIED;
} else if (schemaFieldNames.includes(fieldName)) {
  genAISchema[fieldName] = processJsonSchema(fieldValue);
} else if (listSchemaFieldNames.includes(fieldName)) {
  const listSchemaFieldValue = [];
  for (const item of fieldValue) {
    if (item["type"] === "null") {
      genAISchema["nullable"] = true;
      continue;
    }
    listSchemaFieldValue.push(processJsonSchema(item));
  }
  genAISchema[fieldName] = listSchemaFieldValue;
} else if (dictSchemaFieldNames.includes(fieldName)) {
  const dictSchemaFieldValue = {};
  for (const [key, value] of Object.entries(fieldValue)) {
    dictSchemaFieldValue[key] = processJsonSchema(value);
  }
  genAISchema[fieldName] = dictSchemaFieldValue;
} else {
  if (fieldName === "additionalProperties" || fieldName === "$schema") continue;
  genAISchema[fieldName] = fieldValue;
}

}
return genAISchema;
}

/**

• HELPER: Transform Tool Object
  */
  function tTool(tool) {
  if (tool.functionDeclarations) {
  for (const functionDeclaration of tool.functionDeclarations) {
  if (functionDeclaration.parameters) {
  if (!Object.keys(functionDeclaration.parameters).includes("$schema")) {
  functionDeclaration.parameters = processJsonSchema(
  functionDeclaration.parameters
  );
  } else {
  if (!functionDeclaration.parametersJsonSchema) {
  functionDeclaration.parametersJsonSchema = functionDeclaration.parameters;
  delete functionDeclaration.parameters;
  }
  }
  }
  }
  }
  return tool;
  }

class GeminiCLITransformer {
constructor(options = {}) {
this.name = "gemini-cli";
this.options = options;
}

loadOAuthCredentials() {
try {
if (OAUTH_FILE) this.oauth_creds = require(OAUTH_FILE);
} catch (e) {
this.logger.error ? this.logger.error({ e, file: OAUTH_FILE }, "OAUTH_FILE load error") : console.error("OAUTH_FILE load error", e);
}

try {
  if (CLIENT_FILE) this.client_creds = require(CLIENT_FILE);
} catch (e) {
  this.logger.error ? this.logger.error({ e, file: CLIENT_FILE }, "CLIENT_FILE load error") : console.error("CLIENT_FILE load error", e);
}

try {
  this.token_creds = require(TOKEN_FILE);
} catch (e) {
  // Token file might not exist yet
}

}

async transformRequestIn(request, provider) {
let authMode;
let apiKey;
this.logger.debug(provider, "Prov In");

this.logger.debug(request, "Req In");
// Determine auth mode and key
const rawKey = this.options.apiKey || provider.apiKey || process.env.GEMINI_API_KEY;
if (rawKey && this.options.mode != "oauth") {
  apiKey = rawKey.trim();
  authMode = 'api-key';
} else {
  authMode = 'oauth';
  this.logger.debug(authMode, "Mode test:");

}

// --- Debug Logging ---
if (this.options?.debug) {
  const debugInfo = {
    authMode: authMode,
    model: request.model,
    hasApiKey: !!apiKey
  };

  if (this.logger.debug) {
    this.logger.debug(debugInfo, "Gemini Request In");
  } else {
    console.log("[GeminiUniversal] Request Debug:", JSON.stringify(debugInfo, null, 2));
  }
}


this.logger.debug("options: " + JSON.stringify(this.options));

// --- Authentication Header Generation ---
let headers = {
  'Content-Type': 'application/json'
};

if (authMode === 'api-key') {
  if (!apiKey) throw new Error("Auth mode is api-key but no key found.");

  // Removed x-goog-api-key header in favor of query param below
  // delete headers['x-goog-api-key']; 

  // Critical: Explicitly remove Authorization to prevent conflict
  delete headers['Authorization'];
  headers['Authorization'] = null;
  headers['x-goog-api-key'] = apiKey;
} else {
  // OAuth Mode: Load credentials if not already loaded
  if (!this.oauth_creds || !this.client_creds) {
    this.loadOAuthCredentials();
  }

  // OAuth Mode checks
  if (!this.oauth_creds) {
    throw new Error("Missing Google OAuth credentials (GOOGLE_APPLICATION_CREDENTIALS). Set this or an API_KEY.");
  }
  if (!this.client_creds) {
    throw new Error("Missing Google Client credentials (GOOGLE_APPLICATION_CCR_CLIENT_FILE). Set this or an API_KEY.");
  }

  // Refresh token if expired
  if (!this.token_creds || this.token_creds.expiry_date < Date.now()) {
    await this.refreshToken(this.oauth_creds);
  }

  headers['Authorization'] = `Bearer ${this.token_creds.access_token}`;
  this.logger.debug("Set bearer123: " + JSON.stringify(this.options));
}

// --- Tool Transformation ---
const tools = [];
const functionDeclarations = request.tools
  ?.filter((tool) => tool.function.name !== "web_search")
  ?.map((tool) => {
    return {
      name: tool.function.name,
      description: tool.function.description,
      parametersJsonSchema: tool.function.parameters,
    };
  });

if (functionDeclarations?.length) {
  tools.push(tTool({ functionDeclarations }));
}

// Handle Google Search Grounding
const webSearch = request.tools?.find(
  (tool) => tool.function.name === "web_search"
);
if (webSearch) {
  tools.push({ googleSearch: {} });
}

// --- Message Transformation ---
const contents = request.messages.map((message) => {
  let role = message.role;
  if (role === "assistant") role = "model";
  else if (["user", "system", "tool"].includes(role)) role = "user";
  else role = "user";

  const parts = [];

  if (typeof message.content === "string") {
    parts.push({ text: message.content });
  } else if (Array.isArray(message.content)) {
    parts.push(
      ...message.content.map((content) => {
        if (content.type === "text") {
          return { text: content.text || "" };
        }
        if (content.type === "image_url") {
          if (content.image_url.url.startsWith("http")) {
            return {
              file_data: {
                mime_type: content.media_type || "image/jpeg",
                file_uri: content.image_url.url,
              },
            };
          } else {
            const base64Data = content.image_url.url.includes("base64,")
              ? content.image_url.url.split("base64,")[1]
              : content.image_url.url;
            return {
              inlineData: {
                mime_type: content.media_type || "image/jpeg",
                data: base64Data,
              },
            };
          }
        }
        return null;
      }).filter(Boolean)
    );
  }

  if (Array.isArray(message.tool_calls)) {
    parts.push(
      ...message.tool_calls.map((toolCall) => ({
        functionCall: {
          id: toolCall.id || `tool_${Math.random().toString(36).substring(2, 15)}`,
          name: toolCall.function.name,
          args: JSON.parse(toolCall.function.arguments || "{}"),
        },
      }))
    );
  }

  return { role, parts };
});

const rawModel = request.model;
const model = (rawModel && rawModel.trim().length > 0) ? rawModel.trim() : 'gemini-2.5-flash';

let baseUrl = provider.api_base_url || 'https://generativelanguage.googleapis.com/v1beta/models/';
if (!baseUrl.endsWith('/')) {
  baseUrl += '/';
}

// Construct URL
const method = request.stream ? 'streamGenerateContent' : 'generateContent';
const fullUrlString = `${baseUrl}${model}:${method}`;

const url = new URL(fullUrlString);

// Debug log to catch URL issues
if (this.options.debug) {
  // Log URL but redact the key for security in logs
  const logUrl = new URL(url.toString());
  if (logUrl.searchParams.has('key')) {
    logUrl.searchParams.set('key', 'REDACTED');
  }
  this.logger.debug({ logUrl }, "[GeminiUniversal] Constructed URL");
  this.logger.debug({ headers }, "[GeminiUniversal] Headers");
}

return {
  body: {
    contents,
    tools: tools.length ? tools : undefined,
    generationConfig: {
      temperature: request.temperature,
      topP: request.top_p,
      maxOutputTokens: request.max_tokens,
    }
  },
  config: {
    url,
    headers,
    method: 'POST'
  },
};

}

async transformResponseOut(response) {
const requestUrl = response.url;

// CASE 1: Standard JSON Response
if (response.headers.get("Content-Type")?.includes("application/json")) {
  let jsonResponse = await response.json();

  if (this.options?.debug) {
    if (this.logger.debug) this.logger.debug({ jsonResponse }, "Gemini JSON Response");
    else console.log("[GeminiUniversal] JSON Response:", JSON.stringify(jsonResponse, null, 2));
  }

  if (!response.ok || jsonResponse.error) {
    const errorMsg = jsonResponse.error?.message || response.statusText;
    throw new Error(`Gemini API Error (${response.status}) at ${requestUrl}: ${errorMsg}`);
  }

  const candidate = jsonResponse.candidates?.[0];
  if (!candidate) throw new Error("No candidates returned from Gemini.");

  const tool_calls = candidate.content?.parts
    ?.filter((part) => part.functionCall)
    ?.map((part) => ({
      id: `call_${Math.random().toString(36).substring(2, 15)}`,
      type: "function",
      function: {
        name: part.functionCall?.name,
        arguments: JSON.stringify(part.functionCall?.args || {}),
      },
    }));

  const res = {
    id: jsonResponse.responseId,
    choices: [
      {
        finish_reason: candidate.finishReason?.toLowerCase() || "stop",
        index: 0,
        message: {
          content: candidate.content?.parts
            ?.filter((part) => part.text)
            .map((part) => part.text)
            .join("\n") || null,
          role: "assistant",
          tool_calls: tool_calls?.length > 0 ? tool_calls : undefined,
        },
      },
    ],
    created: Math.floor(Date.now() / 1000),
    model: jsonResponse.modelVersion,
    object: "chat.completion",
    usage: {
      completion_tokens: jsonResponse.usageMetadata?.candidatesTokenCount || 0,
      prompt_tokens: jsonResponse.usageMetadata?.promptTokenCount || 0,
      total_tokens: jsonResponse.usageMetadata?.totalTokenCount || 0,
    },
  };
  return new Response(JSON.stringify(res), {
    status: 200,
    headers: { 'Content-Type': 'application/json' }
  });

  // CASE 2: SSE Streaming Response
} else if (response.headers.get("Content-Type")?.includes("stream")) {
  if (!response.body) return response;

  const decoder = new TextDecoder();
  const encoder = new TextEncoder();

  const processLine = (line, controller) => {
    if (line.startsWith("data: ")) {
      const chunkStr = line.slice(6).trim();
      if (chunkStr && chunkStr !== '[DONE]') {

        if (this.options?.debug && this.logger.debug) {
          this.logger.debug({ chunkStr }, "Gemini Stream Chunk");
        }

        try {
          const chunk = JSON.parse(chunkStr);
          const candidate = chunk.candidates?.[0];
          if (!candidate) return;

          const tool_calls = candidate.content?.parts
            ?.filter((part) => part.functionCall)
            ?.map((part) => ({
              id: `call_${Math.random().toString(36).substring(2, 15)}`,
              type: 'function',
              function: {
                name: part.functionCall.name,
                arguments: JSON.stringify(part.functionCall.args)
              }
            }));

          const res = {
            choices: [{
              delta: {
                role: "assistant",
                content: candidate.content?.parts
                  ?.filter((part) => part.text)
                  ?.map((part) => part.text)
                  ?.join("\n"),
                tool_calls: tool_calls?.length ? tool_calls : undefined
              },
              finish_reason: candidate.finishReason?.toLowerCase() || null,
              index: 0
            }],
            created: Math.floor(Date.now() / 1000),
            id: chunk.responseId || "",
            model: chunk.modelVersion || "",
            object: "chat.completion.chunk",
            usage: {
              completion_tokens: chunk.usageMetadata?.candidatesTokenCount || 0,
              prompt_tokens: chunk.usageMetadata?.promptTokenCount || 0,
              total_tokens: chunk.usageMetadata?.totalTokenCount || 0,
            },
          };

          if (candidate.groundingMetadata?.groundingChunks?.length) {
            res.choices[0].delta.annotations =
              candidate.groundingMetadata.groundingChunks.map(
                (groundingChunk, index) => {
                  const support =
                    candidate.groundingMetadata?.groundingSupports?.filter(
                      (item) => item.groundingChunkIndices.includes(index)
                    );
                  return {
                    type: "url_citation",
                    url_citation: {
                      url: groundingChunk.web.uri,
                      title: groundingChunk.web.title,
                      content: support?.[0]?.segment?.text,
                      start_index: support?.[0]?.segment?.startIndex,
                      end_index: support?.[0]?.segment?.endIndex,
                    },
                  };
                }
              );
          }

          controller.enqueue(encoder.encode(`data: ${JSON.stringify(res)}\n\n`));
        } catch (e) {
          if (this.options?.debug) console.error("Gemini stream parse error:", e);
        }
      }
    }
  };

  const stream = new ReadableStream({
    async start(controller) {
      const reader = response.body.getReader();
      let buffer = "";
      try {
        while (true) {
          const { done, value } = await reader.read();
          if (done) {
            if (buffer) processLine(buffer, controller);
            break;
          }
          buffer += decoder.decode(value, { stream: true });
          const lines = buffer.split("\n");
          buffer = lines.pop() || "";
          lines.forEach(line => processLine(line, controller));
        }
      } catch (e) { controller.error(e); }
      finally { controller.close(); }
    },
  });

  return new Response(stream, {
    status: 200,
    headers: { 'Content-Type': 'text/event-stream' }
  });
}

return response;

}

refreshToken(oauth_creds) {
return fetch("https://oauth2.googleapis.com/token", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
client_id: this.client_creds.installed.client_id,
client_secret: this.client_creds.installed.client_secret,
refresh_token: oauth_creds.refresh_token,
grant_type: "refresh_token",
}),
})
.then((response) => response.json())
.then(async (data) => {
data.expiry_date = new Date().getTime() + data.expires_in * 1000 - 60000;
this.token_creds = data;
try {
await fs.writeFile(TOKEN_FILE, JSON.stringify(data, null, 2));
} catch (e) {
if (this.options?.debug) console.error("Failed to save refreshed token:", e);
}
});
}
}

module.exports = GeminiCLITransformer;
in my ~/.bashrc (linux) I have

export GOOGLE_APPLICATION_CREDENTIALS="/home/mark/.config/gcloud/application_default_credentials.json"
export GOOGLE_APPLICATION_CCR_CLIENT_FILE="/home/mark/.claude-code-router/client_secret_someid.apps.googleusercontent.com.json"
where the client file is a reference to the file created in the process of following the gcloud documentation.

In providers I have

{
  "name": "gemini-cli",
  "api_base_url": "https://generativelanguage.googleapis.com/v1beta/models/",
  "api_key": "null",
  "models": ["gemini-2.5-flash", "gemini-2.5-pro", "gemini-3-pro-preview"],
  "transformer": {
    "use": ["gemini-cli"]
  }
}

and it works for me. Did this clarify anything?

Hi, do you have a detailed step by step guide? I get lost with the instructions as someone not that technical. Thanks in advance!

[NubeBuster]

Hi, do you have a detailed step by step guide? I get lost with the instructions as someone not that technical. Thanks in advance!

The code i posted goes in HOME/.claude-code-router/plugins/gemini-cli.js

Then in HOME/.claude-code-router/config.json you add

  "transformers": [
    {
      "path": "HOME/.claude-code-router/plugins/gemini-cli.js",
      "options": {
        "debug": true,
        "mode": "oauth"
      }
    }
  ],

and to "Providers": [
you add

    {
      "name": "gemini-cli",
      "api_base_url": "https://generativelanguage.googleapis.com/v1beta/models/",
      "api_key": "null",
      "models": ["gemini-2.5-flash", "gemini-2.5-pro", "gemini-3-pro-preview"],
      "transformer": {
        "use": ["gemini-cli"]
      }
    }

Then follow the steps at
https://ai.google.dev/gemini-api/docs/oauth

then you set these two env vars to the file paths you have from the steps above, with the file paths correct.

export GOOGLE_APPLICATION_CREDENTIALS="/home/mark/.config/gcloud/application_default_credentials.json"
export GOOGLE_APPLICATION_CCR_CLIENT_FILE="/home/mark/.claude-code-router/client_secret_someid.apps.googleusercontent.com.json"

depending on if you're on windows or linux. On linux you just put it in ~/.bashrc
For windows you'll have to ask your LLM "how do I set these ENV variables for when I launch gemini cli?"