@juspay/neurolink 9.41.0 → 9.42.1

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
@@ -278,6 +279,16 @@ export class OpenAIProvider extends BaseProvider {
             // Build message array from options with multimodal support
             // Using protected helper from BaseProvider to eliminate code duplication
             const messages = await this.buildMessagesForStream(options);
+            let resolvedToolChoice = resolveToolChoice(options, tools, shouldUseTools);
+            // Guard: if toolChoice names a specific tool that was filtered out, fall back to "auto"
+            if (resolvedToolChoice !== null &&
+                typeof resolvedToolChoice === "object" &&
+                "toolName" in resolvedToolChoice &&
+                typeof resolvedToolChoice.toolName === "string" &&
+                !tools[resolvedToolChoice.toolName]) {
+                logger.warn(`OpenAI: toolChoice references tool "${resolvedToolChoice.toolName}" which was removed during filtering; falling back to "auto"`);
+                resolvedToolChoice = "auto";
+            }
             // Debug the actual request being sent to OpenAI
             logger.debug(`OpenAI: streamText request parameters:`, {
                 modelName: this.modelName,
@@ -285,7 +296,7 @@ export class OpenAIProvider extends BaseProvider {
                 temperature: options.temperature,
                 maxTokens: options.maxTokens,
                 toolsCount: Object.keys(tools).length,
-                toolChoice: shouldUseTools && Object.keys(tools).length > 0 ? "auto" : "none",
+                toolChoice: resolvedToolChoice,
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 firstToolExample: Object.keys(tools).length > 0
                     ? {
@@ -314,7 +325,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: resolvedToolChoice,
                     abortSignal: composeAbortSignals(options.abortSignal, timeoutController?.controller.signal),
                     experimental_telemetry: this.telemetryHandler.getTelemetryConfig(options),
                     onStepFinish: ({ toolCalls, toolResults }) => {
@@ -381,150 +392,14 @@ export class OpenAIProvider extends BaseProvider {
                 hasToolResults: !!result.toolResults,
                 resultType: typeof result,
             });
-            // Transform string stream to content object stream using fullStream
-            const transformedStream = async function* () {
-                try {
-                    logger.debug(`OpenAI: Starting stream transformation`, {
-                        hasTextStream: !!result.textStream,
-                        hasFullStream: !!result.fullStream,
-                        resultKeys: Object.keys(result),
-                        toolsEnabled: shouldUseTools,
-                        toolsCount: Object.keys(tools).length,
-                    });
-                    let chunkCount = 0;
-                    let contentYielded = 0;
-                    // Try fullStream first (handles both text and tool calls), fallback to textStream
-                    const streamToUse = result.fullStream || result.textStream;
-                    if (!streamToUse) {
-                        logger.error("OpenAI: No stream available in result", {
-                            resultKeys: Object.keys(result),
-                        });
-                        return;
-                    }
-                    logger.debug(`OpenAI: Stream source selected:`, {
-                        usingFullStream: !!result.fullStream,
-                        usingTextStream: !!result.textStream && !result.fullStream,
-                        streamSourceType: result.fullStream ? "fullStream" : "textStream",
-                    });
-                    for await (const chunk of streamToUse) {
-                        chunkCount++;
-                        logger.debug(`OpenAI: Processing chunk ${chunkCount}:`, {
-                            chunkType: typeof chunk,
-                            chunkValue: typeof chunk === "string"
-                                ? chunk.substring(0, 50)
-                                : "not-string",
-                            chunkKeys: chunk && typeof chunk === "object"
-                                ? Object.keys(chunk)
-                                : "not-object",
-                            hasText: chunk && typeof chunk === "object" && "text" in chunk,
-                            hasTextDelta: chunk && typeof chunk === "object" && "textDelta" in chunk,
-                            hasType: chunk && typeof chunk === "object" && "type" in chunk,
-                            chunkTypeValue: chunk && typeof chunk === "object" && "type" in chunk
-                                ? chunk.type
-                                : "no-type",
-                        });
-                        let contentToYield = null;
-                        // Handle different chunk types from fullStream
-                        if (chunk && typeof chunk === "object") {
-                            // Log the full chunk structure for debugging (debug mode only)
-                            if (process.env.NEUROLINK_DEBUG === "true") {
-                                logger.debug(`OpenAI: Full chunk structure:`, {
-                                    chunkKeys: Object.keys(chunk),
-                                    fullChunk: JSON.stringify(chunk).substring(0, 500),
-                                });
-                            }
-                            if ("type" in chunk && chunk.type === "error") {
-                                // Handle error chunks when tools are enabled
-                                const errorChunk = chunk;
-                                logger.error(`OpenAI: Error chunk received:`, {
-                                    errorType: errorChunk.type,
-                                    errorDetails: errorChunk.error,
-                                    fullChunk: JSON.stringify(chunk),
-                                });
-                                // Throw a more descriptive error for tool-related issues
-                                const errorMessage = errorChunk.error &&
-                                    typeof errorChunk.error === "object" &&
-                                    "message" in errorChunk.error
-                                    ? String(errorChunk.error.message)
-                                    : "OpenAI API error when tools are enabled";
-                                throw new Error(`OpenAI streaming error with tools: ${errorMessage}. Try disabling tools with --disableTools`);
-                            }
-                            else if ("type" in chunk &&
-                                chunk.type === "text-delta" &&
-                                "textDelta" in chunk) {
-                                // Text delta from fullStream
-                                contentToYield = chunk.textDelta;
-                                logger.debug(`OpenAI: Found text-delta:`, {
-                                    textDelta: contentToYield,
-                                });
-                            }
-                            else if ("text" in chunk) {
-                                // Direct text chunk
-                                contentToYield = chunk.text;
-                                logger.debug(`OpenAI: Found direct text:`, {
-                                    text: contentToYield,
-                                });
-                            }
-                            else {
-                                // Log unhandled chunks in debug mode only
-                                if (process.env.NEUROLINK_DEBUG === "true") {
-                                    logger.debug(`OpenAI: Unhandled object chunk:`, {
-                                        chunkKeys: Object.keys(chunk),
-                                        chunkType: chunk.type || "no-type",
-                                        fullChunk: JSON.stringify(chunk).substring(0, 500),
-                                    });
-                                }
-                            }
-                        }
-                        else if (typeof chunk === "string") {
-                            // Direct string chunk from textStream
-                            contentToYield = chunk;
-                            logger.debug(`OpenAI: Found string chunk:`, {
-                                content: contentToYield,
-                            });
-                        }
-                        else {
-                            logger.warn(`OpenAI: Unhandled chunk type:`, {
-                                type: typeof chunk,
-                                value: String(chunk).substring(0, 100),
-                            });
-                        }
-                        if (contentToYield) {
-                            contentYielded++;
-                            logger.debug(`OpenAI: Yielding content ${contentYielded}:`, {
-                                content: contentToYield.substring(0, 50),
-                                length: contentToYield.length,
-                            });
-                            yield { content: contentToYield };
-                        }
-                    }
-                    logger.debug(`OpenAI: Stream transformation completed`, {
-                        totalChunks: chunkCount,
-                        contentYielded,
-                        success: contentYielded > 0,
-                    });
-                    if (contentYielded === 0) {
-                        logger.warn(`OpenAI: No content was yielded from stream despite processing ${chunkCount} chunks`);
-                    }
-                }
-                catch (streamError) {
-                    // AI SDK v6 throws NoOutputGeneratedError when the stream produced no output.
-                    // Treat as an empty stream rather than crashing with an unhandled rejection.
-                    if (NoOutputGeneratedError.isInstance(streamError)) {
-                        logger.warn("OpenAI: Stream produced no output (NoOutputGeneratedError)");
-                        return;
-                    }
-                    logger.error(`OpenAI: Stream transformation error:`, streamError);
-                    throw streamError;
-                }
-            };
+            const transformedStream = this.createOpenAITransformedStream(result, shouldUseTools, tools);
             // Create analytics promise that resolves after stream completion
             const analyticsPromise = streamAnalyticsCollector.createAnalytics(this.providerName, this.modelName, result, Date.now() - startTime, {
                 requestId: `openai-stream-${Date.now()}`,
                 streamingMode: true,
             });
             return {
-                stream: transformedStream(),
+                stream: transformedStream,
                 provider: this.providerName,
                 model: this.modelName,
                 analytics: analyticsPromise,
@@ -539,6 +414,131 @@ export class OpenAIProvider extends BaseProvider {
             throw this.handleProviderError(error);
         }
     }
+    async *createOpenAITransformedStream(result, shouldUseTools, tools) {
+        try {
+            logger.debug(`OpenAI: Starting stream transformation`, {
+                hasTextStream: !!result.textStream,
+                hasFullStream: !!result.fullStream,
+                resultKeys: Object.keys(result),
+                toolsEnabled: shouldUseTools,
+                toolsCount: Object.keys(tools).length,
+            });
+            let chunkCount = 0;
+            let contentYielded = 0;
+            const streamToUse = result.fullStream || result.textStream;
+            if (!streamToUse) {
+                logger.error("OpenAI: No stream available in result", {
+                    resultKeys: Object.keys(result),
+                });
+                return;
+            }
+            logger.debug(`OpenAI: Stream source selected:`, {
+                usingFullStream: !!result.fullStream,
+                usingTextStream: !!result.textStream && !result.fullStream,
+                streamSourceType: result.fullStream ? "fullStream" : "textStream",
+            });
+            for await (const chunk of streamToUse) {
+                chunkCount++;
+                logger.debug(`OpenAI: Processing chunk ${chunkCount}:`, {
+                    chunkType: typeof chunk,
+                    chunkValue: typeof chunk === "string"
+                        ? chunk.substring(0, 50)
+                        : "not-string",
+                    chunkKeys: chunk && typeof chunk === "object"
+                        ? Object.keys(chunk)
+                        : "not-object",
+                    hasText: chunk && typeof chunk === "object" && "text" in chunk,
+                    hasTextDelta: chunk && typeof chunk === "object" && "textDelta" in chunk,
+                    hasType: chunk && typeof chunk === "object" && "type" in chunk,
+                    chunkTypeValue: chunk && typeof chunk === "object" && "type" in chunk
+                        ? chunk.type
+                        : "no-type",
+                });
+                const contentToYield = this.extractOpenAIChunkContent(chunk);
+                if (contentToYield) {
+                    contentYielded++;
+                    logger.debug(`OpenAI: Yielding content ${contentYielded}:`, {
+                        content: contentToYield.substring(0, 50),
+                        length: contentToYield.length,
+                    });
+                    yield { content: contentToYield };
+                }
+            }
+            logger.debug(`OpenAI: Stream transformation completed`, {
+                totalChunks: chunkCount,
+                contentYielded,
+                success: contentYielded > 0,
+            });
+            if (contentYielded === 0) {
+                logger.warn(`OpenAI: No content was yielded from stream despite processing ${chunkCount} chunks`);
+            }
+        }
+        catch (streamError) {
+            if (NoOutputGeneratedError.isInstance(streamError)) {
+                logger.warn("OpenAI: Stream produced no output (NoOutputGeneratedError)");
+                return;
+            }
+            logger.error(`OpenAI: Stream transformation error:`, streamError);
+            throw streamError;
+        }
+    }
+    extractOpenAIChunkContent(chunk) {
+        if (chunk && typeof chunk === "object") {
+            if (process.env.NEUROLINK_DEBUG === "true") {
+                logger.debug(`OpenAI: Full chunk structure:`, {
+                    chunkKeys: Object.keys(chunk),
+                    fullChunk: JSON.stringify(chunk).substring(0, 500),
+                });
+            }
+            if ("type" in chunk && chunk.type === "error") {
+                const errorChunk = chunk;
+                logger.error(`OpenAI: Error chunk received:`, {
+                    errorType: errorChunk.type,
+                    errorDetails: errorChunk.error,
+                    fullChunk: JSON.stringify(chunk),
+                });
+                const errorMessage = errorChunk.error &&
+                    typeof errorChunk.error === "object" &&
+                    "message" in errorChunk.error
+                    ? String(errorChunk.error.message)
+                    : "OpenAI API error when tools are enabled";
+                throw new Error(`OpenAI streaming error with tools: ${errorMessage}. Try disabling tools with --disableTools`);
+            }
+            if ("type" in chunk &&
+                chunk.type === "text-delta" &&
+                "textDelta" in chunk) {
+                const textDelta = chunk.textDelta;
+                logger.debug(`OpenAI: Found text-delta:`, { textDelta });
+                return textDelta;
+            }
+            if ("text" in chunk) {
+                const text = chunk.text;
+                logger.debug(`OpenAI: Found direct text:`, { text });
+                return text;
+            }
+            if (process.env.NEUROLINK_DEBUG === "true") {
+                logger.debug(`OpenAI: Unhandled object chunk:`, {
+                    chunkKeys: Object.keys(chunk),
+                    chunkType: "type" in chunk
+                        ? String(chunk.type)
+                        : "no-type",
+                    fullChunk: JSON.stringify(chunk).substring(0, 500),
+                });
+            }
+            return null;
+        }
+        if (typeof chunk === "string") {
+            logger.debug(`OpenAI: Found string chunk:`, {
+                content: chunk,
+            });
+            return chunk;
+        }
+        logger.warn(`OpenAI: Unhandled chunk type:`, {
+            type: typeof chunk,
+            value: String(chunk).substring(0, 100),
+        });
+        return null;
+    }
     /**
      * Generate embeddings for text using OpenAI text-embedding models
      * @param text - The text to embed

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
 // ---------------------------------------------------------------------------
@@ -148,13 +148,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 ---
@@ -239,6 +239,11 @@ 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 +255,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 +277,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 +372,7 @@ export function formatSSE(eventType, data) {
 export class ClaudeStreamSerializer {
     state = "idle";
     currentBlockType = null;
+    sawToolUseBlock = false;
     blockIndex = 0;
     hasOpenedBlock = false;
     outputTokens = 0;
@@ -465,15 +475,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 +538,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 +572,22 @@ 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
  *