@juspay/neurolink 11.17.3 → 11.18.1

package/dist/proxy/clientAttribution.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Which CLI is calling, from its User-Agent.
+ *
+ * The proxy already computed a client label for trace spans, but it only
+ * distinguished `claude-cli/` from `ai/` and dropped the result into an OTel
+ * attribute. Nothing persisted it, so usage could be attributed to an account
+ * but never to the tool that spent it — the question a pooled-subscription
+ * operator actually asks.
+ *
+ * Two rules keep this honest as the roster grows:
+ *
+ * - **Only prefixes observed in real traffic appear here.** A guessed mapping
+ *   that never matches is indistinguishable from one that works, and silently
+ *   files a client under the wrong name if the guess collides.
+ * - **The raw header is persisted alongside the derived name.** An unrecognised
+ *   client is then still attributable by its own User-Agent rather than
+ *   collapsing into one bucket with every other unknown.
+ */
+/**
+ * Derive a stable client name, or "unknown" when the header is absent or
+ * unrecognised. Never throws: attribution must not be able to fail a request.
+ */
+export declare function detectProxyClient(userAgent: string | undefined): string;
+/** Read the User-Agent case-insensitively and bound it for storage. */
+export declare function readUserAgent(headers: Record<string, string> | undefined): string | undefined;
+/** The pair every proxy engine attaches to its request log entry. */
+export declare function buildClientAttribution(headers: Record<string, string> | undefined): {
+    clientApp: string;
+    userAgent?: string;
+};

package/dist/proxy/clientAttribution.js

@@ -0,0 +1,64 @@
+/**
+ * Which CLI is calling, from its User-Agent.
+ *
+ * The proxy already computed a client label for trace spans, but it only
+ * distinguished `claude-cli/` from `ai/` and dropped the result into an OTel
+ * attribute. Nothing persisted it, so usage could be attributed to an account
+ * but never to the tool that spent it — the question a pooled-subscription
+ * operator actually asks.
+ *
+ * Two rules keep this honest as the roster grows:
+ *
+ * - **Only prefixes observed in real traffic appear here.** A guessed mapping
+ *   that never matches is indistinguishable from one that works, and silently
+ *   files a client under the wrong name if the guess collides.
+ * - **The raw header is persisted alongside the derived name.** An unrecognised
+ *   client is then still attributable by its own User-Agent rather than
+ *   collapsing into one bucket with every other unknown.
+ */
+/** Longest prefix wins, so a more specific match cannot be shadowed. */
+const CLIENT_PREFIXES = [
+    // Verified against this machine's proxy logs.
+    ["claude-cli/", "claude-code"],
+    // Verified: the AI SDK's own UA, used by NeuroLink's SDK callers.
+    ["ai/", "sdk"],
+];
+/** Cap stored User-Agents. They are attacker-influenced and unbounded. */
+const MAX_USER_AGENT_CHARS = 200;
+/**
+ * Derive a stable client name, or "unknown" when the header is absent or
+ * unrecognised. Never throws: attribution must not be able to fail a request.
+ */
+export function detectProxyClient(userAgent) {
+    if (!userAgent) {
+        return "unknown";
+    }
+    const ua = userAgent.trim();
+    let best;
+    let bestLength = 0;
+    for (const [prefix, name] of CLIENT_PREFIXES) {
+        if (ua.startsWith(prefix) && prefix.length > bestLength) {
+            best = name;
+            bestLength = prefix.length;
+        }
+    }
+    return best ?? "unknown";
+}
+/** Read the User-Agent case-insensitively and bound it for storage. */
+export function readUserAgent(headers) {
+    if (!headers) {
+        return undefined;
+    }
+    for (const [name, value] of Object.entries(headers)) {
+        if (name.toLowerCase() === "user-agent" && typeof value === "string") {
+            const trimmed = value.trim();
+            return trimmed ? trimmed.slice(0, MAX_USER_AGENT_CHARS) : undefined;
+        }
+    }
+    return undefined;
+}
+/** The pair every proxy engine attaches to its request log entry. */
+export function buildClientAttribution(headers) {
+    const userAgent = readUserAgent(headers);
+    return { clientApp: detectProxyClient(userAgent), userAgent };
+}

package/dist/proxy/geminiFormat.d.ts

@@ -0,0 +1,77 @@
+/**
+ * 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.
+ */
+import type { ParsedGeminiRequest, StreamSerializerAdapter } from "../types/index.js";
+/**
+ * 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 declare function parseGeminiRequest(model: string, body: Record<string, unknown>, stream: boolean): ParsedGeminiRequest;
+/** Build a complete `generateContent` response body. */
+export declare function buildGeminiResponse(text: string, finishReason: string, usage: {
+    input: number;
+    output: number;
+    total: number;
+}, modelVersion: string): Record<string, unknown>;
+/** Google's error envelope, which the CLI parses to classify failures. */
+export declare function buildGeminiErrorResponse(status: number, message: string, statusText?: string): Response;
+/**
+ * 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 declare class GeminiStreamSerializer {
+    private readonly model;
+    constructor(model: string);
+    private frame;
+    /** Google sends no preamble frame; the first delta is the first frame. */
+    start(): string[];
+    pushDelta(text: string): string[];
+    /**
+     * 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: string, name: string, input: unknown): string[];
+    finish(finishReason: string, usage: {
+        input: number;
+        output: number;
+        total: number;
+    }): string[];
+    /**
+     * 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: string): string[];
+}
+/** Adapter so the translation engine can drive this like the other two. */
+export declare function createGeminiSerializerAdapter(model: string): StreamSerializerAdapter;

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,