@juspay/neurolink 11.17.2 → 11.18.0

package/dist/proxy/geminiFormat.js

@@ -0,0 +1,219 @@
+/**
+ * Google `generateContent` wire format.
+ *
+ * The Gemini CLI honours `GOOGLE_GEMINI_BASE_URL`, so it can be pointed at this
+ * proxy with no vendor cooperation — verified live: with the variable set the
+ * CLI reached the proxy and failed with `ModelNotFoundError: 404`, which is the
+ * right answer from a proxy that had no route to answer it. This module is the
+ * missing half.
+ *
+ * Three differences from the Claude and OpenAI shapes drive everything here:
+ *
+ * - Roles are `user` / `model`, not `user` / `assistant`.
+ * - The system prompt is a sibling `systemInstruction`, not a turn.
+ * - Generation settings nest under `generationConfig`.
+ *
+ * Token counts also have their own names — `promptTokenCount`,
+ * `candidatesTokenCount`, `totalTokenCount` — and the CLI reads them to render
+ * its own usage line, so getting them wrong is visible to the user rather than
+ * merely wrong in a log.
+ */
+/** Google's role for assistant turns. */
+const MODEL_ROLE = "model";
+function partsToText(parts) {
+    if (!Array.isArray(parts)) {
+        return "";
+    }
+    return parts
+        .map((p) => (typeof p?.text === "string" ? p.text : ""))
+        .filter(Boolean)
+        .join("");
+}
+function partsToImages(parts) {
+    if (!Array.isArray(parts)) {
+        return [];
+    }
+    return parts
+        .map((p) => p?.inlineData?.data)
+        .filter((d) => typeof d === "string" && d.length > 0);
+}
+/**
+ * Parse a `generateContent` body into the shape the translation engine takes.
+ *
+ * The final user turn becomes `prompt`; everything before it becomes
+ * `conversationMessages`, with Google's `model` role mapped to `assistant` so
+ * downstream providers see a role they understand.
+ */
+export function parseGeminiRequest(model, body, stream) {
+    const contents = Array.isArray(body.contents)
+        ? body.contents
+        : [];
+    const generationConfig = (body.generationConfig ?? {});
+    const systemInstruction = body.systemInstruction;
+    const systemPrompt = systemInstruction
+        ? partsToText(systemInstruction.parts)
+        : undefined;
+    const turns = contents.map((c) => ({
+        role: c?.role === MODEL_ROLE ? "assistant" : "user",
+        content: partsToText(c?.parts),
+        images: partsToImages(c?.parts),
+    }));
+    // The last user turn is the prompt; anything before it is history. A request
+    // whose final turn is a model turn (the CLI does this when continuing) leaves
+    // an empty prompt rather than replaying the assistant's own words as input.
+    let prompt = "";
+    let images = [];
+    const conversationMessages = [];
+    for (let i = 0; i < turns.length; i += 1) {
+        const isLast = i === turns.length - 1;
+        if (isLast && turns[i].role === "user") {
+            prompt = turns[i].content;
+            images = turns[i].images;
+        }
+        else {
+            conversationMessages.push({
+                role: turns[i].role,
+                content: turns[i].content,
+            });
+        }
+    }
+    const numeric = (v) => typeof v === "number" && Number.isFinite(v) ? v : undefined;
+    const stops = generationConfig.stopSequences;
+    return {
+        model,
+        maxTokens: numeric(generationConfig.maxOutputTokens),
+        temperature: numeric(generationConfig.temperature),
+        topP: numeric(generationConfig.topP),
+        systemPrompt: systemPrompt || undefined,
+        stream,
+        prompt,
+        images,
+        conversationMessages,
+        tools: {},
+        stopSequences: Array.isArray(stops)
+            ? stops.filter((x) => typeof x === "string")
+            : undefined,
+    };
+}
+/** Google's finishReason vocabulary. */
+function toGeminiFinishReason(reason) {
+    switch (reason) {
+        case "length":
+        case "max_tokens":
+            return "MAX_TOKENS";
+        case "content_filter":
+            return "SAFETY";
+        default:
+            return "STOP";
+    }
+}
+function usageMetadata(usage) {
+    return {
+        promptTokenCount: usage.input,
+        candidatesTokenCount: usage.output,
+        totalTokenCount: usage.total || usage.input + usage.output,
+    };
+}
+/** Build a complete `generateContent` response body. */
+export function buildGeminiResponse(text, finishReason, usage, modelVersion) {
+    return {
+        candidates: [
+            {
+                content: { role: MODEL_ROLE, parts: [{ text }] },
+                finishReason: toGeminiFinishReason(finishReason),
+                index: 0,
+            },
+        ],
+        usageMetadata: usageMetadata(usage),
+        modelVersion,
+    };
+}
+/** Google's error envelope, which the CLI parses to classify failures. */
+export function buildGeminiErrorResponse(status, message, statusText = "INVALID_ARGUMENT") {
+    return new Response(JSON.stringify({ error: { code: status, message, status: statusText } }), { status, headers: { "content-type": "application/json" } });
+}
+/**
+ * SSE serializer for `streamGenerateContent?alt=sse`.
+ *
+ * Google streams whole `GenerateContentResponse` objects, one per `data:`
+ * frame, rather than the deltas Claude and OpenAI send. Each frame therefore
+ * carries a complete `candidates[0].content.parts[0].text` holding only that
+ * chunk's text — the CLI concatenates them — and the final frame is the one
+ * that carries `finishReason` and `usageMetadata`.
+ */
+export class GeminiStreamSerializer {
+    model;
+    constructor(model) {
+        this.model = model;
+    }
+    frame(payload) {
+        return `data: ${JSON.stringify(payload)}\n\n`;
+    }
+    /** Google sends no preamble frame; the first delta is the first frame. */
+    start() {
+        return [];
+    }
+    pushDelta(text) {
+        if (!text) {
+            return [];
+        }
+        return [
+            this.frame({
+                candidates: [
+                    { content: { role: MODEL_ROLE, parts: [{ text }] }, index: 0 },
+                ],
+                modelVersion: this.model,
+            }),
+        ];
+    }
+    /**
+     * Tool calls are surfaced as text.
+     *
+     * The translation engine can emit a tool call, but the Gemini CLI drives its
+     * own tools locally and does not expect `functionCall` parts from a plain
+     * `generateContent`. Emitting one would make the CLI wait for a tool result
+     * that is never coming; rendering it as text keeps the turn terminating.
+     */
+    pushToolUse(_id, name, input) {
+        return this.pushDelta(`\n[tool: ${name} ${JSON.stringify(input)}]\n`);
+    }
+    finish(finishReason, usage) {
+        return [
+            this.frame({
+                candidates: [
+                    {
+                        content: { role: MODEL_ROLE, parts: [{ text: "" }] },
+                        finishReason: toGeminiFinishReason(finishReason),
+                        index: 0,
+                    },
+                ],
+                usageMetadata: usageMetadata(usage),
+                modelVersion: this.model,
+            }),
+        ];
+    }
+    /**
+     * Errors ride the stream as a Google error object.
+     *
+     * Once headers are sent the status code is spent, so the CLI can only learn
+     * about a mid-stream failure from the body.
+     */
+    emitError(message) {
+        return [
+            this.frame({
+                error: { code: 500, message, status: "INTERNAL" },
+            }),
+        ];
+    }
+}
+/** Adapter so the translation engine can drive this like the other two. */
+export function createGeminiSerializerAdapter(model) {
+    const s = new GeminiStreamSerializer(model);
+    return {
+        start: () => s.start(),
+        pushDelta: (text) => s.pushDelta(text),
+        pushToolUse: (id, name, input) => s.pushToolUse(id, name, input),
+        finish: (finishReason, usage) => s.finish(finishReason, usage),
+        emitError: (message) => s.emitError(message),
+    };
+}

