@juspay/neurolink 9.51.1 → 9.51.3

package/dist/cli/factories/commandFactory.js

@@ -19,6 +19,7 @@ import { LoopSession } from "../loop/session.js";
 import { initializeCliParser } from "../parser.js";
 import { formatFileSize, saveAudioToFile } from "../utils/audioFileUtils.js";
 import { resolveFilePaths } from "../utils/pathResolver.js";
+import { animatedWrite } from "../utils/typewriter.js";
 import { formatVideoFileSize, getVideoMetadataSummary, saveVideoToFile, } from "../utils/videoFileUtils.js";
 import { OllamaCommandFactory } from "./ollamaCommandFactory.js";
 import { SageMakerCommandFactory } from "./sagemakerCommandFactory.js";
@@ -1995,7 +1996,7 @@ export class CLICommandFactory {
         ];
         let fullContent = "";
         for (const chunk of chunks) {
-            process.stdout.write(chunk);
+            await animatedWrite(chunk);
             fullContent += chunk;
             await new Promise((resolve) => setTimeout(resolve, 50)); // Simulate streaming delay
         }
@@ -2247,7 +2248,7 @@ export class CLICommandFactory {
                         "string");
                 };
                 if (isText(evt)) {
-                    process.stdout.write(evt.content);
+                    await animatedWrite(evt.content);
                     fullContent += evt.content;
                 }
                 else if (isAudio(evt)) {

package/dist/cli/utils/typewriter.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Typewriter animation for CLI streaming output.
+ * Writes text character-by-character with a configurable delay.
+ * @module cli/utils/typewriter
+ */
+/**
+ * Write text to stdout with a per-character typewriter animation.
+ * Falls back to raw write when delay is 0 or negative.
+ */
+export declare function typewriterWrite(text: string, delayMs?: number): Promise<void>;
+/** Whether typewriter animation should be used for the current process. */
+export declare function shouldAnimate(): boolean;
+/**
+ * Write text to stdout with animation when stdout is a TTY, otherwise
+ * fall back to a raw write. Use this from CLI streaming code paths to
+ * keep the behaviour consistent in one place.
+ */
+export declare function animatedWrite(text: string): Promise<void>;

package/dist/cli/utils/typewriter.js

@@ -0,0 +1,42 @@
+/**
+ * Typewriter animation for CLI streaming output.
+ * Writes text character-by-character with a configurable delay.
+ * @module cli/utils/typewriter
+ */
+const DEFAULT_CHAR_DELAY_MS = 8;
+/**
+ * Write text to stdout with a per-character typewriter animation.
+ * Falls back to raw write when delay is 0 or negative.
+ */
+export async function typewriterWrite(text, delayMs = DEFAULT_CHAR_DELAY_MS) {
+    if (!text) {
+        return;
+    }
+    if (delayMs <= 0) {
+        process.stdout.write(text);
+        return;
+    }
+    // Use Array.from to handle surrogate pairs / emoji correctly
+    for (const ch of Array.from(text)) {
+        process.stdout.write(ch);
+        await new Promise((r) => setTimeout(r, delayMs));
+    }
+}
+/** Whether typewriter animation should be used for the current process. */
+export function shouldAnimate() {
+    return Boolean(process.stdout.isTTY);
+}
+/**
+ * Write text to stdout with animation when stdout is a TTY, otherwise
+ * fall back to a raw write. Use this from CLI streaming code paths to
+ * keep the behaviour consistent in one place.
+ */
+export async function animatedWrite(text) {
+    if (shouldAnimate()) {
+        await typewriterWrite(text);
+    }
+    else {
+        process.stdout.write(text);
+    }
+}
+//# sourceMappingURL=typewriter.js.map

package/dist/core/modules/ToolsManager.d.ts

@@ -31,6 +31,16 @@ export declare class ToolsManager {
     protected sessionId?: string;
     protected userId?: string;
     constructor(providerName: AIProviderName, directTools: Record<string, unknown>, neurolink?: NeuroLink | undefined, utilities?: ToolUtilities | undefined);
+    /**
+     * BZ-666: Wrap tool execute with output truncation to prevent
+     * context overflow when large results flow into the AI SDK accumulator.
+     */
+    private wrapExecuteWithTruncation;
+    /**
+     * BZ-666: Apply generateToolOutputPreview to tool results to prevent
+     * context overflow when large results flow into the AI SDK accumulator.
+     */
+    private truncateToolResult;
     /**
      * Set session context for MCP tools
      */

package/dist/core/modules/ToolsManager.js

@@ -22,6 +22,7 @@ import { SpanStatusCode } from "@opentelemetry/api";
 import { logger } from "../../utils/logger.js";
 import { getKeyCount } from "../../utils/transformationUtils.js";
 import { convertJsonSchemaToZod } from "../../utils/schemaConversion.js";
+import { generateToolOutputPreview } from "../../context/toolOutputLimits.js";
 /**
  * ToolsManager class - Handles all tool management operations
  */
@@ -44,6 +45,79 @@ export class ToolsManager {
         this.utilities = utilities;
         this.mcpTools = {};
     }
+    /**
+     * BZ-666: Wrap tool execute with output truncation to prevent
+     * context overflow when large results flow into the AI SDK accumulator.
+     */
+    wrapExecuteWithTruncation(toolName, originalExecute) {
+        return async (params) => {
+            const result = await originalExecute(params);
+            return this.truncateToolResult(toolName, result);
+        };
+    }
+    /**
+     * BZ-666: Apply generateToolOutputPreview to tool results to prevent
+     * context overflow when large results flow into the AI SDK accumulator.
+     */
+    truncateToolResult(toolName, result) {
+        if (result === null || result === undefined) {
+            return result;
+        }
+        // Handle string results directly
+        if (typeof result === "string") {
+            const { preview, truncated, originalSize } = generateToolOutputPreview(result);
+            if (truncated) {
+                logger.debug(`[ToolsManager] Truncated '${toolName}' string output: ${originalSize} bytes → ${Buffer.byteLength(preview, "utf-8")} bytes`);
+            }
+            return truncated ? preview : result;
+        }
+        // Handle object results (e.g. readFile returns { content, ... })
+        if (typeof result === "object") {
+            const obj = result;
+            let nextObj = null;
+            // Truncate "content" if present and oversized
+            if (typeof obj.content === "string") {
+                const { preview, truncated, originalSize } = generateToolOutputPreview(obj.content);
+                if (truncated) {
+                    logger.debug(`[ToolsManager] Truncated '${toolName}' content field: ${originalSize} bytes → ${Buffer.byteLength(preview, "utf-8")} bytes`);
+                    nextObj = { ...(nextObj ?? obj), content: preview };
+                }
+            }
+            // Truncate "data" if present and oversized — both fields can coexist
+            if (typeof obj.data === "string") {
+                const { preview, truncated, originalSize } = generateToolOutputPreview(obj.data);
+                if (truncated) {
+                    logger.debug(`[ToolsManager] Truncated '${toolName}' data field: ${originalSize} bytes → ${Buffer.byteLength(preview, "utf-8")} bytes`);
+                    nextObj = { ...(nextObj ?? obj), data: preview };
+                }
+            }
+            if (nextObj) {
+                return nextObj;
+            }
+            // For other objects, check if their JSON serialization is too large.
+            // Use UTF-8 byte length, not string length, to match the 50KB budget.
+            try {
+                const jsonStr = JSON.stringify(result);
+                if (Buffer.byteLength(jsonStr, "utf-8") > 51_200) {
+                    const { preview, truncated, originalSize } = generateToolOutputPreview(jsonStr);
+                    if (truncated) {
+                        logger.debug(`[ToolsManager] Truncated '${toolName}' JSON output: ${originalSize} bytes → ${Buffer.byteLength(preview, "utf-8")} bytes`);
+                        // Preserve object shape so callers reading structured fields don't
+                        // get a type surprise. Attach the preview under a sentinel field.
+                        return {
+                            _truncated: true,
+                            _originalSize: originalSize,
+                            _preview: preview,
+                        };
+                    }
+                }
+            }
+            catch {
+                // JSON serialization failed — return as-is
+            }
+        }
+        return result;
+    }
     /**
      * Set session context for MCP tools
      */
@@ -179,14 +253,15 @@ export class ToolsManager {
                 typeof directTool === "object" &&
                 "execute" in directTool) {
                 const originalExecute = directTool.execute;
-                // Create a new tool with wrapped execute function
+                // Create a new tool with wrapped execute function (BZ-666/BZ-664 guards applied)
+                const guardedExecute = this.wrapExecuteWithTruncation(toolName, originalExecute);
                 tools[toolName] = {
                     ...directTool,
                     execute: async (params) => {
                         const startTime = Date.now();
                         this.emitToolEvent("tool:start", toolName, { input: params });
                         try {
-                            const result = await originalExecute(params);
+                            const result = await guardedExecute(params);
                             this.emitToolEvent("tool:end", toolName, {
                                 result,
                                 success: true,
@@ -228,6 +303,12 @@ export class ToolsManager {
             if (toolInfo && typeof toolInfo.execute === "function") {
                 const tool = await this.createCustomToolFromDefinition(toolName, toolInfo);
                 if (tool && !tools[toolName]) {
+                    // BZ-666/BZ-664: Wrap custom tool execute with guards
+                    const origExec = tool.execute;
+                    if (origExec) {
+                        const guarded = this.wrapExecuteWithTruncation(toolName, origExec);
+                        tool.execute = guarded;
+                    }
                     tools[toolName] = tool;
                 }
             }
@@ -444,47 +525,42 @@ export class ToolsManager {
                     ? this.utilities.createPermissiveZodSchema()
                     : z.object({});
             }
+            // BZ-666/BZ-664: Wrap the raw MCP execute with guards before event wrapping
+            const rawExecute = async (params) => {
+                if (this.neurolink &&
+                    typeof this.neurolink.executeExternalMCPTool === "function") {
+                    return this.neurolink.executeExternalMCPTool(tool.serverId || "unknown", tool.name, params);
+                }
+                throw new Error(`Cannot execute external MCP tool: NeuroLink executeExternalMCPTool not available`);
+            };
+            const guardedExecute = this.wrapExecuteWithTruncation(tool.name, rawExecute);
             return createAISDKTool({
                 description: tool.description || `External MCP tool ${tool.name}`,
                 inputSchema: finalSchema, // AI SDK v6 uses inputSchema (not parameters)
                 execute: async (params) => {
                     const startTime = Date.now();
                     this.emitToolEvent("tool:start", tool.name, { input: params });
-                    // Execute via NeuroLink's direct tool execution
-                    if (this.neurolink &&
-                        typeof this.neurolink.executeExternalMCPTool === "function") {
-                        try {
-                            const result = await this.neurolink.executeExternalMCPTool(tool.serverId || "unknown", tool.name, params);
-                            this.emitToolEvent("tool:end", tool.name, {
-                                result,
-                                success: true,
-                                responseTime: Date.now() - startTime,
-                            });
-                            return result;
-                        }
-                        catch (mcpError) {
-                            const errorMsg = mcpError instanceof Error ? mcpError.message : String(mcpError);
-                            this.emitToolEvent("tool:end", tool.name, {
-                                error: errorMsg,
-                                success: false,
-                                responseTime: Date.now() - startTime,
-                            });
-                            logger.error(`External MCP tool failed: ${tool.name}`, {
-                                serverId: tool.serverId,
-                                error: errorMsg,
-                            });
-                            throw mcpError;
-                        }
+                    try {
+                        const result = await guardedExecute(params);
+                        this.emitToolEvent("tool:end", tool.name, {
+                            result,
+                            success: true,
+                            responseTime: Date.now() - startTime,
+                        });
+                        return result;
                     }
-                    else {
-                        const error = `Cannot execute external MCP tool: NeuroLink executeExternalMCPTool not available`;
+                    catch (mcpError) {
+                        const errorMsg = mcpError instanceof Error ? mcpError.message : String(mcpError);
                         this.emitToolEvent("tool:end", tool.name, {
-                            error,
+                            error: errorMsg,
                             success: false,
                             responseTime: Date.now() - startTime,
                         });
-                        logger.error(error);
-                        throw new Error(error);
+                        logger.error(`External MCP tool failed: ${tool.name}`, {
+                            serverId: tool.serverId,
+                            error: errorMsg,
+                        });
+                        throw mcpError;
                     }
                 },
             });

package/dist/lib/core/modules/ToolsManager.d.ts

@@ -31,6 +31,16 @@ export declare class ToolsManager {
     protected sessionId?: string;
     protected userId?: string;
     constructor(providerName: AIProviderName, directTools: Record<string, unknown>, neurolink?: NeuroLink | undefined, utilities?: ToolUtilities | undefined);
+    /**
+     * BZ-666: Wrap tool execute with output truncation to prevent
+     * context overflow when large results flow into the AI SDK accumulator.
+     */
+    private wrapExecuteWithTruncation;
+    /**
+     * BZ-666: Apply generateToolOutputPreview to tool results to prevent
+     * context overflow when large results flow into the AI SDK accumulator.
+     */
+    private truncateToolResult;
     /**
      * Set session context for MCP tools
      */

package/dist/lib/core/modules/ToolsManager.js

@@ -22,6 +22,7 @@ import { SpanStatusCode } from "@opentelemetry/api";
 import { logger } from "../../utils/logger.js";
 import { getKeyCount } from "../../utils/transformationUtils.js";
 import { convertJsonSchemaToZod } from "../../utils/schemaConversion.js";
+import { generateToolOutputPreview } from "../../context/toolOutputLimits.js";
 /**
  * ToolsManager class - Handles all tool management operations
  */
@@ -44,6 +45,79 @@ export class ToolsManager {
         this.utilities = utilities;
         this.mcpTools = {};
     }
+    /**
+     * BZ-666: Wrap tool execute with output truncation to prevent
+     * context overflow when large results flow into the AI SDK accumulator.
+     */
+    wrapExecuteWithTruncation(toolName, originalExecute) {
+        return async (params) => {
+            const result = await originalExecute(params);
+            return this.truncateToolResult(toolName, result);
+        };
+    }
+    /**
+     * BZ-666: Apply generateToolOutputPreview to tool results to prevent
+     * context overflow when large results flow into the AI SDK accumulator.
+     */
+    truncateToolResult(toolName, result) {
+        if (result === null || result === undefined) {
+            return result;
+        }
+        // Handle string results directly
+        if (typeof result === "string") {
+            const { preview, truncated, originalSize } = generateToolOutputPreview(result);
+            if (truncated) {
+                logger.debug(`[ToolsManager] Truncated '${toolName}' string output: ${originalSize} bytes → ${Buffer.byteLength(preview, "utf-8")} bytes`);
+            }
+            return truncated ? preview : result;
+        }
+        // Handle object results (e.g. readFile returns { content, ... })
+        if (typeof result === "object") {
+            const obj = result;
+            let nextObj = null;
+            // Truncate "content" if present and oversized
+            if (typeof obj.content === "string") {
+                const { preview, truncated, originalSize } = generateToolOutputPreview(obj.content);
+                if (truncated) {
+                    logger.debug(`[ToolsManager] Truncated '${toolName}' content field: ${originalSize} bytes → ${Buffer.byteLength(preview, "utf-8")} bytes`);
+                    nextObj = { ...(nextObj ?? obj), content: preview };
+                }
+            }
+            // Truncate "data" if present and oversized — both fields can coexist
+            if (typeof obj.data === "string") {
+                const { preview, truncated, originalSize } = generateToolOutputPreview(obj.data);
+                if (truncated) {
+                    logger.debug(`[ToolsManager] Truncated '${toolName}' data field: ${originalSize} bytes → ${Buffer.byteLength(preview, "utf-8")} bytes`);
+                    nextObj = { ...(nextObj ?? obj), data: preview };
+                }
+            }
+            if (nextObj) {
+                return nextObj;
+            }
+            // For other objects, check if their JSON serialization is too large.
+            // Use UTF-8 byte length, not string length, to match the 50KB budget.
+            try {
+                const jsonStr = JSON.stringify(result);
+                if (Buffer.byteLength(jsonStr, "utf-8") > 51_200) {
+                    const { preview, truncated, originalSize } = generateToolOutputPreview(jsonStr);
+                    if (truncated) {
+                        logger.debug(`[ToolsManager] Truncated '${toolName}' JSON output: ${originalSize} bytes → ${Buffer.byteLength(preview, "utf-8")} bytes`);
+                        // Preserve object shape so callers reading structured fields don't
+                        // get a type surprise. Attach the preview under a sentinel field.
+                        return {
+                            _truncated: true,
+                            _originalSize: originalSize,
+                            _preview: preview,
+                        };
+                    }
+                }
+            }
+            catch {
+                // JSON serialization failed — return as-is
+            }
+        }
+        return result;
+    }
     /**
      * Set session context for MCP tools
      */
@@ -179,14 +253,15 @@ export class ToolsManager {
                 typeof directTool === "object" &&
                 "execute" in directTool) {
                 const originalExecute = directTool.execute;
-                // Create a new tool with wrapped execute function
+                // Create a new tool with wrapped execute function (BZ-666/BZ-664 guards applied)
+                const guardedExecute = this.wrapExecuteWithTruncation(toolName, originalExecute);
                 tools[toolName] = {
                     ...directTool,
                     execute: async (params) => {
                         const startTime = Date.now();
                         this.emitToolEvent("tool:start", toolName, { input: params });
                         try {
-                            const result = await originalExecute(params);
+                            const result = await guardedExecute(params);
                             this.emitToolEvent("tool:end", toolName, {
                                 result,
                                 success: true,
@@ -228,6 +303,12 @@ export class ToolsManager {
             if (toolInfo && typeof toolInfo.execute === "function") {
                 const tool = await this.createCustomToolFromDefinition(toolName, toolInfo);
                 if (tool && !tools[toolName]) {
+                    // BZ-666/BZ-664: Wrap custom tool execute with guards
+                    const origExec = tool.execute;
+                    if (origExec) {
+                        const guarded = this.wrapExecuteWithTruncation(toolName, origExec);
+                        tool.execute = guarded;
+                    }
                     tools[toolName] = tool;
                 }
             }
@@ -444,47 +525,42 @@ export class ToolsManager {
                     ? this.utilities.createPermissiveZodSchema()
                     : z.object({});
             }
+            // BZ-666/BZ-664: Wrap the raw MCP execute with guards before event wrapping
+            const rawExecute = async (params) => {
+                if (this.neurolink &&
+                    typeof this.neurolink.executeExternalMCPTool === "function") {
+                    return this.neurolink.executeExternalMCPTool(tool.serverId || "unknown", tool.name, params);
+                }
+                throw new Error(`Cannot execute external MCP tool: NeuroLink executeExternalMCPTool not available`);
+            };
+            const guardedExecute = this.wrapExecuteWithTruncation(tool.name, rawExecute);
             return createAISDKTool({
                 description: tool.description || `External MCP tool ${tool.name}`,
                 inputSchema: finalSchema, // AI SDK v6 uses inputSchema (not parameters)
                 execute: async (params) => {
                     const startTime = Date.now();
                     this.emitToolEvent("tool:start", tool.name, { input: params });
-                    // Execute via NeuroLink's direct tool execution
-                    if (this.neurolink &&
-                        typeof this.neurolink.executeExternalMCPTool === "function") {
-                        try {
-                            const result = await this.neurolink.executeExternalMCPTool(tool.serverId || "unknown", tool.name, params);
-                            this.emitToolEvent("tool:end", tool.name, {
-                                result,
-                                success: true,
-                                responseTime: Date.now() - startTime,
-                            });
-                            return result;
-                        }
-                        catch (mcpError) {
-                            const errorMsg = mcpError instanceof Error ? mcpError.message : String(mcpError);
-                            this.emitToolEvent("tool:end", tool.name, {
-                                error: errorMsg,
-                                success: false,
-                                responseTime: Date.now() - startTime,
-                            });
-                            logger.error(`External MCP tool failed: ${tool.name}`, {
-                                serverId: tool.serverId,
-                                error: errorMsg,
-                            });
-                            throw mcpError;
-                        }
+                    try {
+                        const result = await guardedExecute(params);
+                        this.emitToolEvent("tool:end", tool.name, {
+                            result,
+                            success: true,
+                            responseTime: Date.now() - startTime,
+                        });
+                        return result;
                     }
-                    else {
-                        const error = `Cannot execute external MCP tool: NeuroLink executeExternalMCPTool not available`;
+                    catch (mcpError) {
+                        const errorMsg = mcpError instanceof Error ? mcpError.message : String(mcpError);
                         this.emitToolEvent("tool:end", tool.name, {
-                            error,
+                            error: errorMsg,
                             success: false,
                             responseTime: Date.now() - startTime,
                         });
-                        logger.error(error);
-                        throw new Error(error);
+                        logger.error(`External MCP tool failed: ${tool.name}`, {
+                            serverId: tool.serverId,
+                            error: errorMsg,
+                        });
+                        throw mcpError;
                     }
                 },
             });

package/dist/lib/neurolink.js

@@ -775,17 +775,18 @@ export class NeuroLink {
     initializeMCPEnhancements(config) {
         const mcpConfig = config?.mcp;
         this.mcpEnhancementsConfig = mcpConfig;
-        // ToolCache — disabled by default, opt-in
-        if (mcpConfig?.cache?.enabled) {
+        // BZ-664: ToolCache — enabled by default to prevent duplicate tool calls.
+        // Callers can explicitly opt out via mcp.cache.enabled = false.
+        if (mcpConfig?.cache?.enabled !== false) {
             this.mcpToolResultCache = new ToolResultCache({
-                ttl: mcpConfig.cache.ttl ?? 300_000,
-                maxSize: mcpConfig.cache.maxSize ?? 500,
-                strategy: mcpConfig.cache.strategy ?? "lru",
+                ttl: mcpConfig?.cache?.ttl ?? 300_000,
+                maxSize: mcpConfig?.cache?.maxSize ?? 500,
+                strategy: mcpConfig?.cache?.strategy ?? "lru",
             });
             logger.debug("[NeuroLink] MCP tool result cache initialized", {
-                ttl: mcpConfig.cache.ttl ?? 300_000,
-                maxSize: mcpConfig.cache.maxSize ?? 500,
-                strategy: mcpConfig.cache.strategy ?? "lru",
+                ttl: mcpConfig?.cache?.ttl ?? 300_000,
+                maxSize: mcpConfig?.cache?.maxSize ?? 500,
+                strategy: mcpConfig?.cache?.strategy ?? "lru",
             });
         }
         // ToolCallBatcher — disabled by default, opt-in
@@ -7628,7 +7629,36 @@ Current user's request: ${currentInput}`;
     async executeExternalMCPTool(serverId, toolName, parameters, options) {
         try {
             mcpLogger.debug(`[NeuroLink] Executing external MCP tool: ${toolName} on ${serverId}`);
+            // BZ-664: Check existing ToolResultCache before executing to avoid
+            // duplicate identical calls within the same session.
+            //
+            // Safety guards aligned with executeToolInternal():
+            // - Skip destructive tools (destructiveHint annotation)
+            // - Scope cache key by serverId (two servers can expose same tool name)
+            //   and toolExecutionContext (prevents cross-session/user leaks)
+            const toolAnnotations = this.getToolAnnotationsForExecution(toolName);
+            const cacheEnabled = !!this.mcpToolResultCache &&
+                !this._disableToolCacheForCurrentRequest &&
+                !toolAnnotations?.destructiveHint;
+            const cacheKeyArgs = {
+                __serverId: serverId,
+                __args: parameters,
+                ...(this.toolExecutionContext
+                    ? { __ctx: this.toolExecutionContext }
+                    : {}),
+            };
+            if (cacheEnabled && this.mcpToolResultCache) {
+                const cached = this.mcpToolResultCache.getCachedResult(toolName, cacheKeyArgs);
+                if (cached !== undefined) {
+                    mcpLogger.debug(`[NeuroLink] Tool result cache HIT: ${toolName} on ${serverId}`);
+                    return cached;
+                }
+            }
             const result = await this.externalServerManager.executeTool(serverId, toolName, parameters, options);
+            // BZ-664: Store result in cache after successful execution
+            if (cacheEnabled && this.mcpToolResultCache) {
+                this.mcpToolResultCache.cacheResult(toolName, cacheKeyArgs, result);
+            }
             mcpLogger.debug(`[NeuroLink] External MCP tool executed successfully: ${toolName}`);
             return result;
         }

package/dist/lib/providers/anthropic.js

@@ -4,7 +4,7 @@ import { stepCountIs, streamText } from "ai";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync, } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-import { ANTHROPIC_TOKEN_URL, CLAUDE_CLI_USER_AGENT, CLAUDE_CODE_CLIENT_ID, } from "../auth/anthropicOAuth.js";
+import { ANTHROPIC_TOKEN_URL, CLAUDE_CLI_USER_AGENT, CLAUDE_CODE_CLIENT_ID, CLAUDE_CODE_OAUTH_BETAS, } from "../auth/anthropicOAuth.js";
 import { AnthropicModels, TOKEN_EXPIRY_BUFFER_MS, } from "../constants/enums.js";
 import { BaseProvider } from "../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../core/constants.js";
@@ -310,6 +310,9 @@ export class AnthropicProvider extends BaseProvider {
             anthropic = createAnthropic({
                 apiKey: apiKeyToUse,
                 headers,
+                ...(process.env.ANTHROPIC_BASE_URL && {
+                    baseURL: process.env.ANTHROPIC_BASE_URL,
+                }),
                 fetch: createProxyFetch(),
             });
             logger.debug("Anthropic Provider initialized with API key", {
@@ -354,9 +357,23 @@ export class AnthropicProvider extends BaseProvider {
      */
     getAuthHeaders() {
         const headers = {};
-        // Add beta headers if enabled
+        // When routing through proxy (ANTHROPIC_BASE_URL set), use the full
+        // OAuth beta set so the proxy forwards them upstream. Without these,
+        // Anthropic treats the request with tighter non-subscription rate limits.
+        const usingProxy = !!process.env.ANTHROPIC_BASE_URL;
         if (this.enableBetaFeatures) {
-            headers["anthropic-beta"] = ANTHROPIC_BETA_HEADERS["anthropic-beta"];
+            if (usingProxy) {
+                headers["anthropic-beta"] = [
+                    ...CLAUDE_CODE_OAUTH_BETAS,
+                    "fine-grained-tool-streaming-2025-05-14",
+                    "context-1m-2025-08-07",
+                    "interleaved-thinking-2025-05-14",
+                    "redact-thinking-2026-02-12",
+                ].join(",");
+            }
+            else {
+                headers["anthropic-beta"] = ANTHROPIC_BETA_HEADERS["anthropic-beta"];
+            }
         }
         // Add subscription-specific headers if applicable
         if (this.subscriptionTier !== "api") {

package/dist/lib/proxy/routingPolicy.js

@@ -2,7 +2,7 @@ const STREAMING_CONVERSATIONAL_TOOL_THRESHOLD = 4;
 const STRONG_TOOL_FIDELITY_THRESHOLD = 8;
 const HIGH_TOOL_COUNT_THRESHOLD = 24;
 const DEFAULT_COOLDOWN_FLOOR_MS = 1_000;
-const HIGH_TOOL_COUNT_COOLDOWN_FLOOR_MS = 120_000;
+const HIGH_TOOL_COUNT_COOLDOWN_FLOOR_MS = 10_000;
 const HIGH_FIDELITY_COOLDOWN_FLOOR_MS = 300_000;
 export function inferClaudeProxyModelTier(modelName) {
     const normalized = modelName.toLowerCase();
@@ -221,10 +221,15 @@ export function applyRateLimitCooldownScope(args) {
     const rcBackoffLevels = args.state.requestClassBackoffLevels ?? {};
     const mtBackoffLevels = args.state.modelTierBackoffLevels ?? {};
     const scopedBackoffLevel = Math.max(rcBackoffLevels[requestClassKey] ?? 0, mtBackoffLevels[modelTierKey] ?? 0);
-    const floorMs = args.profile.modelTier === "opus" || args.profile.requiresStrongToolFidelity
-        ? HIGH_FIDELITY_COOLDOWN_FLOOR_MS
-        : args.profile.isHighToolCountNonStream
-            ? HIGH_TOOL_COUNT_COOLDOWN_FLOOR_MS
+    // High-tool-count-non-stream gets its own (lower) floor so that requests
+    // recover faster once proper OAuth betas are forwarded. Check it first
+    // because every >=24-tool request also satisfies requiresStrongToolFidelity
+    // (threshold 8), which would otherwise shadow this branch.
+    const floorMs = args.profile.isHighToolCountNonStream
+        ? HIGH_TOOL_COUNT_COOLDOWN_FLOOR_MS
+        : args.profile.modelTier === "opus" ||
+            args.profile.requiresStrongToolFidelity
+            ? HIGH_FIDELITY_COOLDOWN_FLOOR_MS
             : DEFAULT_COOLDOWN_FLOOR_MS;
     const baseCooldownMs = Math.max(args.retryAfterMs ?? 0, floorMs);
     const backoffMs = Math.min(baseCooldownMs * 2 ** scopedBackoffLevel, args.capMs);