@juspay/neurolink 9.74.0 → 9.75.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [9.75.0](https://github.com/juspay/neurolink/compare/v9.74.0...v9.75.0) (2026-06-20)
+
+### Features
+
+- **(cli):** surface tool-routing config via CLI flags ([9ad353f](https://github.com/juspay/neurolink/commit/9ad353fa98759bee21ff79b14aa08d2bacfbaf7e))
+
 ## [9.74.0](https://github.com/juspay/neurolink/compare/v9.73.0...v9.74.0) (2026-06-20)
 
 ### Features

package/dist/cli/factories/commandFactory.js

@@ -10,6 +10,7 @@ import { checkRedisAvailability } from "../../lib/utils/conversationMemory.js";
 import { normalizeEvaluationData } from "../../lib/utils/evaluationUtils.js";
 import { logger } from "../../lib/utils/logger.js";
 import { createThinkingConfigFromRecord } from "../../lib/utils/thinkingConfig.js";
+import { buildToolRoutingConfigFromCli } from "../utils/toolRoutingFlags.js";
 import { configManager } from "../commands/config.js";
 import { MCPCommandFactory } from "../commands/mcp.js";
 import { ModelsCommandFactory } from "../commands/models.js";
@@ -540,6 +541,42 @@ export class CLICommandFactory {
             description: "Thinking level for extended reasoning (Anthropic Claude, Gemini 2.5+, Gemini 3): minimal, low, medium, high",
             choices: ["minimal", "low", "medium", "high"],
         },
+        // Tool-routing options
+        toolRouting: {
+            type: "boolean",
+            description: "Enable pre-call per-turn tool routing (narrows MCP tools by relevance).",
+        },
+        toolRoutingTimeout: {
+            type: "number",
+            description: "Router LLM hard timeout in milliseconds.",
+            alias: "tool-routing-timeout",
+        },
+        toolRoutingRouterProvider: {
+            type: "string",
+            description: "Override the provider used for the router LLM call.",
+            alias: "tool-routing-router-provider",
+        },
+        toolRoutingRouterModel: {
+            type: "string",
+            description: "Override the model used for the router LLM call.",
+            alias: "tool-routing-router-model",
+        },
+        toolRoutingRouterRegion: {
+            type: "string",
+            description: "Override the region used for the router LLM call.",
+            alias: "tool-routing-router-region",
+        },
+        toolRoutingAlwaysInclude: {
+            type: "array",
+            description: "Server ids whose tools are always kept and never offered to the router (repeatable).",
+            alias: "tool-routing-always-include",
+            string: true,
+        },
+        toolRoutingServers: {
+            type: "string",
+            description: "Path to a JSON file OR inline JSON array of {id, description} server descriptors for the routable catalog.",
+            alias: "tool-routing-servers",
+        },
         region: {
             type: "string",
             description: "Vertex AI region (e.g., us-central1, europe-west1, asia-northeast1)",
@@ -821,6 +858,16 @@ export class CLICommandFactory {
             authMethod: argv.authMethod,
             subscriptionTier: argv.subscriptionTier,
             enableBeta: argv.enableBeta,
+            // Tool-routing flags — constructor-level config, not a per-call option.
+            // Passed through the options bag so handlers can inject into the SDK
+            // instance before the first getOrCreateNeuroLink() call.
+            toolRouting: argv.toolRouting,
+            toolRoutingTimeout: argv.toolRoutingTimeout,
+            toolRoutingRouterProvider: argv.toolRoutingRouterProvider,
+            toolRoutingRouterModel: argv.toolRoutingRouterModel,
+            toolRoutingRouterRegion: argv.toolRoutingRouterRegion,
+            toolRoutingAlwaysInclude: argv.toolRoutingAlwaysInclude,
+            toolRoutingServers: argv.toolRoutingServers,
         };
     }
     /**
@@ -2217,6 +2264,11 @@ export class CLICommandFactory {
                 }
                 return;
             }
+            // Inject tool-routing config into the SDK instance before constructing it.
+            const toolRoutingConfig = buildToolRoutingConfigFromCli(options);
+            if (toolRoutingConfig) {
+                globalSession.setToolRoutingConfig(toolRoutingConfig);
+            }
             // Initialize SDK and session
             const sdk = globalSession.getOrCreateNeuroLink();
             const sessionVariables = CLICommandFactory.normalizeLoopSessionVariables(globalSession.getSessionVariables());
@@ -2447,6 +2499,11 @@ export class CLICommandFactory {
      * Execute real streaming with timeout handling
      */
     static async executeRealStream(argv, options, inputText, contextMetadata) {
+        // Inject tool-routing config into the SDK instance before constructing it.
+        const toolRoutingConfig = buildToolRoutingConfigFromCli(options);
+        if (toolRoutingConfig) {
+            globalSession.setToolRoutingConfig(toolRoutingConfig);
+        }
         const sdk = globalSession.getOrCreateNeuroLink();
         const sessionVariables = CLICommandFactory.normalizeLoopSessionVariables(globalSession.getSessionVariables());
         const enhancedOptions = { ...options, ...sessionVariables };
@@ -2923,6 +2980,11 @@ export class CLICommandFactory {
                 logger.always(chalk.blue(`📦 Processing ${prompts.length} prompts...\n`));
             }
             const results = [];
+            // Inject tool-routing config into the SDK instance before constructing it.
+            const toolRoutingConfig = buildToolRoutingConfigFromCli(options);
+            if (toolRoutingConfig) {
+                globalSession.setToolRoutingConfig(toolRoutingConfig);
+            }
             const sdk = globalSession.getOrCreateNeuroLink();
             const sessionVariables = CLICommandFactory.normalizeLoopSessionVariables(globalSession.getSessionVariables());
             const enhancedOptions = { ...options, ...sessionVariables };

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

@@ -0,0 +1,20 @@
+/**
+ * CLI helper: parse --tool-routing-* flags into a ToolRoutingConfig.
+ *
+ * This module is intentionally side-effect-free so it can be unit-tested
+ * without a running NeuroLink instance.
+ */
+import type { CliToolRoutingFlags, ToolRoutingConfig } from "../../lib/types/index.js";
+/**
+ * Build a {@link ToolRoutingConfig} from the parsed CLI flags.
+ *
+ * Returns `undefined` when `--tool-routing` is absent or false, so callers
+ * can skip the setter entirely with a simple truthiness check — behaviour is
+ * identical to routing being disabled.
+ *
+ * `--tool-routing-servers` is parsed permissively:
+ * - If the value looks like an existing file path, the file is read and JSON-parsed.
+ * - Otherwise the value is treated as an inline JSON string.
+ * - On any parse error a warning is logged and `servers` is omitted (fail open).
+ */
+export declare function buildToolRoutingConfigFromCli(flags: CliToolRoutingFlags & Record<string, unknown>): ToolRoutingConfig | undefined;

package/dist/cli/utils/toolRoutingFlags.js

@@ -0,0 +1,115 @@
+/**
+ * CLI helper: parse --tool-routing-* flags into a ToolRoutingConfig.
+ *
+ * This module is intentionally side-effect-free so it can be unit-tested
+ * without a running NeuroLink instance.
+ */
+import fs from "node:fs";
+import { logger } from "../../lib/utils/logger.js";
+/**
+ * Build a {@link ToolRoutingConfig} from the parsed CLI flags.
+ *
+ * Returns `undefined` when `--tool-routing` is absent or false, so callers
+ * can skip the setter entirely with a simple truthiness check — behaviour is
+ * identical to routing being disabled.
+ *
+ * `--tool-routing-servers` is parsed permissively:
+ * - If the value looks like an existing file path, the file is read and JSON-parsed.
+ * - Otherwise the value is treated as an inline JSON string.
+ * - On any parse error a warning is logged and `servers` is omitted (fail open).
+ */
+export function buildToolRoutingConfigFromCli(flags) {
+    if (!flags.toolRouting) {
+        return undefined;
+    }
+    const config = { enabled: true };
+    if (flags.toolRoutingTimeout !== undefined) {
+        const t = flags.toolRoutingTimeout;
+        if (Number.isFinite(t) && t > 0) {
+            config.timeoutMs = t;
+        }
+        else {
+            logger.warn(`[tool-routing] --tool-routing-timeout value ${String(t)} is not a positive finite number; ignoring (SDK default applies).`);
+        }
+    }
+    const hasRouterProvider = typeof flags.toolRoutingRouterProvider === "string";
+    const hasRouterModel = typeof flags.toolRoutingRouterModel === "string";
+    const hasRouterRegion = typeof flags.toolRoutingRouterRegion === "string";
+    if (hasRouterProvider || hasRouterModel || hasRouterRegion) {
+        config.routerModel = {
+            ...(hasRouterProvider && {
+                provider: flags.toolRoutingRouterProvider,
+            }),
+            ...(hasRouterModel && {
+                model: flags.toolRoutingRouterModel,
+            }),
+            ...(hasRouterRegion && {
+                region: flags.toolRoutingRouterRegion,
+            }),
+        };
+    }
+    if (Array.isArray(flags.toolRoutingAlwaysInclude) &&
+        flags.toolRoutingAlwaysInclude.length > 0) {
+        config.alwaysIncludeServerIds = flags.toolRoutingAlwaysInclude;
+    }
+    if (typeof flags.toolRoutingServers === "string" &&
+        flags.toolRoutingServers.trim() !== "") {
+        config.servers = parseServersFlag(flags.toolRoutingServers);
+    }
+    return config;
+}
+// Trust model: --tool-routing-servers is a local, user-supplied CLI flag.
+// The invoking user already holds the process's OS permissions, so absolute
+// and home-dir config paths are fully supported — there is no cross-trust-
+// boundary to enforce.  The caps below are a robustness guard against
+// accidentally pointing at a huge file (e.g. a log or binary) that would
+// silently OOM the process or stall the CLI, not a security boundary.
+const MAX_SERVERS_INPUT_BYTES = 1_000_000; // 1 MB
+const MAX_SERVERS_ENTRIES = 1_000;
+/**
+ * Parse the `--tool-routing-servers` value.
+ *
+ * Tries file-path first (if the string exists on disk), then inline JSON.
+ * Logs a warning and returns `undefined` on any error (fail open).
+ */
+function parseServersFlag(value) {
+    try {
+        // File-path branch: resolve relative to cwd, check existence.
+        const resolved = fs.existsSync(value) ? value : null;
+        if (resolved !== null) {
+            const { size } = fs.statSync(resolved);
+            if (size > MAX_SERVERS_INPUT_BYTES) {
+                logger.warn(`[tool-routing] --tool-routing-servers file exceeds ${MAX_SERVERS_INPUT_BYTES} bytes (got ${size}); ignoring to avoid excessive memory use.`);
+                return undefined;
+            }
+        }
+        else if (Buffer.byteLength(value, "utf8") > MAX_SERVERS_INPUT_BYTES) {
+            logger.warn(`[tool-routing] --tool-routing-servers inline JSON exceeds ${MAX_SERVERS_INPUT_BYTES} bytes; ignoring to avoid excessive memory use.`);
+            return undefined;
+        }
+        const jsonText = resolved ? fs.readFileSync(resolved, "utf8") : value;
+        const parsed = JSON.parse(jsonText);
+        if (!Array.isArray(parsed)) {
+            logger.warn("[tool-routing] --tool-routing-servers must be a JSON array; ignoring.");
+            return undefined;
+        }
+        // Validate shape loosely — only keep entries with id + description strings.
+        const valid = parsed.filter((entry) => typeof entry === "object" &&
+            entry !== null &&
+            typeof entry.id === "string" &&
+            typeof entry.description === "string");
+        if (valid.length !== parsed.length) {
+            logger.warn(`[tool-routing] ${parsed.length - valid.length} server descriptor(s) skipped — each must have string "id" and "description" fields.`);
+        }
+        if (valid.length > MAX_SERVERS_ENTRIES) {
+            logger.warn(`[tool-routing] --tool-routing-servers contains ${valid.length} entries; truncating to ${MAX_SERVERS_ENTRIES} to prevent pathological inputs.`);
+            return valid.slice(0, MAX_SERVERS_ENTRIES);
+        }
+        return valid.length > 0 ? valid : undefined;
+    }
+    catch (err) {
+        logger.warn(`[tool-routing] Failed to parse --tool-routing-servers: ${err.message}. Omitting servers (fail open).`);
+        return undefined;
+    }
+}
+//# sourceMappingURL=toolRoutingFlags.js.map

package/dist/lib/session/globalSessionState.d.ts

@@ -1,8 +1,10 @@
 import { NeuroLink } from "../neurolink.js";
-import type { ConversationMemoryConfig, LoopSessionState, SessionVariableValue } from "../types/index.js";
+import type { ConversationMemoryConfig, LoopSessionState, SessionVariableValue, ToolRoutingConfig } from "../types/index.js";
 export declare class GlobalSessionManager {
     private static instance;
     private loopSession;
+    /** Optional tool-routing config set by CLI handlers before SDK construction. */
+    private _toolRoutingConfig;
     static getInstance(): GlobalSessionManager;
     setLoopSession(config?: ConversationMemoryConfig): string;
     /**
@@ -33,6 +35,13 @@ export declare class GlobalSessionManager {
     updateSessionId(newSessionId: string): void;
     getLoopSession(): LoopSessionState | null;
     clearLoopSession(): void;
+    /**
+     * Store a tool-routing config to be injected at SDK construction time.
+     * Call this BEFORE `getOrCreateNeuroLink()` inside a command handler.
+     * When a loop session is already active the config is ignored (the instance
+     * already exists).
+     */
+    setToolRoutingConfig(config: ToolRoutingConfig): void;
     getOrCreateNeuroLink(): NeuroLink;
     getCurrentSessionId(): string | undefined;
     setSessionVariable(key: string, value: SessionVariableValue): void;

package/dist/lib/session/globalSessionState.js

@@ -31,6 +31,8 @@ function buildMcpOutputLimitsFromEnv() {
 export class GlobalSessionManager {
     static instance;
     loopSession = null;
+    /** Optional tool-routing config set by CLI handlers before SDK construction. */
+    _toolRoutingConfig = undefined;
     static getInstance() {
         if (!GlobalSessionManager.instance) {
             GlobalSessionManager.instance = new GlobalSessionManager();
@@ -127,6 +129,18 @@ export class GlobalSessionManager {
             this.loopSession = null;
         }
     }
+    /**
+     * Store a tool-routing config to be injected at SDK construction time.
+     * Call this BEFORE `getOrCreateNeuroLink()` inside a command handler.
+     * When a loop session is already active the config is ignored (the instance
+     * already exists).
+     */
+    setToolRoutingConfig(config) {
+        if (this.hasActiveSession()) {
+            return;
+        }
+        this._toolRoutingConfig = config;
+    }
     getOrCreateNeuroLink() {
         const session = this.getLoopSession();
         if (session) {
@@ -142,6 +156,10 @@ export class GlobalSessionManager {
         if (mcpOutputLimits) {
             options.mcp = { outputLimits: mcpOutputLimits };
         }
+        if (this._toolRoutingConfig) {
+            options.toolRouting = this._toolRoutingConfig;
+            this._toolRoutingConfig = undefined;
+        }
         return new NeuroLink(Object.keys(options).length ? options : undefined);
     }
     getCurrentSessionId() {

package/dist/lib/types/cli.d.ts

@@ -45,7 +45,7 @@ export type BaseCommandArgs = {
 /**
  * Generate command arguments
  */
-export type GenerateCommandArgs = BaseCommandArgs & {
+export type GenerateCommandArgs = BaseCommandArgs & CliToolRoutingFlags & {
     /** Input text or prompt */
     input?: string;
     /** AI provider to use */
@@ -110,7 +110,7 @@ export type GenerateCommandArgs = BaseCommandArgs & {
 /**
  * Stream command arguments
  */
-export type StreamCommandArgs = BaseCommandArgs & {
+export type StreamCommandArgs = BaseCommandArgs & CliToolRoutingFlags & {
     /** Input text or prompt */
     input?: string;
     /** AI provider to use */
@@ -137,7 +137,7 @@ export type StreamCommandArgs = BaseCommandArgs & {
 /**
  * Batch command arguments
  */
-export type BatchCommandArgs = BaseCommandArgs & {
+export type BatchCommandArgs = BaseCommandArgs & CliToolRoutingFlags & {
     /** Input file path */
     file?: string;
     /** AI provider to use */
@@ -1500,3 +1500,29 @@ export type CliServeFlatRoute = {
     description?: string;
     group: string;
 };
+/**
+ * Raw CLI flag shape for the tool-routing family of options.
+ * Keys are camelCase as yargs delivers them after parsing kebab-case aliases.
+ */
+export type CliToolRoutingFlags = {
+    /** Master enable switch (--tool-routing). */
+    toolRouting?: boolean;
+    /** Router LLM hard timeout in ms (--tool-routing-timeout). */
+    toolRoutingTimeout?: number;
+    /** Router LLM provider override (--tool-routing-router-provider). */
+    toolRoutingRouterProvider?: string;
+    /** Router LLM model override (--tool-routing-router-model). */
+    toolRoutingRouterModel?: string;
+    /** Router LLM region override (--tool-routing-router-region). */
+    toolRoutingRouterRegion?: string;
+    /**
+     * Server ids that are always kept and never offered to the router
+     * (--tool-routing-always-include, repeatable).
+     */
+    toolRoutingAlwaysInclude?: string[];
+    /**
+     * Path to a JSON file OR inline JSON array of server descriptors
+     * (--tool-routing-servers).
+     */
+    toolRoutingServers?: string;
+};

package/dist/session/globalSessionState.d.ts

@@ -1,8 +1,10 @@
 import { NeuroLink } from "../neurolink.js";
-import type { ConversationMemoryConfig, LoopSessionState, SessionVariableValue } from "../types/index.js";
+import type { ConversationMemoryConfig, LoopSessionState, SessionVariableValue, ToolRoutingConfig } from "../types/index.js";
 export declare class GlobalSessionManager {
     private static instance;
     private loopSession;
+    /** Optional tool-routing config set by CLI handlers before SDK construction. */
+    private _toolRoutingConfig;
     static getInstance(): GlobalSessionManager;
     setLoopSession(config?: ConversationMemoryConfig): string;
     /**
@@ -33,6 +35,13 @@ export declare class GlobalSessionManager {
     updateSessionId(newSessionId: string): void;
     getLoopSession(): LoopSessionState | null;
     clearLoopSession(): void;
+    /**
+     * Store a tool-routing config to be injected at SDK construction time.
+     * Call this BEFORE `getOrCreateNeuroLink()` inside a command handler.
+     * When a loop session is already active the config is ignored (the instance
+     * already exists).
+     */
+    setToolRoutingConfig(config: ToolRoutingConfig): void;
     getOrCreateNeuroLink(): NeuroLink;
     getCurrentSessionId(): string | undefined;
     setSessionVariable(key: string, value: SessionVariableValue): void;

package/dist/session/globalSessionState.js

@@ -31,6 +31,8 @@ function buildMcpOutputLimitsFromEnv() {
 export class GlobalSessionManager {
     static instance;
     loopSession = null;
+    /** Optional tool-routing config set by CLI handlers before SDK construction. */
+    _toolRoutingConfig = undefined;
     static getInstance() {
         if (!GlobalSessionManager.instance) {
             GlobalSessionManager.instance = new GlobalSessionManager();
@@ -127,6 +129,18 @@ export class GlobalSessionManager {
             this.loopSession = null;
         }
     }
+    /**
+     * Store a tool-routing config to be injected at SDK construction time.
+     * Call this BEFORE `getOrCreateNeuroLink()` inside a command handler.
+     * When a loop session is already active the config is ignored (the instance
+     * already exists).
+     */
+    setToolRoutingConfig(config) {
+        if (this.hasActiveSession()) {
+            return;
+        }
+        this._toolRoutingConfig = config;
+    }
     getOrCreateNeuroLink() {
         const session = this.getLoopSession();
         if (session) {
@@ -142,6 +156,10 @@ export class GlobalSessionManager {
         if (mcpOutputLimits) {
             options.mcp = { outputLimits: mcpOutputLimits };
         }
+        if (this._toolRoutingConfig) {
+            options.toolRouting = this._toolRoutingConfig;
+            this._toolRoutingConfig = undefined;
+        }
         return new NeuroLink(Object.keys(options).length ? options : undefined);
     }
     getCurrentSessionId() {

package/dist/types/cli.d.ts

@@ -45,7 +45,7 @@ export type BaseCommandArgs = {
 /**
  * Generate command arguments
  */
-export type GenerateCommandArgs = BaseCommandArgs & {
+export type GenerateCommandArgs = BaseCommandArgs & CliToolRoutingFlags & {
     /** Input text or prompt */
     input?: string;
     /** AI provider to use */
@@ -110,7 +110,7 @@ export type GenerateCommandArgs = BaseCommandArgs & {
 /**
  * Stream command arguments
  */
-export type StreamCommandArgs = BaseCommandArgs & {
+export type StreamCommandArgs = BaseCommandArgs & CliToolRoutingFlags & {
     /** Input text or prompt */
     input?: string;
     /** AI provider to use */
@@ -137,7 +137,7 @@ export type StreamCommandArgs = BaseCommandArgs & {
 /**
  * Batch command arguments
  */
-export type BatchCommandArgs = BaseCommandArgs & {
+export type BatchCommandArgs = BaseCommandArgs & CliToolRoutingFlags & {
     /** Input file path */
     file?: string;
     /** AI provider to use */
@@ -1500,3 +1500,29 @@ export type CliServeFlatRoute = {
     description?: string;
     group: string;
 };
+/**
+ * Raw CLI flag shape for the tool-routing family of options.
+ * Keys are camelCase as yargs delivers them after parsing kebab-case aliases.
+ */
+export type CliToolRoutingFlags = {
+    /** Master enable switch (--tool-routing). */
+    toolRouting?: boolean;
+    /** Router LLM hard timeout in ms (--tool-routing-timeout). */
+    toolRoutingTimeout?: number;
+    /** Router LLM provider override (--tool-routing-router-provider). */
+    toolRoutingRouterProvider?: string;
+    /** Router LLM model override (--tool-routing-router-model). */
+    toolRoutingRouterModel?: string;
+    /** Router LLM region override (--tool-routing-router-region). */
+    toolRoutingRouterRegion?: string;
+    /**
+     * Server ids that are always kept and never offered to the router
+     * (--tool-routing-always-include, repeatable).
+     */
+    toolRoutingAlwaysInclude?: string[];
+    /**
+     * Path to a JSON file OR inline JSON array of server descriptors
+     * (--tool-routing-servers).
+     */
+    toolRoutingServers?: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.74.0",
+  "version": "9.75.0",
   "packageManager": "pnpm@10.15.1",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, voice (TTS/STT/realtime), and professional CLI. 58+ external MCP servers discoverable, multimodal file processing, RAG pipelines. Build, test, and deploy AI applications with 21+ providers: OpenAI, Anthropic, Google AI Studio, Google Vertex, AWS Bedrock, Azure OpenAI, Mistral, LiteLLM, SageMaker, Hugging Face, Ollama, OpenAI-compatible, OpenRouter, DeepSeek, NVIDIA NIM, LM Studio, llama.cpp, plus voice (OpenAI TTS, ElevenLabs, Deepgram, Azure Speech).",
   "author": {
@@ -118,11 +118,13 @@
     "test:autoresearch": "npx tsx test/continuous-test-suite-autoresearch.ts",
     "test:autoresearch:redis": "npx tsx test/continuous-test-suite-autoresearch-redis.ts",
     "test:envguard": "npx tsx test/helpers/envGuard.test.ts",
+    "test:tool-routing-cli:vitest": "pnpm exec vitest run test/toolRoutingCli.test.ts",
+    "test:tool-routing-cli": "pnpm run test:tool-routing-cli:vitest && npx tsx test/continuous-test-suite-tool-routing-cli.ts",
     "test:ci": "pnpm run test && pnpm run test:client && pnpm run test:hitl",
     "// CI tier — fast, no live AI calls, safe for every commit": "",
     "test:unit:vitest": "pnpm exec vitest run test/toolRouting.test.ts",
     "test:tool-routing": "pnpm run test:unit:vitest && npx tsx test/continuous-test-suite-tool-routing.ts",
-    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:autoresearch:redis && pnpm run test:unit:vitest",
+    "test:unit": "pnpm run test:envguard && pnpm run test:bugfixes && pnpm run test:mcp:infra && pnpm run test:mcp:bash && pnpm run test:mcp:limits && pnpm run test:mcp:spans && pnpm run test:autoresearch:redis && pnpm run test:unit:vitest && pnpm run test:tool-routing-cli:vitest",
     "// CI tier — live providers, runs only when API keys are present (test:credentials and test:dynamic make real provider calls when keys are set, so they live here, not in test:unit)": "",
     "test:live": "pnpm run test:providers && pnpm run test:mcp:http && pnpm run test:mcp:sdk && pnpm run test:mcp:cli && pnpm run test:observability && pnpm run test:context && pnpm run test:memory && pnpm run test:tool-reliability && pnpm run test:evaluation && pnpm run test:autoresearch && pnpm run test:credentials && pnpm run test:dynamic",
     "// CI tier — product output (image/video/TTS/PPT) — costs $$ per run": "",