@juspay/neurolink 9.40.0 → 9.42.0

package/dist/lib/providers/ollama.js

@@ -11,7 +11,7 @@ import { InvalidModelError, NetworkError, ProviderError, } from "../types/errors
 import { tracers, ATTR, withClientSpan } from "../telemetry/index.js";
 import { TimeoutError } from "../utils/timeout.js";
 // Model version constants (configurable via environment)
-const DEFAULT_OLLAMA_MODEL = "llama3.1:8b";
+const DEFAULT_OLLAMA_MODEL = process.env.OLLAMA_MODEL || "llama3.1:8b";
 const FALLBACK_OLLAMA_MODEL = "llama3.2:latest"; // Used when primary model fails
 // Configuration helpers
 const getOllamaBaseUrl = () => {
@@ -40,6 +40,17 @@ const getOllamaTimeout = () => {
     // especially for larger models like aliafshar/gemma3-it-qat-tools:latest (12.2B parameters)
     return parseInt(process.env.OLLAMA_TIMEOUT || "240000", 10);
 };
+async function createOllamaHttpError(response) {
+    let responseBody = "";
+    try {
+        responseBody = (await response.text()).trim();
+    }
+    catch {
+        // Ignore unreadable bodies
+    }
+    const suffix = responseBody ? ` - ${responseBody.slice(0, 500)}` : "";
+    return new Error(`Ollama API error: ${response.status} ${response.statusText}${suffix}`);
+}
 // Create proxy-aware fetch instance
 const proxyFetch = createProxyFetch();
 // Custom LanguageModel implementation for Ollama
@@ -110,21 +121,37 @@ class OllamaLanguageModel {
                 signal: createAbortSignalWithTimeout(this.timeout),
             });
             if (!response.ok) {
-                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+                throw await createOllamaHttpError(response);
             }
             const data = await response.json();
             logger.debug("[OllamaLanguageModel] OpenAI API Response:", JSON.stringify(data, null, 2));
             const text = data.choices?.[0]?.message?.content || "";
             const usage = data.usage || {};
