@juspay/neurolink 11.17.3 → 11.18.0

package/dist/server/routes/geminiProxyRoutes.js

@@ -0,0 +1,225 @@
+/**
+ * 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 { buildGeminiErrorResponse, parseGeminiRequest, } from "../../proxy/geminiFormat.js";
+import { ProxyTracer } from "../../proxy/proxyTracer.js";
+import { handleTranslatedJsonRequest, handleTranslatedStreamRequest, } from "../../proxy/proxyTranslationEngine.js";
+import { buildProxyTranslationPlan } from "../../proxy/routingPolicy.js";
+import { sanitizeForLog } from "../../utils/logSanitize.js";
+import { logger } from "../../utils/logger.js";
+// Default loopback port — kept only for signature parity with
+// createOpenAIProxyRoutes. Gemini has no Anthropic-loopback bridge (nothing
+// in the Google wire format needs the OAuth-passthrough detour), so the value
+// is threaded through but never read.
+const DEFAULT_LOOPBACK_PORT = 55669;
+const GENERATE = "generateContent";
+const STREAM_GENERATE = "streamGenerateContent";
+// ---------------------------------------------------------------------------
+// Path parsing
+// ---------------------------------------------------------------------------
+/**
+ * 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.
+ */
+function splitModelAction(requestPath) {
+    // Take the last path segment, ignoring any trailing slash or query.
+    const withoutQuery = requestPath.split("?")[0];
+    const rawSegment = withoutQuery.replace(/\/+$/, "").split("/").pop() ?? "";
+    const separatorIndex = rawSegment.lastIndexOf(":");
+    if (separatorIndex === -1) {
+        return { modelId: rawSegment, action: undefined };
+    }
+    return {
+        modelId: rawSegment.slice(0, separatorIndex),
+        action: rawSegment.slice(separatorIndex + 1),
+    };
+}
+// ---------------------------------------------------------------------------
+// Adapt ParsedGeminiRequest to the shape buildProxyTranslationPlan expects
+// ---------------------------------------------------------------------------
+/**
+ * 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.
+ */
+function adaptGeminiForTranslationPlan(parsed) {
+    return {
+        model: parsed.model,
+        maxTokens: parsed.maxTokens ?? 4096,
+        temperature: parsed.temperature,
+        topP: parsed.topP,
+        systemPrompt: parsed.systemPrompt,
+        stream: parsed.stream,
+        prompt: parsed.prompt,
+        images: parsed.images,
+        conversationMessages: parsed.conversationMessages,
+        tools: parsed.tools,
+        stopSequences: parsed.stopSequences,
+    };
+}
+// ---------------------------------------------------------------------------
+// Route factory
+// ---------------------------------------------------------------------------
+/**
+ * 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 function createGeminiProxyRoutes(modelRouter, basePath = "", _loopbackPort = DEFAULT_LOOPBACK_PORT, runtimeConfigProvider) {
+    return {
+        prefix: `${basePath}/v1beta`,
+        routes: [
+            // =================================================================
+            // POST /v1beta/models/:model — covers both `:generateContent` and
+            // `:streamGenerateContent`; the action lives inside the captured
+            // segment, not in a second route (see splitModelAction above).
+            // =================================================================
+            {
+                method: "POST",
+                path: `${basePath}/v1beta/models/:model`,
+                description: "Gemini-compatible generateContent / streamGenerateContent (translation mode)",
+                handler: async (ctx) => {
+                    const requestModelRouter = runtimeConfigProvider
+                        ? runtimeConfigProvider().modelRouter
+                        : modelRouter;
+                    const requestStartTime = Date.now();
+                    // --- Split "<model>:<action>" out of the captured path segment ---
+                    const { modelId, action } = splitModelAction(ctx.path);
+                    if (!modelId || (action !== GENERATE && action !== STREAM_GENERATE)) {
+                        // Mirrors Google's own 404 shape so the CLI's error handling
+                        // (which parses `error.status`) sees a response it recognizes
+                        // instead of a bare proxy 404.
+                        return buildGeminiErrorResponse(404, `Unsupported Gemini endpoint: ${ctx.path}`, "NOT_FOUND");
+                    }
+                    const body = ctx.body;
+                    // --- Validation ---
+                    if (!body ||
+                        !Array.isArray(body.contents) ||
+                        body.contents.length === 0) {
+                        return buildGeminiErrorResponse(400, "Request must include a non-empty 'contents' array");
+                    }
+                    const stream = action === STREAM_GENERATE;
+                    // --- Resolve target provider/model ---
+                    const route = requestModelRouter
+                        ? requestModelRouter.resolve(modelId)
+                        : { provider: null, model: modelId };
+                    const targetProvider = route.provider ?? undefined;
+                    const targetModel = route.model ?? modelId;
+                    logger.debug(`[proxy:gemini] ${modelId} → ${targetProvider ?? "auto"}/${targetModel}`);
+                    // --- Parse request ---
+                    const parsed = parseGeminiRequest(targetModel, body, stream);
+                    // --- Build translation plan ---
+                    const adapted = adaptGeminiForTranslationPlan(parsed);
+                    const plan = buildProxyTranslationPlan({
+                        provider: targetProvider ?? "auto",
+                        model: targetModel,
+                    }, requestModelRouter?.getFallbackChain() ?? [], modelId, 
+                    // The classifier only reads fields present across all three formats.
+                    adapted, requestModelRouter?.isAutoFallbackEnabled?.() ?? false);
+                    const attempts = plan.attempts;
+                    // --- Optional tracing ---
+                    let tracer;
+                    try {
+                        tracer = ProxyTracer.startRequest({
+                            requestId: ctx.requestId,
+                            method: ctx.method,
+                            path: ctx.path,
+                            model: modelId,
+                            stream,
+                            toolCount: Object.keys(parsed.tools).length,
+                            clientApp: "gemini-compat",
+                            userAgent: ctx.headers["user-agent"] ?? "",
+                            // Same reasoning as the OpenAI door: without an explicit
+                            // provider the tracer defaults to "anthropic" and prices a
+                            // Gemini model at Claude rates (or $0, off the anthropic
+                            // table's _default-less lookup).
+                            provider: targetProvider ?? "google-ai",
+                        }, ctx.headers);
+                        tracer.setMode("full");
+                    }
+                    catch {
+                        // Tracing is best-effort; continue without it.
+                    }
+                    // --- Dispatch via shared translation engine ---
+                    try {
+                        if (stream) {
+                            return handleTranslatedStreamRequest({
+                                ctx,
+                                format: "gemini",
+                                requestModel: modelId,
+                                parsed,
+                                attempts,
+                                tracer,
+                                requestStartTime,
+                            });
+                        }
+                        return await handleTranslatedJsonRequest({
+                            ctx,
+                            format: "gemini",
+                            requestModel: modelId,
+                            parsed,
+                            attempts,
+                            tracer,
+                            requestStartTime,
+                        });
+                    }
+                    catch (err) {
+                        // Internal exception text (.message + any stack-trace remnants)
+                        // is kept ONLY in server-side logs + tracer. The client receives
+                        // a fixed generic message so internal paths/frames don't leak
+                        // back through the response body. (CodeQL: information exposure
+                        // through a stack trace.)
+                        const rawMessage = err instanceof Error ? err.message : String(err);
+                        const internalDetail = sanitizeForLog(rawMessage);
+                        logger.always(`[proxy:gemini] request failed: ${internalDetail}`);
+                        tracer?.setError("generation_error", internalDetail);
+                        tracer?.end(500, Date.now() - requestStartTime);
+                        return buildGeminiErrorResponse(500, "Internal proxy error", "INTERNAL");
+                    }
+                },
+            },
+        ],
+    };
+}
+export const __testHooks = { splitModelAction, adaptGeminiForTranslationPlan };

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

@@ -8,6 +8,7 @@ export { createClaudeProxyRoutes } from "./claudeProxyRoutes.js";
 export { createHealthRoutes } from "./healthRoutes.js";
 export { createOpenAIProxyRoutes } from "./openaiProxyRoutes.js";
 export { createCodexProxyRoutes } from "./codexProxyRoutes.js";
+export { createGeminiProxyRoutes } from "./geminiProxyRoutes.js";
 export { createMCPRoutes } from "./mcpRoutes.js";
 export { createMemoryRoutes } from "./memoryRoutes.js";
 export { createOpenApiRoutes } from "./openApiRoutes.js";

package/dist/server/routes/index.js

@@ -5,6 +5,7 @@
 import { createAgentRoutes } from "./agentRoutes.js";
 import { createClaudeProxyRoutes } from "./claudeProxyRoutes.js";
 // ClaudeProxyDeps removed
+import { createGeminiProxyRoutes } from "./geminiProxyRoutes.js";
 import { createHealthRoutes } from "./healthRoutes.js";
 import { createOpenAIProxyRoutes } from "./openaiProxyRoutes.js";
 import { createCodexProxyRoutes } from "./codexProxyRoutes.js";
@@ -19,6 +20,7 @@ export { createClaudeProxyRoutes } from "./claudeProxyRoutes.js";
 export { createHealthRoutes } from "./healthRoutes.js";
 export { createOpenAIProxyRoutes } from "./openaiProxyRoutes.js";
 export { createCodexProxyRoutes } from "./codexProxyRoutes.js";
+export { createGeminiProxyRoutes } from "./geminiProxyRoutes.js";
 export { createMCPRoutes } from "./mcpRoutes.js";
 export { createMemoryRoutes } from "./memoryRoutes.js";
 export { createOpenApiRoutes } from "./openApiRoutes.js";
@@ -46,6 +48,7 @@ export function createAllRoutes(basePath = "/api", options) {
     const enableClaudeProxy = options?.proxy || options?.claudeProxy;
     const enableOpenAIProxy = options?.proxy || options?.openaiProxy;
     const enableCodexProxy = options?.proxy || options?.codexProxy;
+    const enableGeminiProxy = options?.proxy || options?.geminiProxy;
     if (enableClaudeProxy) {
         routes.push(createClaudeProxyRoutes(undefined, basePath));
     }
@@ -55,6 +58,9 @@ export function createAllRoutes(basePath = "/api", options) {
     if (enableCodexProxy) {
         routes.push(createCodexProxyRoutes(basePath));
     }
+    if (enableGeminiProxy) {
+        routes.push(createGeminiProxyRoutes(undefined, basePath));
+    }
     return routes;
 }
 /**

package/dist/server/routes/openaiProxyRoutes.js

@@ -14,6 +14,7 @@
 import { buildOpenAIError, convertClaudeToOpenAIResponse, convertOpenAIToClaudeRequest, createClaudeToOpenAIStreamTransform, parseOpenAIRequest, } from "../../proxy/openaiFormat.js";
 import { ProxyTracer } from "../../proxy/proxyTracer.js";
 import { buildModelsListResponse, handleTranslatedJsonRequest, handleTranslatedStreamRequest, } from "../../proxy/proxyTranslationEngine.js";
+import { buildClientAttribution } from "../../proxy/clientAttribution.js";
 import { logRequest } from "../../proxy/requestLogger.js";
 import { buildProxyTranslationPlan } from "../../proxy/routingPolicy.js";
 import { withTimeout } from "../../utils/async/withTimeout.js";
@@ -108,6 +109,7 @@ async function handleOpenAIToAnthropicBridge(args) {
         toolCount,
         account: "",
         accountType: "openai-bridge",
+        ...buildClientAttribution(ctx.headers),
         responseStatus,
         responseTimeMs: Date.now() - requestStartTime,
         ...extra,

package/dist/types/proxy.d.ts

@@ -576,6 +576,18 @@ export type RequestLogEntry = {
      * cross-provider model lookup rather than assuming Anthropic.
      */
     provider?: string;
