@juspay/neurolink 11.17.3 → 11.18.0

package/dist/cli/commands/proxy.js

@@ -1158,6 +1158,7 @@ export async function createProxyStartApp(params) {
     const { createClaudeProxyRoutes } = await import("../../server/routes/claudeProxyRoutes.js");
     const { createOpenAIProxyRoutes } = await import("../../server/routes/openaiProxyRoutes.js");
     const { createCodexProxyRoutes } = await import("../../server/routes/codexProxyRoutes.js");
+    const { createGeminiProxyRoutes } = await import("../../server/routes/geminiProxyRoutes.js");
     const { logBodyCapture, logRequest } = await import("../../proxy/requestLogger.js");
     const { recordFinalError } = await import("../../proxy/usageStats.js");
     const { Hono } = await import("hono");
@@ -1279,10 +1280,12 @@ export async function createProxyStartApp(params) {
         : params.accountAllowlist);
     const openaiRouteGroup = createOpenAIProxyRoutes(params.modelRouter, "", params.port, runtimeConfigProvider);
     const codexRouteGroup = createCodexProxyRoutes("");
+    const geminiRouteGroup = createGeminiProxyRoutes(params.modelRouter, "", params.port, runtimeConfigProvider);
     const allProxyRoutes = [
         ...routeGroup.routes,
         ...openaiRouteGroup.routes,
         ...codexRouteGroup.routes,
+        ...geminiRouteGroup.routes,
     ];
     for (const route of allProxyRoutes) {
         const method = route.method.toLowerCase();

package/dist/providers/googleNativeGemini3/utils.d.ts

@@ -28,55 +28,6 @@ export declare class DedupExecuteMap extends Map<string, Tool["execute"]> {
     private readonly resultCache;
     get(name: string): Tool["execute"] | undefined;
 }
-export declare function sanitizeForGoogleFunctionName(name: string): string;
-/**
- * Resolve a sanitized Gemini tool name to one that is both unique within
- * the current request and at most 128 characters. When the candidate
- * collides with an already-used name we append `_2`, `_3`, … — but
- * reserve room for the suffix by truncating the base first so the
- * resolved name never exceeds Google's `function_declarations[].name`
- * limit.
- *
- * @param base       The already-sanitized candidate name.
- * @param isTaken    Predicate that returns true if `name` is already used.
- */
-export declare function resolveUniqueGoogleFunctionName(base: string, isTaken: (name: string) => boolean): string;
-/**
- * Sanitize a JSON Schema for Gemini's proto-based API.
- *
- * Gemini cannot handle `anyOf`/`oneOf` union types in function declarations
- * because its proto format expects a single `type` field, not a list of types.
- * This function recursively converts unions to `string` type (the most
- * permissive primitive that can represent any value as text).
- *
- * Also removes `$schema`, `additionalProperties`, and `default` keys that
- * Gemini's proto format doesn't support.
- */
-export declare function sanitizeSchemaForGemini(schema: Record<string, unknown>): Record<string, unknown>;
-/**
- * Sanitize Vercel AI SDK tools for Gemini compatibility.
- *
- * For the Vercel AI SDK path (non-native), tool parameters are Zod schemas that
- * get converted to JSON Schema internally by @ai-sdk/google. This conversion
- * doesn't sanitize union types (anyOf/oneOf), causing Gemini proto errors.
- *
- * This function pre-converts each tool's Zod parameters to sanitized JSON Schema
- * and re-wraps with the Vercel AI SDK's jsonSchema() helper.
- */
-export declare function sanitizeToolsForGemini(tools: Record<string, Tool>): {
-    tools: Record<string, Tool>;
-    dropped: string[];
-    /**
-     * Reverse map: Google-safe sanitized name → original consumer-supplied
-     * name. Lets the calling layer translate tool-call results back so the
-     * sanitization stays transport-only (see CodeRabbit thread, PR #1006).
-     */
-    originalNameMap: Map<string, string>;
-};
-export declare function normalizeToolsForJsonSchemaProvider(tools: Record<string, Tool>): {
-    tools: Record<string, Tool>;
-    normalized: string[];
-};
 /**
  * Convert Vercel AI SDK tools to @google/genai FunctionDeclarations and an execute map.
  *

package/dist/providers/googleNativeGemini3/utils.js

@@ -15,11 +15,10 @@ import { DEFAULT_CONTEXT_GUARD_RATIO, DEFAULT_MAX_STEPS, DEFAULT_TOOL_MAX_RETRIE
 import { needsAudioTranscode, toProviderCompatibleAudio, } from "../../adapters/audioFormatSupport.js";
 import { logger } from "../../utils/logger.js";
 import { resolveSamplingParams } from "../../models/modelRegistry.js";
-import { convertZodToJsonSchema, ensureNestedSchemaTypes, inlineJsonSchema, isZodSchema, normalizeJsonSchemaObject, } from "../../utils/schemaConversion.js";
+import { convertZodToJsonSchema, ensureNestedSchemaTypes, inlineJsonSchema, isZodSchema, } from "../../utils/schemaConversion.js";
 import { createNativeThinkingConfig } from "../../utils/thinkingConfig.js";
 import { resolveLiveTool } from "../../tools/toolDiscovery.js";
 import { raceWithAbort, withTimeout } from "../../utils/async/index.js";
-import { jsonSchema as aiJsonSchema, tool as createAISDKTool, } from "../../utils/tool.js";
 // ── Functions ──
 /** Stable, key-order-independent serialization of tool args for the dedup key. */
 function stableStringifyForDedup(value) {
@@ -83,7 +82,7 @@ export class DedupExecuteMap extends Map {
  */
 const GOOGLE_FN_NAME_REGEX = /^[A-Za-z_][A-Za-z0-9_.:-]{0,127}$/;
 const GOOGLE_FN_NAME_MAX_LENGTH = 128;
-export function sanitizeForGoogleFunctionName(name) {
+function sanitizeForGoogleFunctionName(name) {
     if (GOOGLE_FN_NAME_REGEX.test(name)) {
         return name;
     }
@@ -107,7 +106,7 @@ export function sanitizeForGoogleFunctionName(name) {
  * @param base       The already-sanitized candidate name.
  * @param isTaken    Predicate that returns true if `name` is already used.
  */
-export function resolveUniqueGoogleFunctionName(base, isTaken) {
+function resolveUniqueGoogleFunctionName(base, isTaken) {
     if (!isTaken(base)) {
         return base;
     }
@@ -133,7 +132,7 @@ export function resolveUniqueGoogleFunctionName(base, isTaken) {
  * Also removes `$schema`, `additionalProperties`, and `default` keys that
  * Gemini's proto format doesn't support.
  */
-export function sanitizeSchemaForGemini(schema) {
+function sanitizeSchemaForGemini(schema) {
     // If this node has anyOf/oneOf, collapse to string type
     if (Array.isArray(schema.anyOf) || Array.isArray(schema.oneOf)) {
         const unionKey = schema.anyOf ? "anyOf" : "oneOf";
@@ -243,129 +242,6 @@ export function sanitizeSchemaForGemini(schema) {
     }
     return result;
 }
-/**
- * Sanitize Vercel AI SDK tools for Gemini compatibility.
- *
- * For the Vercel AI SDK path (non-native), tool parameters are Zod schemas that
- * get converted to JSON Schema internally by @ai-sdk/google. This conversion
- * doesn't sanitize union types (anyOf/oneOf), causing Gemini proto errors.
- *
- * This function pre-converts each tool's Zod parameters to sanitized JSON Schema
- * and re-wraps with the Vercel AI SDK's jsonSchema() helper.
- */
-export function sanitizeToolsForGemini(tools) {
-    const sanitized = {};
-    const dropped = [];
-    const renamed = [];
-    const originalNameMap = new Map();
-    for (const [name, tool] of Object.entries(tools)) {
-        try {
-            // Sanitize the tool name to fit Google's function_declarations regex.
-            // Without this, MCP-imported or user-registered tools whose names contain
-            // characters outside [A-Za-z_][A-Za-z0-9_.:-]{0,127} cause the entire
-            // request to 400 with "Invalid function name", surfacing as a misleading
-            // tool-calling failure. Distinct originals that collapse onto the same
-            // sanitized name (e.g. "my/tool" and "my-tool" → "my_tool") are
-            // disambiguated with a numeric suffix that preserves Google's 128-char
-            // ceiling.
-            const candidate = sanitizeForGoogleFunctionName(name);
-            const safeName = resolveUniqueGoogleFunctionName(candidate, (n) => n in sanitized);
-            // Always record the mapping so downstream code can translate every
-            // safeName back to the original — including the no-rename identity
-            // mapping, which simplifies the lookup path.
-            originalNameMap.set(safeName, name);
-            if (safeName !== name) {
-                renamed.push({ from: name, to: safeName });
-            }
-            // Access the legacy `parameters` field that may exist on older AI SDK tools.
-            // AI SDK v6 uses `inputSchema`, but v3/v4 tools and third-party wrappers use `parameters`.
-            const legacyTool = tool;
-            const params = legacyTool.parameters;
-            if (params &&
-                typeof params === "object" &&
-                "_def" in params &&
-                typeof params.parse === "function") {
-                const rawJsonSchema = convertZodToJsonSchema(params, "openApi3");
-                const inlined = inlineJsonSchema(rawJsonSchema);
-                // Gemini sanitization strips Zod-only features not supported by the Gemini API:
-                // union types (anyOf/oneOf) are collapsed to string, default values and
-                // additionalProperties are removed. The resulting schema is Gemini-compatible
-                // but loses some type constraints from the original Zod schema.
-                const sanitizedSchema = sanitizeSchemaForGemini(inlined);
-                sanitized[safeName] = createAISDKTool({
-                    description: tool.description || `Tool: ${safeName}`,
-                    inputSchema: aiJsonSchema(sanitizedSchema),
-                    execute: tool.execute,
-                });
-            }
-            else if (params &&
-                typeof params === "object" &&
-                "jsonSchema" in params) {
-                // Non-Zod JSON schema (e.g., from ai SDK jsonSchema() helper) — still needs sanitization
-                const rawSchema = params
-                    .jsonSchema;
-                const sanitizedSchema = sanitizeSchemaForGemini(inlineJsonSchema(rawSchema));
-                sanitized[safeName] = createAISDKTool({
-                    description: tool.description || `Tool: ${safeName}`,
-                    inputSchema: aiJsonSchema(sanitizedSchema),
-                    execute: tool.execute,
-                });
-            }
-            else {
-                sanitized[safeName] = tool;
-            }
-        }
-        catch (error) {
-            logger.warn(`[Gemini] Failed to sanitize tool "${name}", skipping: ${error instanceof Error ? error.message : String(error)}`);
-            // Don't fall back to the original tool — an incompatible schema would fail the Gemini request
-            dropped.push(name);
-        }
-    }
-    if (renamed.length > 0) {
-        logger.warn(`[Gemini] ${renamed.length} tool name(s) sanitized for Google's function-name regex: ${renamed
-            .map((r) => `"${r.from}" -> "${r.to}"`)
-            .join(", ")}`);
-    }
-    return { tools: sanitized, dropped, originalNameMap };
-}
-export function normalizeToolsForJsonSchemaProvider(tools) {
-    const normalizedTools = {};
-    const normalized = [];
-    for (const [name, tool] of Object.entries(tools)) {
-        const legacyTool = tool;
-        const toolParams = legacyTool.parameters || tool.inputSchema;
-        let rawSchema;
-        if (isZodSchema(toolParams)) {
-            rawSchema = convertZodToJsonSchema(toolParams, "openApi3");
-        }
-        else if (toolParams && typeof toolParams === "object") {
-            rawSchema = toolParams;
-        }
-        else {
-            rawSchema = { type: "object", properties: {} };
-        }
-        if (rawSchema.jsonSchema &&
-            typeof rawSchema.jsonSchema === "object" &&
-            !rawSchema.type) {
-            rawSchema = rawSchema.jsonSchema;
-        }
-        const schemaBefore = JSON.stringify(rawSchema);
-        const normalizedSchema = normalizeJsonSchemaObject(rawSchema);
-        if (JSON.stringify(normalizedSchema) !== schemaBefore) {
-            normalized.push(name);
-        }
-        const wrappedSchema = aiJsonSchema(normalizedSchema);
-        normalizedTools[name] = {
-            ...tool,
-            inputSchema: wrappedSchema,
-            ...(legacyTool.parameters ? { parameters: wrappedSchema } : {}),
-        };
-    }
-    return {
-        tools: normalizedTools,
-        normalized,
-    };
-}
 /**
  * Convert Vercel AI SDK tools to @google/genai FunctionDeclarations and an execute map.
  *

package/dist/proxy/accountLedger.js

@@ -144,6 +144,7 @@ async function advanceCursor(fileName, cursor) {
             outputTokens: finiteNumber(record.outputTokens),
             cacheReadTokens: finiteNumber(record.cacheReadTokens),
             cacheCreationTokens: finiteNumber(record.cacheCreationTokens),
+            clientApp: resolveClientApp(record),
         };
         // A later record for the same request enriches the earlier one — it must
         // replace it, never add to it. But token fields take the MAX rather than
@@ -214,6 +215,27 @@ function resolveSlotKey(cursor, entryKey, next) {
     }
     return slot;
 }
+/**
+ * Which CLI a log row came from.
+ *
+ * Prefers the derived name the proxy recorded. Falls back to the raw
+ * User-Agent's leading token so an unclassified client is still attributable
+ * instead of collapsing into one bucket with everything else. Rows written
+ * before attribution existed carry neither and are reported as "unattributed"
+ * — distinct from "unknown", which means a client we saw but could not name.
+ */
+function resolveClientApp(record) {
+    if (typeof record.clientApp === "string" && record.clientApp) {
+        return record.clientApp;
+    }
+    if (typeof record.userAgent === "string" && record.userAgent) {
+        const token = record.userAgent.trim().split(/[\s/]/)[0];
+        if (token) {
+            return token;
+        }
+    }
+    return "unattributed";
+}
 /** UTC date stamp of the log file the totals cover. */
 export function currentUsageDate(now = new Date()) {
     return now.toISOString().slice(0, 10);
@@ -228,6 +250,7 @@ function emptyTotals() {
         costUsd: 0,
         unpricedRequests: 0,
         unpricedModels: [],
+        byClient: {},
     };
 }
 /**
@@ -267,16 +290,31 @@ export async function readAccountUsage(date = currentUsageDate()) {
         row.outputTokens += entry.outputTokens;
         row.cacheReadTokens += entry.cacheReadTokens;
         row.cacheCreationTokens += entry.cacheCreationTokens;
+        const client = (row.byClient[entry.clientApp] ??= {
+            requests: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheReadTokens: 0,
+            cacheCreationTokens: 0,
+            costUsd: 0,
+        });
+        client.requests += 1;
+        client.inputTokens += entry.inputTokens;
+        client.outputTokens += entry.outputTokens;
+        client.cacheReadTokens += entry.cacheReadTokens;
+        client.cacheCreationTokens += entry.cacheCreationTokens;
         const provider = resolveProvider(entry);
         if (entry.model && entry.model !== "-") {
             if (hasPricing(provider, entry.model)) {
-                row.costUsd += calculateCost(provider, entry.model, {
+                const cost = calculateCost(provider, entry.model, {
                     input: entry.inputTokens,
                     output: entry.outputTokens,
                     total: entry.inputTokens + entry.outputTokens,
                     cacheReadTokens: entry.cacheReadTokens,
                     cacheCreationTokens: entry.cacheCreationTokens,
                 });
+                row.costUsd += cost;
+                client.costUsd += cost;
             }
             else {
                 row.unpricedRequests += 1;
@@ -289,6 +327,9 @@ export async function readAccountUsage(date = currentUsageDate()) {
     }
     for (const [account, row] of totals) {
         row.costUsd = Number(row.costUsd.toFixed(6));
+        for (const slice of Object.values(row.byClient)) {
+            slice.costUsd = Number(slice.costUsd.toFixed(6));
+        }
         row.unpricedModels = [...(unpriced.get(account) ?? [])].sort();
     }
     return totals;

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;