+            const promptTokens = usage.prompt_tokens ??
+                this.estimateTokenCount(JSON.stringify(messages));
+            const completionTokens = usage.completion_tokens ?? this.estimateTokenCount(text);
             return {
+                content: text ? [{ type: "text", text }] : [],
                 text,
                 usage: {
-                    promptTokens: usage.prompt_tokens ??
-                        this.estimateTokenCount(JSON.stringify(messages)),
-                    completionTokens: usage.completion_tokens ?? this.estimateTokenCount(text),
-                    totalTokens: usage.total_tokens,
+                    inputTokens: promptTokens,
+                    outputTokens: completionTokens,
+                    promptTokens,
+                    completionTokens,
+                    totalTokens: usage.total_tokens ?? promptTokens + completionTokens,
+                },
+                finishReason: data.choices?.[0]?.finish_reason ?? "stop",
+                warnings: [],
+                request: {
+                    body: JSON.stringify(requestBody),
+                },
+                response: {
+                    id: data.id,
+                    modelId: data.model,
+                    timestamp: new Date(),
+                    headers: {},
+                    body: data,
                 },
-                finishReason: "stop",
                 rawCall: {
                     rawPrompt: messages,
                     rawSettings: {
@@ -158,21 +185,45 @@ class OllamaLanguageModel {
                 signal: createAbortSignalWithTimeout(this.timeout),
             });
             if (!response.ok) {
-                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+                throw await createOllamaHttpError(response);
             }
             const data = await response.json();
             logger.debug("[OllamaLanguageModel] Native API Response:", JSON.stringify(data, null, 2));
+            const text = String(data.response ?? "");
+            const promptTokens = data.prompt_eval_count ?? this.estimateTokenCount(prompt);
+            const completionTokens = data.eval_count ?? this.estimateTokenCount(text);
+            const requestBody = {
+                model: this.modelId,
+                prompt,
+                stream: false,
+                system: messages.find((m) => m.role === "system")?.content,
+                options: {
+                    temperature: options.temperature,
+                    num_predict: options.maxTokens,
+                },
+            };
             return {
-                text: data.response,
+                content: text ? [{ type: "text", text }] : [],
+                text,
                 usage: {
-                    promptTokens: data.prompt_eval_count ?? this.estimateTokenCount(prompt),
-                    completionTokens: data.eval_count ??
-                        this.estimateTokenCount(String(data.response ?? "")),
-                    totalTokens: (data.prompt_eval_count ?? this.estimateTokenCount(prompt)) +
-                        (data.eval_count ??
-                            this.estimateTokenCount(String(data.response ?? ""))),
+                    inputTokens: promptTokens,
+                    outputTokens: completionTokens,
+                    promptTokens,
+                    completionTokens,
+                    totalTokens: promptTokens + completionTokens,
+                },
+                finishReason: data.done_reason ?? "stop",
+                warnings: [],
+                request: {
+                    body: JSON.stringify(requestBody),
+                },
+                response: {
+                    id: data.created_at,
+                    modelId: this.modelId,
+                    timestamp: data.created_at ? new Date(data.created_at) : new Date(),
+                    headers: {},
+                    body: data,
                 },
-                finishReason: "stop",
                 rawCall: {
                     rawPrompt: prompt,
                     rawSettings: {
@@ -220,7 +271,7 @@ class OllamaLanguageModel {
                 ok: response.ok,
             });
             if (!response.ok) {
-                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+                throw await createOllamaHttpError(response);
             }
             const self = this;
             return {
@@ -282,7 +333,7 @@ class OllamaLanguageModel {
                 ok: response.ok,
             });
             if (!response.ok) {
-                throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+                throw await createOllamaHttpError(response);
             }
             const self = this;
             return {
@@ -705,7 +756,7 @@ export class OllamaProvider extends BaseProvider {
                                 signal: createAbortSignalWithTimeout(this.timeout),
                             });
                             if (!response.ok) {
-                                throw this.handleProviderError(new Error(`Ollama API error: ${response.status} ${response.statusText}`));
+                                throw this.handleProviderError(await createOllamaHttpError(response));
                             }
                             // Process response stream
                             const { content, toolCalls, finishReason } = await this.processOllamaResponse(response, controller);
@@ -870,7 +921,7 @@ export class OllamaProvider extends BaseProvider {
                     ok: response.ok,
                 });
                 if (!response.ok) {
-                    throw this.handleProviderError(new Error(`Ollama API error: ${response.status} ${response.statusText}`));
+                    throw this.handleProviderError(await createOllamaHttpError(response));
                 }
                 // Transform to async generator for OpenAI-compatible format
                 const self = this;
@@ -936,7 +987,7 @@ export class OllamaProvider extends BaseProvider {
                     ok: response.ok,
                 });
                 if (!response.ok) {
-                    throw this.handleProviderError(new Error(`Ollama API error: ${response.status} ${response.statusText}`));
+                    throw this.handleProviderError(await createOllamaHttpError(response));
                 }
                 // Transform to async generator to match other providers
                 const self = this;
@@ -1486,8 +1537,14 @@ export class OllamaProvider extends BaseProvider {
             error.message?.includes("not found")) {
             return new InvalidModelError(`❌ Ollama Model Not Found\n\nModel '${this.modelName}' is not available locally.\n\n🔧 Install Model:\n1. Run: ollama pull ${this.modelName}\n2. Or try a different model:\n   - ollama pull ${FALLBACK_OLLAMA_MODEL}\n   - ollama pull mistral:latest\n   - ollama pull codellama:latest\n\n🔧 List Available Models:\nollama list`, this.providerName);
         }
-        if (error.message?.includes("404")) {
-            return new NetworkError(`❌ Ollama API Endpoint Not Found\n\nThe API endpoint might have changed or Ollama version is incompatible.\n\n🔧 Check:\n1. Ollama version: 'ollama --version'\n2. Update Ollama to latest version\n3. Verify API is available: 'curl ${this.baseUrl}/api/version'`, this.providerName);
+        const errMsg = error.message ?? "";
+        if (errMsg.includes("404") &&
+            (errMsg.toLowerCase().includes("model") ||
+                errMsg.toLowerCase().includes("not found"))) {
+            return new InvalidModelError(`❌ Ollama Returned HTTP 404\n\nThis usually means the configured model '${this.modelName}' is not installed locally, although a bad base URL or incompatible API mode can also cause it.\n\n🔧 Check:\n1. Verify the model exists: 'ollama list'\n2. Pull it if missing: 'ollama pull ${this.modelName}'\n3. Verify the service is healthy: 'curl ${this.baseUrl}/api/version'\n4. If you use OpenAI-compatible mode, confirm the base URL serves /v1/chat/completions`, this.providerName);
+        }
+        if (errMsg.includes("404")) {
+            return new ProviderError(`❌ Ollama Endpoint Returned HTTP 404\n\nThe configured base URL (${this.baseUrl}) did not serve the expected Ollama endpoint for model '${this.modelName}'. This is usually a configuration or API-mode mismatch rather than a missing model.\n\n🔧 Check:\n1. Verify the base URL: ${this.baseUrl}\n2. For native Ollama mode, confirm /api/generate exists\n3. For OpenAI-compatible mode, confirm /v1/chat/completions exists\n4. If the model is missing, the response body should explicitly say so`, this.providerName);
         }
         return new ProviderError(`❌ Ollama Provider Error\n\n${error.message || "Unknown error occurred"}\n\n🔧 Troubleshooting:\n1. Check if Ollama service is running\n2. Verify model is installed: 'ollama list'\n3. Check network connectivity to ${this.baseUrl}\n4. Review Ollama logs for details`, this.providerName);
     }

package/dist/lib/providers/openAI.js

@@ -1,6 +1,6 @@
 import { createOpenAI } from "@ai-sdk/openai";
+import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { embed, embedMany, NoOutputGeneratedError, stepCountIs, streamText, } from "ai";
-import { trace, SpanKind, SpanStatusCode } from "@opentelemetry/api";
 import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
@@ -12,6 +12,7 @@ import { calculateCost } from "../utils/pricing.js";
 import { createOpenAIConfig, getProviderModel, validateApiKey, } from "../utils/providerConfig.js";
 import { isZodSchema } from "../utils/schemaConversion.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
 import { getModelId } from "./providerTypeUtils.js";
 /**
  * Retrieve a tool's schema, handling both AI SDK v6 (`inputSchema`) and
@@ -314,7 +315,7 @@ export class OpenAIProvider extends BaseProvider {
                     maxRetries: 0, // NL11: Disable AI SDK's invisible internal retries; we handle retries with OTel instrumentation
                     tools,
                     stopWhen: stepCountIs(options.maxSteps || DEFAULT_MAX_STEPS),
-                    toolChoice: shouldUseTools && Object.keys(tools).length > 0 ? "auto" : "none",
+                    toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                     abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                     experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                     onStepFinish: ({ toolCalls, toolResults }) => {

package/dist/lib/providers/openRouter.js

@@ -9,6 +9,7 @@ import { isAbortError } from "../utils/errorHandling.js";
 import { logger } from "../utils/logger.js";
 import { getProviderModel } from "../utils/providerConfig.js";
 import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
 // Constants
 const MODELS_DISCOVERY_TIMEOUT_MS = 5000; // 5 seconds for model discovery
 // Configuration helpers
@@ -234,7 +235,7 @@ export class OpenRouterProvider extends BaseProvider {
                 ...(shouldUseTools &&
                     Object.keys(tools).length > 0 && {
                     tools,
-                    toolChoice: "auto",
+                    toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                     maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 }),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),

package/dist/lib/providers/openaiCompatible.d.ts

@@ -1,8 +1,8 @@
-import { type Schema, type LanguageModel } from "ai";
-import type { ZodUnknownSchema } from "../types/typeAliases.js";
-import { AIProviderName } from "../constants/enums.js";
-import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+import { type LanguageModel, type Schema } from "ai";
+import type { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
+import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
+import type { ZodUnknownSchema } from "../types/typeAliases.js";
 /**
  * OpenAI Compatible Provider - BaseProvider Implementation
  * Provides access to one of the OpenAI-compatible endpoint (OpenRouter, vLLM, LiteLLM, etc.)

package/dist/lib/providers/openaiCompatible.js

@@ -1,11 +1,11 @@
 import { createOpenAI } from "@ai-sdk/openai";
 import { NoOutputGeneratedError, streamText, } from "ai";
-import { AIProviderName } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
-import { logger } from "../utils/logger.js";
-import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
 import { streamAnalyticsCollector } from "../core/streamAnalytics.js";
 import { createProxyFetch } from "../proxy/proxyFetch.js";
+import { logger } from "../utils/logger.js";
+import { composeAbortSignals, createTimeoutController, TimeoutError, } from "../utils/timeout.js";
+import { resolveToolChoice } from "../utils/toolChoice.js";
 import { toAnalyticsStreamResult } from "./providerTypeUtils.js";
 // Constants
 const FALLBACK_OPENAI_COMPATIBLE_MODEL = "gpt-3.5-turbo";
@@ -178,7 +178,7 @@ export class OpenAICompatibleProvider extends BaseProvider {
                     ? { temperature: options.temperature }
                     : {}),
                 tools,
-                toolChoice: shouldUseTools ? "auto" : "none",
+                toolChoice: resolveToolChoice(options, tools, shouldUseTools),
                 abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                 experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                 onStepFinish: (event) => {

package/dist/lib/proxy/claudeFormat.d.ts

@@ -74,6 +74,7 @@ export declare function formatSSE(eventType: string, data: unknown): string;
 export declare class ClaudeStreamSerializer {
     private state;
     private currentBlockType;
+    private sawToolUseBlock;
     private blockIndex;
     private hasOpenedBlock;
     private outputTokens;
@@ -107,8 +108,8 @@ export declare class ClaudeStreamSerializer {
      */
     private openBlock;
     /**
-     * Emit the opening frames: message_start, ping, content_block_start (text).
-     * Automatically called on the first pushDelta if not called manually.
+     * Emit the opening frames: message_start and ping.
+     * The first actual content decides which content block opens next.
      */
     start(): Generator<string>;
     /**

package/dist/lib/proxy/claudeFormat.js

@@ -8,8 +8,8 @@
  *
  * Reference: https://docs.anthropic.com/en/api/messages
  */
+import { jsonSchema, tool } from "ai";
 import { randomBytes } from "crypto";
-import { jsonSchema } from "ai";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -122,9 +122,7 @@ export function parseClaudeRequest(body) {
                     const resultContent = typeof block.content === "string"
                         ? block.content
                         : Array.isArray(block.content)
-                            ? block.content
-                                .map((b) => (b.type === "text" ? b.text : `[${b.type}]`))
-                                .join("\n")
+                            ? block.content.map((b) => (b.type === "text" ? b.text : `[${b.type}]`)).join("\n")
                             : "";
                     textParts.push(`[tool_result:${block.tool_use_id}] ${resultContent}`);
                 }
@@ -148,13 +146,13 @@ export function parseClaudeRequest(body) {
     const tools = {};
     if (body.tools) {
         for (const t of body.tools) {
-            tools[t.name] = {
+            tools[t.name] = tool({
                 description: t.description ?? "",
-                // Wrap raw JSON schema with AI SDK's jsonSchema() so the SDK
-                // recognizes it (it checks for Symbol.for("vercel.ai.schema")).
-                // Without this, the SDK tries zodSchema() on raw JSON and crashes.
-                parameters: jsonSchema(t.input_schema ?? { type: "object" }),
-            };
+                // Fallback providers consume AI SDK-style tools, not Claude wire-format
+                // tool descriptors. Wrap the raw JSON schema once here so every
+                // downstream provider sees a canonical `inputSchema` shape.
+                inputSchema: jsonSchema(t.input_schema ?? { type: "object" }),
+            });
         }
     }
     // --- tool_choice ---
@@ -186,9 +184,7 @@ export function parseClaudeRequest(body) {
             enabled: isEnabled,
             budgetTokens: body.thinking.budget_tokens,
             // Pass the raw type so providers can map "adaptive" appropriately
-            ...(body.thinking.type === "adaptive"
-                ? { thinkingLevel: "medium" }
-                : {}),
+            ...(body.thinking.type === "adaptive" ? { thinkingLevel: "medium" } : {}),
         };
     }
     return {
@@ -239,6 +235,9 @@ function mapStopReason(finishReason) {
  */
 export function serializeClaudeResponse(result, requestModel) {
     const content = [];
+    const inferredFinishReason = result.toolCalls && result.toolCalls.length > 0 && (!result.finishReason || result.finishReason === "stop")
+        ? "tool_use"
+        : result.finishReason;
     // Thinking/reasoning content block (if present)
     if (result.reasoning) {
         content.push({ type: "thinking", thinking: result.reasoning });
@@ -250,11 +249,15 @@ export function serializeClaudeResponse(result, requestModel) {
     // Tool use blocks — normalize IDs to Claude `toolu_` format
     if (result.toolCalls && result.toolCalls.length > 0) {
         for (const tc of result.toolCalls) {
+            const toolInput = tc.args ??
+                tc.parameters ??
+                tc.input ??
+                {};
             content.push({
                 type: "tool_use",
                 id: generateToolUseId(),
                 name: tc.toolName,
-                input: tc.args,
+                input: toolInput,
             });
         }
     }
@@ -268,7 +271,7 @@ export function serializeClaudeResponse(result, requestModel) {
         role: "assistant",
         content,
         model: result.model ?? requestModel,
-        stop_reason: mapStopReason(result.finishReason),
+        stop_reason: mapStopReason(inferredFinishReason),
         stop_sequence: null,
         usage: {
             input_tokens: result.usage?.input ?? 0,
@@ -363,6 +366,7 @@ export function formatSSE(eventType, data) {
 export class ClaudeStreamSerializer {
     state = "idle";
     currentBlockType = null;
+    sawToolUseBlock = false;
     blockIndex = 0;
     hasOpenedBlock = false;
     outputTokens = 0;
@@ -465,15 +469,14 @@ export class ClaudeStreamSerializer {
     // Public API
     // -----------------------------------------------------------------------
     /**
-     * Emit the opening frames: message_start, ping, content_block_start (text).
-     * Automatically called on the first pushDelta if not called manually.
+     * Emit the opening frames: message_start and ping.
+     * The first actual content decides which content block opens next.
      */
     *start() {
         if (this.state !== "idle") {
             return;
         }
         yield* this.ensureMessageStarted();
-        yield* this.openBlock({ type: "text", text: "" });
     }
     /**
      * Push a text delta.  Returns zero or more SSE frames.
@@ -529,6 +532,7 @@ export class ClaudeStreamSerializer {
         if (this.state === "done" || this.state === "error") {
             return;
         }
+        this.sawToolUseBlock = true;
         yield* this.ensureMessageStarted();
         // Open a tool_use block (closes any current block)
         yield* this.openBlock({ type: "tool_use", id, name, input: "" });
@@ -562,19 +566,20 @@ export class ClaudeStreamSerializer {
     *finish(outputTokens, finishReason) {
         // If we never started (empty response), start first
         if (this.state === "idle") {
-            yield* this.start();
+            yield* this.ensureMessageStarted();
         }
         if (this.state === "done" || this.state === "error") {
             return;
         }
         this.outputTokens = outputTokens ?? this.outputTokens;
+        const resolvedFinishReason = this.sawToolUseBlock && (!finishReason || finishReason === "stop") ? "tool_use" : finishReason;
         // Close any open content block
         yield* this.closeCurrentBlock();
         // message_delta
         const messageDelta = {
             type: "message_delta",
             delta: {
-                stop_reason: mapStopReason(finishReason),
+                stop_reason: mapStopReason(resolvedFinishReason),
                 stop_sequence: null,
             },
             usage: { output_tokens: this.outputTokens },

package/dist/lib/proxy/cloaking/plugins/sessionIdentity.d.ts

@@ -3,13 +3,9 @@
  * so that Anthropic sees consistent "user" fingerprints even when requests are
  * spread across multiple accounts.
  *
- * Session IDs follow the format:
- *   user_[32 hex chars]_account_[UUIDv4]_session_[UUIDv4]
- *
- * IDs are cached with a 1-hour TTL and reused for subsequent requests from
- * the same account within that window.
+ * The generated metadata matches Claude Code's shape:
+ *   {"device_id":"<64 hex>","account_uuid":"<uuid>","session_id":"<uuid>"}
  */
 import type { CloakingPlugin } from "../../../types/index.js";
-/** Purge all expired sessions from the cache. Exported for external timer use. */
 export declare function purgeExpiredSessions(): void;
 export declare function createSessionIdentity(): CloakingPlugin;

package/dist/lib/proxy/cloaking/plugins/sessionIdentity.js

@@ -3,29 +3,12 @@
  * so that Anthropic sees consistent "user" fingerprints even when requests are
  * spread across multiple accounts.
  *
- * Session IDs follow the format:
- *   user_[32 hex chars]_account_[UUIDv4]_session_[UUIDv4]
- *
- * IDs are cached with a 1-hour TTL and reused for subsequent requests from
- * the same account within that window.
+ * The generated metadata matches Claude Code's shape:
+ *   {"device_id":"<64 hex>","account_uuid":"<uuid>","session_id":"<uuid>"}
  */
-import { randomBytes, randomUUID } from "crypto";
-// ── Session cache with TTL ───────────────────────────────────────────────────
-const TTL_MS = 3_600_000; // 1 hour
-const sessionCache = new Map();
-/** Generate a new session user ID in the required format. */
-function generateUserId() {
-    const hex = randomBytes(32).toString("hex"); // 64 hex chars, take first 32
-    return `user_${hex.slice(0, 32)}_account_${randomUUID()}_session_${randomUUID()}`;
-}
-/** Purge all expired sessions from the cache. Exported for external timer use. */
+import { getOrCreateClaudeCodeIdentity, purgeExpiredClaudeCodeIdentities, } from "../../../auth/anthropicOAuth.js";
 export function purgeExpiredSessions() {
-    const now = Date.now();
-    for (const [key, entry] of sessionCache) {
-        if (entry.expiresAt <= now) {
-            sessionCache.delete(key);
-        }
-    }
+    purgeExpiredClaudeCodeIdentities();
 }
 export function createSessionIdentity() {
     return {
@@ -34,23 +17,16 @@ export function createSessionIdentity() {
         enabled: true,
         async transformRequest(ctx) {
             const accountId = ctx.account.id;
-            const now = Date.now();
-            // Check cache first — reuse if still valid
-            let cached = sessionCache.get(accountId);
-            if (!cached || cached.expiresAt <= now) {
-                cached = {
-                    userId: generateUserId(),
-                    expiresAt: now + TTL_MS,
-                };
-                sessionCache.set(accountId, cached);
-            }
+            const identity = getOrCreateClaudeCodeIdentity(accountId, {
+                existingUserId: ctx.request.body.metadata?.user_id,
+            });
             const body = { ...ctx.request.body };
             // Only set user_id if not already present — in passthrough mode,
-            // oauthFetch.ts owns this field and sets it from its own session cache.
+            // oauthFetch.ts owns this field and sets it from the shared helper.
             if (!body.metadata?.user_id) {
                 body.metadata = {
                     ...body.metadata,
-                    user_id: cached.userId,
+                    user_id: identity.metadataUserId,
                 };
             }
             return {

package/dist/lib/proxy/modelRouter.js

@@ -15,6 +15,9 @@ export class ModelRouter {
         if (this.passthrough.has(requestedModel)) {
             return { provider: "anthropic", model: requestedModel };
         }
+        if (requestedModel.startsWith("gemini-")) {
+            return { provider: "vertex", model: requestedModel };
+        }
         if (requestedModel.startsWith("claude-")) {
             return { provider: "anthropic", model: requestedModel };
         }

package/dist/lib/proxy/oauthFetch.d.ts

@@ -20,7 +20,7 @@ export { CLAUDE_CLI_USER_AGENT, MCP_TOOL_PREFIX };
  * - Sets User-Agent to Claude CLI
  * - Adds ?beta=true query parameter to /v1/messages
  * - Injects billing header & agent block into system prompt
- * - Injects fake user ID into metadata
+ * - Injects Claude-Code-shaped user ID into metadata
  * - Adds Stainless SDK headers for fingerprint matching
  * - Disables thinking when tool_choice is forced
  *