+    /**
+     * Which CLI made the request, derived from User-Agent, and the raw header it
+     * was derived from.
+     *
+     * Both are stored. The derived name is what a dashboard groups on, but the
+     * classifier only knows the clients it has seen — keeping the raw header
+     * means a client it does not recognise is still attributable rather than
+     * collapsing into "unknown" with everything else.
+     */
+    clientApp?: string;
+    /** Raw User-Agent, truncated. See clientApp. */
+    userAgent?: string;
     /** OTel trace ID for correlation with distributed traces */
     traceId?: string;
     /** OTel span ID for correlation with distributed traces */
@@ -2609,7 +2621,7 @@ export type StatusStats = {
 /** Sub-action of the `proxy telemetry` CLI command. */
 export type ProxyTelemetryAction = "setup" | "start" | "stop" | "status" | "logs" | "import-dashboard";
 /** Wire format a proxy request is using. */
-export type ProxyFormat = "claude" | "openai";
+export type ProxyFormat = "claude" | "openai" | "gemini";
 /**
  * Common adapter interface that hides the differences between
  * Claude and OpenAI stream serializers from the unified translation engine.
@@ -2761,6 +2773,47 @@ export type OpenAIErrorResponse = {
     };
 };
 /** Parsed OpenAI request — intermediate form for NeuroLink pipeline. */
+/**
+ * A Gemini `generateContent` request, reduced to what translation needs.
+ *
+ * Google's shape differs from both others in three ways that matter here:
+ * roles are `user`/`model` rather than `user`/`assistant`, the system prompt
+ * lives in a sibling `systemInstruction` rather than in the turn list, and
+ * generation settings are nested under `generationConfig` instead of sitting
+ * at the top level.
+ */
+/** One part of a Gemini `contents[].parts[]` entry. */
+export type ProxyGeminiPart = {
+    text?: string;
+    inlineData?: {
+        data?: string;
+    };
+};
+/** One turn in a Gemini `contents[]` array. */
+export type ProxyGeminiContent = {
+    role?: string;
+    parts?: ProxyGeminiPart[];
+};
+export type 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[];
+};
 export type ParsedOpenAIRequest = {
     model: string;
     maxTokens?: number;

package/dist/types/proxyClient.d.ts

@@ -72,6 +72,22 @@ export type CliAccountUsageTotals = {
     unpricedRequests: number;
     /** Distinct models with no pricing row, so an operator can chase them. */
     unpricedModels: string[];
+    /**
+     * Same totals split by calling CLI, keyed by the derived client name.
+     *
+     * Empty for traffic logged before attribution existed — those rows carry no
+     * User-Agent, and guessing one retroactively would invent history.
+     */
+    byClient: Record<string, CliClientUsageTotals>;
+};
+/** Per-CLI slice of an account's usage. See CliAccountUsageTotals.byClient. */
+export type CliClientUsageTotals = {
+    requests: number;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+    costUsd: number;
 };
 /** One row of GET /accounts. */
 export type CliAccountsRow = {
@@ -117,6 +133,8 @@ export type CliAccountsResponse = {
 /** One request as recorded in the proxy request log, reduced to what costing needs. */
 export type ProxyLedgerEntry = {
     account: string;
+    /** Derived calling CLI; see CliAccountUsageTotals.byClient. */
+    clientApp: string;
     accountType: string;
     model: string;
     provider?: string;

package/dist/types/server.d.ts

@@ -1058,7 +1058,7 @@ export type OpenAPISpec = {
 export type CreateRoutesOptions = {
     enableSwagger?: boolean;
     getRoutes?: () => RouteDefinition[];
-    /** Enable every proxy door: Claude, OpenAI and Codex. */
+    /** Enable every proxy door: Claude, OpenAI, Codex and Gemini. */
     proxy?: boolean;
     claudeProxy?: boolean;
     openaiProxy?: boolean;
@@ -1066,10 +1066,12 @@ export type CreateRoutesOptions = {
      * Enable the Codex door on its own.
      *
      * Codex was reachable only from `neurolink proxy start` until this existed —
-     * `createAllRoutes` mounted two of the three doors, so an SDK consumer could
-     * not expose it even deliberately.
+     * `createAllRoutes` mounted two of the doors, so an SDK consumer could not
+     * expose it even deliberately.
      */
     codexProxy?: boolean;
+    /** Enable the Gemini door on its own, for the same reason. */
+    geminiProxy?: boolean;
 };
 /** Data stream finish event. */
 export type FinishEvent = DataStreamEvent & {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "11.17.3",
+  "version": "11.18.0",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {