@juspay/neurolink 11.17.3 → 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

@@ -23,6 +23,7 @@ import { clearAccountCooldown, loadAccountCooldowns, saveAccountCooldown, } from
 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,

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 {};