package/dist/proxy/proxyTranslationEngine.d.ts

@@ -12,7 +12,7 @@
  * JSON handlers that accept a format discriminator.
  */
 import type { ProxyTracer } from "./proxyTracer.js";
-import type { ParsedClaudeRequest, ParsedOpenAIRequest, ProxyFormat, ProxyTranslationAttempt, ServerContext } from "../types/index.js";
+import type { ParsedClaudeRequest, ParsedGeminiRequest, ParsedOpenAIRequest, ProxyFormat, ProxyTranslationAttempt, ServerContext } from "../types/index.js";
 /**
  * Extract text content from a stream chunk (handles various chunk formats).
  */
@@ -42,11 +42,14 @@ export declare function detectProxyFormat(path: string, headers: Record<string,
  * Build options for ctx.neurolink.stream() from a parsed request
  * and an optional provider/model override.
  *
- * Works for both ParsedClaudeRequest and ParsedOpenAIRequest — the
- * only differences are Claude-specific fields (topK, thinkingConfig)
- * which are safely absent on OpenAI parsed requests.
+ * Works for ParsedClaudeRequest, ParsedOpenAIRequest and
+ * ParsedGeminiRequest. The differences are Claude-specific fields (topK,
+ * thinkingConfig), safely absent on OpenAI/Gemini parsed requests, and
+ * toolChoice/toolChoiceName, absent on Gemini parsed requests — Gemini's
+ * parser always emits tools: {} (see geminiFormat.ts's parseGeminiRequest),
+ * so toolNames.length is always 0 below and disableTools is set instead.
  */
-export declare function buildTranslationOptions(parsed: ParsedClaudeRequest | ParsedOpenAIRequest, overrides?: {
+export declare function buildTranslationOptions(parsed: ParsedClaudeRequest | ParsedOpenAIRequest | ParsedGeminiRequest, overrides?: {
     provider?: string;
     model?: string;
 }): Record<string, unknown>;
@@ -61,7 +64,7 @@ export declare function handleTranslatedStreamRequest(args: {
     ctx: ServerContext;
     format: ProxyFormat;
     requestModel: string;
-    parsed: ParsedClaudeRequest | ParsedOpenAIRequest;
+    parsed: ParsedClaudeRequest | ParsedOpenAIRequest | ParsedGeminiRequest;
     attempts: ProxyTranslationAttempt[];
     tracer?: ProxyTracer;
     requestStartTime: number;
@@ -73,7 +76,7 @@ export declare function handleTranslatedJsonRequest(args: {
     ctx: ServerContext;
     format: ProxyFormat;
     requestModel: string;
-    parsed: ParsedClaudeRequest | ParsedOpenAIRequest;
+    parsed: ParsedClaudeRequest | ParsedOpenAIRequest | ParsedGeminiRequest;
     attempts: ProxyTranslationAttempt[];
     tracer?: ProxyTracer;
     requestStartTime: number;

package/dist/proxy/proxyTranslationEngine.js

@@ -12,6 +12,7 @@
  * JSON handlers that accept a format discriminator.
  */
 import { ClaudeStreamSerializer, generateToolUseId, serializeClaudeResponse, } from "./claudeFormat.js";
+import { buildGeminiResponse, createGeminiSerializerAdapter, } from "./geminiFormat.js";
 import { generateOpenAIToolCallId, OpenAIStreamSerializer, serializeOpenAIResponse, } from "./openaiFormat.js";
 import { logRequest } from "./requestLogger.js";
 import { recordAttempt, recordAttemptError, recordFinalError, recordFinalSuccess, } from "./usageStats.js";
@@ -96,6 +97,17 @@ export function detectProxyFormat(path, headers) {
     if (path.includes("/messages")) {
         return "claude";
     }
+    // Gemini CLI wire format: POST /v1beta/models/<model>:generateContent
+    // (non-streaming) or :streamGenerateContent (streaming, selected via
+    // ?alt=sse on ctx.query — not part of ctx.path, so it plays no role here).
+    // Checked as two explicit suffixes: "streamGenerateContent" capitalizes
+    // the "Generate" it shares with "generateContent", so
+    // "streamGenerateContent".includes("generateContent") is false and a
+    // single check would miss every streaming request.
+    if (path.includes(":generateContent") ||
+        path.includes(":streamGenerateContent")) {
+        return "gemini";
+    }
     // Header-based fallback
     if (headers["anthropic-version"]) {
         return "claude";
@@ -140,9 +152,12 @@ function shouldOmitThinkingConfigForTarget(provider, model) {
  * Build options for ctx.neurolink.stream() from a parsed request
  * and an optional provider/model override.
  *
- * Works for both ParsedClaudeRequest and ParsedOpenAIRequest — the
- * only differences are Claude-specific fields (topK, thinkingConfig)
- * which are safely absent on OpenAI parsed requests.
+ * Works for ParsedClaudeRequest, ParsedOpenAIRequest and
+ * ParsedGeminiRequest. The differences are Claude-specific fields (topK,
+ * thinkingConfig), safely absent on OpenAI/Gemini parsed requests, and
+ * toolChoice/toolChoiceName, absent on Gemini parsed requests — Gemini's
+ * parser always emits tools: {} (see geminiFormat.ts's parseGeminiRequest),
+ * so toolNames.length is always 0 below and disableTools is set instead.
  */
 export function buildTranslationOptions(parsed, overrides = {}) {
     const historyMessages = parsed.conversationMessages.slice(0, -1);
@@ -156,9 +171,14 @@ export function buildTranslationOptions(parsed, overrides = {}) {
         !shouldOmitThinkingConfigForTarget(overrides.provider, overrides.model)
         ? claudeParsed.thinkingConfig
         : undefined;
-    const toolChoice = parsed.toolChoiceName
-        ? { type: "tool", toolName: parsed.toolChoiceName }
-        : parsed.toolChoice;
+    // toolChoice/toolChoiceName exist on ParsedClaudeRequest and
+    // ParsedOpenAIRequest but not on ParsedGeminiRequest — go through the same
+    // Partial-cast pattern as claudeParsed above so a Gemini request just sees
+    // both as undefined instead of failing to compile.
+    const toolChoiceParsed = parsed;
+    const toolChoice = toolChoiceParsed.toolChoiceName
+        ? { type: "tool", toolName: toolChoiceParsed.toolChoiceName }
+        : toolChoiceParsed.toolChoice;
     return {
         input: {
             text: parsed.prompt,
@@ -224,7 +244,13 @@ function defaultFinishReason(format) {
     return format === "claude" ? "end_turn" : "stop";
 }
 function logTag(format) {
-    return format === "claude" ? "[proxy]" : "[proxy:openai]";
+    if (format === "claude") {
+        return "[proxy]";
+    }
+    if (format === "gemini") {
+        return "[proxy:gemini]";
+    }
+    return "[proxy:openai]";
 }
 // ---------------------------------------------------------------------------
 // Unified streaming handler
@@ -241,7 +267,9 @@ export async function handleTranslatedStreamRequest(args) {
     const tag = logTag(format);
     const serializer = format === "claude"
         ? createClaudeSerializerAdapter(requestModel)
-        : createOpenAISerializerAdapter(requestModel);
+        : format === "gemini"
+            ? createGeminiSerializerAdapter(requestModel)
+            : createOpenAISerializerAdapter(requestModel);
     const KEEPALIVE_INTERVAL_MS = 15_000;
     const encoder = new TextEncoder();
     let keepAliveTimer;
@@ -566,9 +594,13 @@ export async function handleTranslatedJsonRequest(args) {
                 ...(traceCtx?.traceId ? { traceId: traceCtx.traceId } : {}),
                 ...(traceCtx?.spanId ? { spanId: traceCtx.spanId } : {}),
             });
-            return format === "claude"
-                ? serializeClaudeResponse(internal, requestModel)
-                : serializeOpenAIResponse(internal, requestModel);
+            if (format === "claude") {
+                return serializeClaudeResponse(internal, requestModel);
+            }
+            if (format === "gemini") {
+                return buildGeminiResponse(internal.content, internal.finishReason ?? defaultFinishReason(format), resolvedUsage, internal.model ?? requestModel);
+            }
+            return serializeOpenAIResponse(internal, requestModel);
         }
         catch (attemptError) {
             lastAttemptError =

package/dist/server/index.d.ts

@@ -38,7 +38,7 @@ export { createMCPBodyAttachmentMiddleware, fastifyMCPBodyHook, } from "./middle
 export { createRateLimitMiddleware, createSlidingWindowRateLimitMiddleware, InMemoryRateLimitStore, } from "./middleware/rateLimit.js";
 export { CommonSchemas, createFieldValidator, createRequestValidationMiddleware, ValidationError, } from "./middleware/validation.js";
 export { AgentExecuteRequestSchema as OpenAPIAgentExecuteRequestSchema, AgentExecuteResponseSchema, AgentInputSchema, ApiKeySecurityScheme, BasicSecurityScheme, BearerSecurityScheme, CommonParameters, ConversationMessageSchema, createApiInfo, createDeleteOperation, createErrorResponse as createOpenAPIErrorResponse, createGetOperation, createHeaderParameter, createOpenAPIGenerator, createPathParameter, createPostOperation, createQueryParameter, createServer as createOpenAPIServer, createStreamingPostOperation, createStreamingResponse, createSuccessResponse, DefaultServers, ErrorResponseSchema, generateOpenAPIFromConfig, generateOpenAPISpec, HealthResponseSchema, MCPServerStatusSchema, MCPServersListResponseSchema, MCPServerToolSchema, MetricsResponseSchema, NeuroLinkApiInfo, OpenAPIGenerator, OpenAPISchemas, ProviderInfoSchema, ReadyResponseSchema, SessionSchema, SessionsListResponseSchema, StandardErrorResponses, StandardTags, TokenUsageSchema, ToolCallSchema, ToolDefinitionSchema, ToolExecuteRequestSchema as OpenAPIToolExecuteRequestSchema, ToolExecuteResponseSchema, ToolListResponseSchema, ToolParameterSchema, } from "./openapi/index.js";
-export { createAgentRoutes, createAllRoutes, createHealthRoutes, createMCPRoutes, createMemoryRoutes, createOpenApiRoutes, createToolRoutes, registerAllRoutes, createClaudeProxyRoutes, createOpenAIProxyRoutes, createCodexProxyRoutes, } from "./routes/index.js";
+export { createAgentRoutes, createAllRoutes, createHealthRoutes, createMCPRoutes, createMemoryRoutes, createOpenApiRoutes, createToolRoutes, registerAllRoutes, createClaudeProxyRoutes, createOpenAIProxyRoutes, createCodexProxyRoutes, createGeminiProxyRoutes, } from "./routes/index.js";
 export { BaseDataStreamWriter, createDataStreamResponse, createDataStreamWriter, createNDJSONHeaders, createSSEHeaders, DataStreamResponse, formatSSEEvent, pipeAsyncIterableToDataStream, WebStreamWriter, } from "./streaming/index.js";
 export { ErrorCategory, ErrorSeverity, ServerAdapterErrorCode, } from "../types/index.js";
 export { createStreamRedactor, redactStreamChunk } from "./utils/redaction.js";

package/dist/server/index.js

@@ -94,11 +94,12 @@ OpenAPIGenerator, OpenAPISchemas, ProviderInfoSchema, ReadyResponseSchema, Sessi
 // Routes
 // ============================================
 export { createAgentRoutes, createAllRoutes, createHealthRoutes, createMCPRoutes, createMemoryRoutes, createOpenApiRoutes, createToolRoutes, registerAllRoutes, 
-// The proxy doors. All three were reachable only from the deep path
+// The proxy doors. All were reachable only from the deep path
 // ./routes/index.js, which is not a package export — so a consumer of
 // "@juspay/neurolink/server" could reach them only indirectly through
-// createAllRoutes' flags, never to mount one on its own.
-createClaudeProxyRoutes, createOpenAIProxyRoutes, createCodexProxyRoutes, } from "./routes/index.js";
+// createAllRoutes' flags, never to mount one on its own. Codex stayed
+// CLI-only for long enough on exactly that gap to be worth naming.
+createClaudeProxyRoutes, createOpenAIProxyRoutes, createCodexProxyRoutes, createGeminiProxyRoutes, } from "./routes/index.js";
 // ============================================
 // Streaming
 // ============================================

package/dist/server/routes/claudeProxyRoutes.js

@@ -30,6 +30,7 @@ import { ProxyTracer, recordFallbackAttempt } from "../../proxy/proxyTracer.js";
 import { createRawStreamCapture } from "../../proxy/rawStreamCapture.js";
 import { relocateClientSystemIntoMessages } from "../../proxy/systemRelocation.js";
 import { logBodyCapture, logRequest, logRequestAttempt, } from "../../proxy/requestLogger.js";
+import { buildClientAttribution } from "../../proxy/clientAttribution.js";
 import { createSSEInterceptor } from "../../proxy/sseInterceptor.js";
 import { createStreamTerminalOutcomeTracker, mergeStreamTerminalOutcome, preflightAnthropicStream, } from "../../proxy/streamOutcome.js";
 import { isPermanentRefreshFailure, needsRefresh, persistTokens, refreshToken, refreshTokenFromLatest, } from "../../proxy/tokenRefresh.js";
@@ -4747,6 +4748,7 @@ function createClaudeRequestRuntimeContext(args) {
             toolCount: Array.isArray(body.tools) ? body.tools.length : 0,
             account: finalAccountLabel ?? "",
             accountType: finalAccountType ?? "",
+            ...buildClientAttribution(ctx.headers),
             responseStatus: status,
             responseTimeMs: Date.now() - requestStartTime,
             ...(errorType ? { errorType } : {}),

package/dist/server/routes/codexProxyRoutes.js

@@ -18,11 +18,12 @@
  * the full transient-budget / admission machinery.
  */
 import { tokenStore } from "../../auth/tokenStore.js";
-import { CODEX_ORIGINATOR, CODEX_RESPONSES_URL, CODEX_USER_AGENT, codexTokenNeedsRefresh, isPermanentCodexRefreshFailure, refreshCodexToken, resolveCodexAccountId, } from "../../auth/codexOAuth.js";
+import { CODEX_ORIGINATOR, CODEX_MODELS_URL, CODEX_RESPONSES_URL, CODEX_USER_AGENT, codexTokenNeedsRefresh, isPermanentCodexRefreshFailure, refreshCodexToken, resolveCodexAccountId, } from "../../auth/codexOAuth.js";
 import { clearAccountCooldown, loadAccountCooldowns, saveAccountCooldown, } from "../../proxy/accountCooldown.js";
 import { loadAccountQuotas, saveAccountQuota, } from "../../proxy/accountQuota.js";
 import { createCodexUsageTap } from "../../proxy/codexUsage.js";
 import { CODEX_ACCOUNT_PREFIX, parseCodexRateLimitHeaders, } from "../../proxy/codexAccountUsage.js";
+import { buildClientAttribution } from "../../proxy/clientAttribution.js";
 import { logRequest } from "../../proxy/requestLogger.js";
 import { parseRetryAfterMs } from "../../proxy/routingPolicy.js";
 import { sanitizeForLog } from "../../utils/logSanitize.js";
@@ -252,6 +253,7 @@ async function handleCodexResponsesRequest(ctx) {
             : 0,
         account,
         accountType: "codex-oauth",
+        ...buildClientAttribution(ctx.headers),
         responseStatus,
         responseTimeMs: Date.now() - requestStartTime,
         ...extra,
@@ -452,6 +454,126 @@ async function handleCodexResponsesRequest(ctx) {
     });
     return buildCodexErrorResponse(lastErrorStatus, lastErrorMessage);
 }
+/**
+ * Relay Codex model discovery upstream.
+ *
+ * The CLI refreshes its model list on every invocation. Only `/responses` was
+ * registered, so that GET 404'd and the CLI printed a refresh failure before
+ * falling back to a default model — quietly ignoring the model the user had
+ * configured.
+ *
+ * This relays rather than synthesises, unlike the Claude and OpenAI `/v1/models`
+ * routes, which build their lists locally from the model router. Codex model
+ * availability is a property of the upstream account (plan tier, rollout), not
+ * of anything this proxy knows, so a synthesised list would be a guess that
+ * looks authoritative.
+ *
+ * Read-only with respect to ROUTING: no cooldown is recorded and no quota is
+ * consumed, so a discovery call cannot influence which account real traffic
+ * lands on. It is not literally side-effect free — a token refreshed below is
+ * persisted, exactly as the proactive refresh in `loadCodexProxyAccounts`
+ * persists one. What discovery deliberately never does is *penalise* an
+ * account: it cannot cool one and cannot disable one. A read-only probe must
+ * not be able to cost the user a login.
+ */
+async function handleCodexModelsRequest(ctx) {
+    const accounts = await loadCodexProxyAccounts();
+    if (accounts.length === 0) {
+        return buildCodexErrorResponse(401, "No Codex accounts configured. Run `neurolink auth login codex`.");
+    }
+    const now = Date.now();
+    const ordered = orderCodexAccounts(accounts, now);
+    // A cooling account is rate-limited for completions, not barred from
+    // answering what models exist. Healthy accounts go first, but a cooling one
+    // is still a candidate rather than a reason to fail discovery outright.
+    const isCooling = (a) => a.coolingUntil !== undefined && a.coolingUntil > now;
+    const candidates = [
+        ...ordered.filter((a) => !isCooling(a)),
+        ...ordered.filter(isCooling),
+    ];
+    // Forward the CLI's own query — it sends client_version, and upstream
+    // *requires* it: without it ChatGPT answers 400 with a pydantic
+    // "Field required" on ('query','client_version'). Rebuild from ctx.query,
+    // not ctx.path: path carries no query string, so reading it there silently
+    // dropped the parameter and produced exactly that 400.
+    const params = new URLSearchParams(ctx.query ?? {});
+    const query = params.toString();
+    const url = query ? `${CODEX_MODELS_URL}?${query}` : CODEX_MODELS_URL;
+    let lastErrorStatus = 502;
+    let lastErrorMessage = "Codex model discovery upstream failed";
+    for (const account of candidates) {
+        // One forced refresh per account, then move on. A token can be rejected
+        // upstream while still inside its local expiry window, so relaying that
+        // 401 straight back left discovery broken until the token expired locally
+        // — the CLI would fall back to a default model on every invocation in the
+        // meantime.
+        let authRetried = false;
+        for (;;) {
+            let upstream;
+            try {
+                upstream = await fetch(url, {
+                    method: "GET",
+                    headers: buildCodexUpstreamHeaders(ctx.headers ?? {}, account),
+                    // Bound the upstream call, as the responses route does. Without a
+                    // signal a stalled connection holds the proxy request open with no
+                    // ceiling, and the CLI blocks on model discovery at startup.
+                    signal: AbortSignal.timeout(CODEX_UPSTREAM_TIMEOUT_MS),
+                });
+            }
+            catch (error) {
+                lastErrorStatus = 502;
+                lastErrorMessage = `Codex model discovery upstream failed: ${error instanceof Error ? error.message : String(error)}`;
+                break; // rotate to the next account
+            }
+            if (upstream.status === 401 || upstream.status === 403) {
+                if (!authRetried && account.refreshToken) {
+                    authRetried = true;
+                    try {
+                        const refreshed = await refreshCodexToken(account.refreshToken);
+                        account.token = refreshed.accessToken;
+                        account.refreshToken =
+                            refreshed.refreshToken ?? account.refreshToken;
+                        account.expiresAt = refreshed.expiresAt ?? account.expiresAt;
+                        account.accountId = resolveCodexAccountId(refreshed.accessToken);
+                        await tokenStore.saveTokens(account.key, {
+                            accessToken: account.token,
+                            refreshToken: account.refreshToken,
+                            expiresAt: account.expiresAt ?? Date.now() + 3_600_000,
+                            tokenType: "Bearer",
+                        });
+                        continue; // retry this account with the fresh token
+                    }
+                    catch {
+                        // No cooldown and no disable, unlike the responses path: the
+                        // verdict a completion draws from a failed refresh is earned by a
+                        // request the user actually made. Discovery fires on every CLI
+                        // invocation, so letting it disable an account would turn a
+                        // background probe into a forced re-login.
+                        lastErrorStatus = 401;
+                        lastErrorMessage = "Codex token refresh failed; re-login required";
+                        break; // rotate
+                    }
+                }
+                lastErrorStatus = upstream.status;
+                lastErrorMessage = "Codex model discovery rejected upstream";
+                break; // rotate
+            }
+            // Every other status — including a 400 — is upstream's real answer to a
+            // well-formed request and is relayed unchanged. A 400 here means the
+            // query was not forwarded correctly, and hiding it behind a retry would
+            // bury the exact regression this route was added to fix.
+            const body = await upstream.text();
+            const contentType = upstream.headers.get("content-type") ?? "application/json";
+            return new Response(body, {
+                status: upstream.status,
+                headers: { "content-type": contentType },
+            });
+        }
+    }
+    // A discovery failure must not look like a missing route, or the next
+    // person debugging it re-opens this same issue.
+    return buildCodexErrorResponse(lastErrorStatus, lastErrorMessage);
+}
 /**
  * Create Codex proxy routes.
  *
@@ -468,6 +590,12 @@ export function createCodexProxyRoutes(basePath = "") {
                 description: "Codex ChatGPT-backend Responses API (account pool)",
                 handler: (ctx) => handleCodexResponsesRequest(ctx),
             },
+            {
+                method: "GET",
+                path: `${basePath}/backend-api/codex/models`,
+                description: "Codex model discovery, relayed upstream (account pool)",
+                handler: (ctx) => handleCodexModelsRequest(ctx),
+            },
         ],
     };
 }

package/dist/server/routes/geminiProxyRoutes.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Gemini-Compatible Proxy Routes
+ *
+ * Exposes the Google `generateContent` / `streamGenerateContent` endpoints the
+ * Gemini CLI calls when pointed at this proxy via `GOOGLE_GEMINI_BASE_URL`.
+ * ALL requests are routed through ctx.neurolink.stream() via the shared proxy
+ * translation engine — no direct HTTP calls to any upstream provider.
+ *
+ * This is a thin wrapper that parses the Google wire format and delegates to
+ * the same translation engine openaiProxyRoutes.ts and claudeProxyRoutes.ts
+ * use, mirroring that file's validate → log → delegate shape.
+ *
+ * An optional ModelRouter can remap incoming model names to different
+ * provider/model pairs, exactly as it does for the OpenAI-compatible door.
+ */
+import type { ModelRouterInterface, ParsedGeminiRequest, ProxyRuntimeConfigProvider, RouteGroup } from "../../types/index.js";
+/**
+ * Google bakes the action into the final path segment as `<model>:<action>`
+ * (`models/gemini-2.5-pro:generateContent`). Hono's router has no way to
+ * express a literal `:` after a named param — verified directly against the
+ * `hono` version this repo pins: registering `:model\:generateContent`
+ * doesn't escape the colon, it becomes *part of the param name*, and the
+ * resulting param still greedily swallows the whole trailing segment
+ * (`streamGenerateContent` included) because nothing after the leading `:`
+ * stops the capture except the next `/`. A `:model{regex}` constraint
+ * followed by literal text fails outright — the route never matches (404 on
+ * every request). A bare `:model` segment is therefore the only shape that
+ * actually matches; it captures `<model>:<action>` whole, and this function
+ * splits it back apart in the handler instead of in the route table.
+ */
+/**
+ * Pull "<model>:<action>" out of the request path.
+ *
+ * Read from `ctx.path`, not from a route param. Hono does capture the whole
+ * `gemini-2.5-pro:generateContent` segment — the colon is not a route
+ * separator, so one route covers both actions — but the proxy's mount loop
+ * builds its ServerContext from `path`, `headers`, `query`, `body`, `method`
+ * and `requestId` only. The captured param never reaches the handler, and
+ * reading `ctx.params` here would be `undefined` on every request.
+ */
+declare function splitModelAction(requestPath: string): {
+    modelId: string;
+    action: string | undefined;
+};
+/**
+ * buildProxyTranslationPlan's classifier expects ParsedClaudeRequest, whose
+ * `maxTokens` is required. Gemini's is optional (Google omits
+ * `generationConfig.maxOutputTokens` on plenty of real requests), so the gap
+ * is bridged the same way the OpenAI door bridges it: fill in a safe default
+ * and let the (structurally near-identical) rest pass through untouched.
+ */
+declare function adaptGeminiForTranslationPlan(parsed: ParsedGeminiRequest): {
+    model: string;
+    maxTokens: number;
+    temperature?: number;
+    topP?: number;
+    systemPrompt?: string;
+    stream: boolean;
+    prompt: string;
+    images: string[];
+    conversationMessages: Array<{
+        role: string;
+        content: string;
+    }>;
+    tools: Record<string, {
+        description?: string;
+        inputSchema: unknown;
+        execute?: (...args: unknown[]) => unknown;
+    }>;
+    stopSequences?: string[];
+};
+/**
+ * Create Gemini-compatible proxy routes.
+ *
+ * Every request flows through ctx.neurolink.stream() — no direct HTTP calls
+ * to any upstream provider.
+ *
+ * @param modelRouter   - Optional model router for remapping model names.
+ * @param basePath      - Base path prefix (default: "").
+ * @param loopbackPort  - Unused by this door; kept for parameter-shape parity
+ *                        with createOpenAIProxyRoutes (see DEFAULT_LOOPBACK_PORT).
+ * @returns RouteGroup with Gemini-compatible endpoints.
+ */
+export declare function createGeminiProxyRoutes(modelRouter?: ModelRouterInterface, basePath?: string, _loopbackPort?: number, runtimeConfigProvider?: ProxyRuntimeConfigProvider): RouteGroup;
+export declare const __testHooks: {
+    splitModelAction: typeof splitModelAction;
+    adaptGeminiForTranslationPlan: typeof adaptGeminiForTranslationPlan;
+};
+export {};