@juspay/neurolink 12.9.5 → 12.10.0

package/dist/types/artifact.d.ts

@@ -7,6 +7,7 @@
  *
  * @module types/artifactTypes
  */
+import type { RedisStorageConfig } from "./conversation.js";
 /** Metadata recorded alongside a stored artifact. */
 export type ArtifactMeta = {
     /** Tool name that produced the output. */
@@ -83,10 +84,63 @@ export type ArtifactPageRequest = {
     limit?: number;
 };
 /**
- * Pluggable storage contract for externalized MCP tool outputs.
+ * One window of an artifact, as returned by `ArtifactStore.retrieveRange` or
+ * by the shared reader when the store only supports whole-payload reads.
  *
- * Default backend: LocalTempArtifactStore (filesystem, single-process).
- * Future backends can implement this interface for S3, Redis blobs, etc.
+ * Offsets and lengths are CHARACTERS (UTF-16 code units, the unit
+ * `String.prototype.slice` and `retrieve_context`'s `offset` / `limit` use),
+ * never bytes — so a model advancing `offset` by the characters it received
+ * lands exactly where the previous window ended.
+ */
+export type ArtifactWindow = {
+    /** The characters in `[offset, offset + content.length)`. */
+    content: string;
+    /** Character offset this window starts at. */
+    offset: number;
+    /** Total character length of the whole payload. */
+    totalLength: number;
+};
+/** One hit from a literal search over an artifact. */
+export type ArtifactSearchMatch = {
+    /** Character offset of the match — pass it back as `offset` to read there. */
+    offset: number;
+    /** 1-based line number the match sits on. */
+    line: number;
+    /** Character offset the snippet starts at (≤ `offset`). */
+    snippetOffset: number;
+    /**
+     * Bounded context around the match. Bounded on purpose: an MCP artifact is
+     * usually one compact JSON line, so "the matching line" would be the whole
+     * payload.
+     */
+    snippet: string;
+};
+/** Result of a literal search over an artifact. */
+export type ArtifactSearchResult = {
+    /** Matches returned, in payload order. */
+    matches: ArtifactSearchMatch[];
+    /** `matches.length`. */
+    matchCount: number;
+    /** Every match in the payload, including the ones not returned. */
+    totalMatches: number;
+    /** True when `totalMatches > matchCount`. */
+    truncated: boolean;
+    /** Character offset to pass as `offset` to search for the next matches. */
+    nextSearchOffset?: number;
+};
+/**
+ * Pluggable storage contract for externalized MCP tool outputs and banked
+ * payloads.
+ *
+ * Shipped backends: `LocalTempArtifactStore` (filesystem, per-process index
+ * with a cross-process sidecar) and `RedisArtifactStore` (TTL-expired, shared
+ * across replicas, range reads). Pick one with `artifacts.storage` or the
+ * `STORAGE_TYPE` environment variable, or inject any implementation via
+ * `artifacts.store` / `setArtifactStore()`.
+ *
+ * Only `store`, `retrieve`, `delete`, `cleanup` and `generatePreview` are
+ * required. `retrieveRange` and `close` are optional capabilities: NeuroLink
+ * uses them when present and falls back cleanly when absent.
  */
 export type ArtifactStore = {
     /**
@@ -100,6 +154,22 @@ export type ArtifactStore = {
      * Returns `null` if the artifact is not found or has been cleaned up.
      */
     retrieve(id: string): Promise<string | null>;
+    /**
+     * Retrieve one character window without materialising the whole payload.
+     *
+     * Optional. When present, `retrieve_context` and `readArtifact` call it for
+     * every paged read instead of `retrieve()` + slice, so a backend with native
+     * range reads (Redis `GETRANGE`, S3 `Range`) moves only the window. The
+     * result carries `totalLength` so `hasMore` never needs the payload.
+     *
+     * `offset` and `limit` are characters. A backend that can only address
+     * bytes must either know the payload is single-byte (ASCII) or fall back to
+     * a full read and slice — it must never return a window that starts at the
+     * wrong character. `limit` omitted means "to the end".
+     *
+     * Returns `null` if the artifact is not found or has expired.
+     */
+    retrieveRange?(id: string, range: ArtifactPageRequest): Promise<ArtifactWindow | null>;
     /** Delete a single artifact. No-op if the ID does not exist. */
     delete(id: string): Promise<void>;
     /**
@@ -109,6 +179,13 @@ export type ArtifactStore = {
     cleanup(olderThanMs: number): Promise<number>;
     /** Generate a short preview string from a serialized payload. */
     generatePreview(payload: string): string;
+    /**
+     * Release whatever the store holds open (a pooled connection, a file
+     * handle). Optional. NeuroLink calls it — from `shutdown()`, and when
+     * `setArtifactStore()` replaces the store — only for stores it built
+     * itself; a store you inject is yours to close.
+     */
+    close?(): Promise<void>;
 };
 /**
  * In-memory index row tracked by LocalTempArtifactStore.
@@ -122,3 +199,47 @@ export type IndexEntry = ArtifactMeta & {
      */
     rehydrated?: boolean;
 };
+/**
+ * Where artifacts live. Mirrors conversation memory's `STORAGE_TYPE`:
+ *  - "local"  OS temp directory, per-process index with a cross-process
+ *             sidecar. Fine for one machine; artifacts do not survive a pod.
+ *  - "redis"  Shared across replicas, expired by TTL, range reads via
+ *             `GETRANGE`. Uses the same connection pool as Redis conversation
+ *             memory.
+ */
+export type ArtifactStorageType = "local" | "redis";
+/**
+ * Artifact storage configuration (`new NeuroLink({ artifacts })`).
+ *
+ * Resolution order for the backend: `store` → `storage` → `STORAGE_TYPE`
+ * environment variable → `"local"`. Resolution order for the Redis connection:
+ * `redisConfig` → `conversationMemory.redisConfig` → `REDIS_URL` / `REDIS_HOST`
+ * environment variables — so a deployment already running conversation memory
+ * on Redis keeps its artifacts on the same Redis without new settings.
+ */
+export type ArtifactStorageConfig = {
+    /** Backend to use. Default: `STORAGE_TYPE` env var, else `"local"`. */
+    storage?: ArtifactStorageType;
+    /**
+     * Redis connection for `storage: "redis"`. `keyPrefix` defaults to
+     * `neurolink:artifact:` (NOT the conversation prefix). `ttl` is seconds,
+     * must be positive, and defaults to 86400; zero or negative is replaced by
+     * the default with a warning — artifacts in Redis always expire.
+     * `userSessionsKeyPrefix` is ignored.
+     */
+    redisConfig?: RedisStorageConfig;
+    /**
+     * A ready-made backend. Wins over `storage`. Use this for S3, a database,
+     * or a wrapped store; `setArtifactStore()` does the same after construction.
+     */
+    store?: ArtifactStore;
+};
+/**
+ * What `RedisArtifactStore` keeps beside each payload. `charLength` is what
+ * makes range reads honest: when it equals `sizeBytes` the payload is pure
+ * ASCII and a byte range IS a character range.
+ */
+export type RedisArtifactRecord = ArtifactMeta & {
+    /** `payload.length` at store time — characters, not bytes. */
+    charLength: number;
+};

package/dist/types/config.d.ts

@@ -6,6 +6,7 @@ import type { MCPToolRegistry } from "../mcp/toolRegistry.js";
 import type { TaskManagerConfig } from "./task.js";
 import type { HITLConfig } from "../types/hitl.js";
 import type { ConversationMemoryConfig } from "./conversation.js";
+import type { ArtifactStorageConfig } from "./artifact.js";
 import type { ObservabilityConfig } from "./observability.js";
 import type { AuthProvider, AuthProviderType, AuthProviderConfig, Auth0Config, ClerkConfig, FirebaseConfig, SupabaseConfig, WorkOSConfig, BetterAuthConfig, JWTConfig, OAuth2Config, CognitoConfig, KeycloakConfig, AuthenticatedContext } from "./auth.js";
 import type { NeurolinkCredentials } from "./providers.js";
@@ -61,6 +62,12 @@ export type NeurolinkConstructorConfig = {
     modelAliasConfig?: ModelAliasConfig;
     /** MCP enhancement modules configuration (cache, router, batcher, annotations, middleware) */
     mcp?: MCPEnhancementsConfig;
+    /**
+     * Artifact storage: where externalized MCP tool outputs and banked payloads
+     * live. The backend follows `STORAGE_TYPE` exactly like conversation memory
+     * unless chosen here. See {@link ArtifactStorageConfig}.
+     */
+    artifacts?: ArtifactStorageConfig;
     /** Authentication provider configuration */
     auth?: NeuroLinkAuthConfig;
     /** TaskManager configuration (scheduled and self-running tasks) */

package/dist/types/mcp.d.ts

@@ -422,6 +422,22 @@ export type ToolDiscoveryResult = {
     /** Server ID */
     serverId: string;
 };
+/**
+ * Outcome of matching a possibly-misspelled tool name against a list of
+ * available tool names (see `resolveToolName` in
+ * src/lib/utils/toolCallRepair.ts). Shared between the AI-SDK generation-path
+ * repair (`experimental_repairToolCall`) and direct MCP execution boundaries
+ * (`NeuroLink.executeExternalMCPTool`) so both recover from the same class of
+ * near-miss the same way.
+ */
+export type ToolNameResolution = {
+    /** The resolved, available tool name. */
+    name: string;
+    /** Which strategy produced the match, in the order they are attempted. */
+    strategy: "case" | "substring" | "levenshtein";
+    /** Normalized Levenshtein distance (0–1) — only set when strategy is "levenshtein". */
+    score?: number;
+};
 /**
  * External MCP tool execution options
  * Moved from src/lib/mcp/toolDiscoveryService.ts

package/dist/utils/redis.d.ts

@@ -3,6 +3,21 @@
  * Helper functions for Redis storage operations
  */
 import type { ChatMessage, RedisClient, RedisConversationObject, RedisStorageConfig } from "../types/index.js";
+/**
+ * Redact the userinfo of every `scheme://user:pass@host` in `text`.
+ *
+ * Deliberately not a regex. `/:\/\/[^@]+@/` and its relatives backtrack
+ * quadratically on input with many `://` and no `@` (CodeQL
+ * js/polynomial-redos), and the URL here can come straight from a caller —
+ * `RedisStorageConfig.url` reaches this through `RedisArtifactStore` and the
+ * conversation memory manager. One forward pass, every character visited a
+ * bounded number of times.
+ *
+ * Redacts everything before the LAST `@` of the authority, so a password
+ * containing `@` is still hidden. A URL with only a user name is redacted
+ * too; the old regexes let that through.
+ */
+export declare function redactUrlCredentials(text: string): string;
 /**
  * Get a pooled Redis connection. Multiple callers with the same host:port:db
  * share a single connection, reducing connection count.

package/dist/utils/redis.js

@@ -6,17 +6,75 @@ import { randomUUID } from "crypto";
 import { createClient } from "redis";
 import { logger } from "./logger.js";
 const SESSION_ONLY_PREFIX = "session-only:";
+/** Characters that end the authority (`user:pass@host:port`) of a URL in text. */
+const AUTHORITY_TERMINATORS = new Set(["/", "?", "#", " ", "\t", "\n", "\r"]);
+/**
+ * Redact the userinfo of every `scheme://user:pass@host` in `text`.
+ *
+ * Deliberately not a regex. `/:\/\/[^@]+@/` and its relatives backtrack
+ * quadratically on input with many `://` and no `@` (CodeQL
+ * js/polynomial-redos), and the URL here can come straight from a caller —
+ * `RedisStorageConfig.url` reaches this through `RedisArtifactStore` and the
+ * conversation memory manager. One forward pass, every character visited a
+ * bounded number of times.
+ *
+ * Redacts everything before the LAST `@` of the authority, so a password
+ * containing `@` is still hidden. A URL with only a user name is redacted
+ * too; the old regexes let that through.
+ */
+export function redactUrlCredentials(text) {
+    let out = "";
+    let cursor = 0;
+    for (;;) {
+        const schemeEnd = text.indexOf("://", cursor);
+        if (schemeEnd === -1) {
+            return out + text.slice(cursor);
+        }
+        const authorityStart = schemeEnd + 3;
+        let authorityEnd = authorityStart;
+        let lastAt = -1;
+        while (authorityEnd < text.length) {
+            const ch = text[authorityEnd];
+            if (AUTHORITY_TERMINATORS.has(ch)) {
+                break;
+            }
+            if (ch === "@") {
+                lastAt = authorityEnd;
+            }
+            authorityEnd += 1;
+        }
+        if (lastAt === -1) {
+            out += text.slice(cursor, authorityEnd);
+            cursor = authorityEnd;
+        }
+        else {
+            out += `${text.slice(cursor, authorityStart)}[redacted]@`;
+            cursor = lastAt + 1;
+        }
+    }
+}
 // Connection pool - keyed by host:port:db
 const connectionPool = new Map();
 const pendingConnections = new Map();
+/**
+ * One pool key per distinct connection. Shared by acquire AND release: they
+ * used to compute it separately, and the release side never knew about the
+ * `url:` form, so a URL-configured client was acquired under one key and
+ * "released" under another that did not exist — its reference count never
+ * dropped and the connection outlived every owner. Credentials never appear
+ * in the key; it is logged.
+ */
+function poolKeyFor(config) {
+    return config.url
+        ? `url:${redactUrlCredentials(config.url)}`
+        : `${config.host}:${config.port}:${config.db}:${config.password ? "auth" : "noauth"}`;
+}
 /**
  * Get a pooled Redis connection. Multiple callers with the same host:port:db
  * share a single connection, reducing connection count.
  */
 export async function getPooledRedisClient(config) {
-    const key = config.url
-        ? `url:${config.url.replace(/:\/\/[^:]+:[^@]+@/, "://[redacted]@")}`
-        : `${config.host}:${config.port}:${config.db}:${config.password ? "auth" : "noauth"}`;
+    const key = poolKeyFor(config);
     const existing = connectionPool.get(key);
     if (existing && existing.client.isOpen) {
         existing.refCount++;
@@ -77,7 +135,7 @@ export async function getPooledRedisClient(config) {
  * Release a pooled Redis connection. Only closes when refCount reaches 0.
  */
 export async function releasePooledRedisClient(config) {
-    const key = `${config.host}:${config.port}:${config.db}:${config.password ? "auth" : "noauth"}`;
+    const key = poolKeyFor(config);
     const entry = connectionPool.get(key);
     if (!entry) {
         return;
@@ -140,7 +198,7 @@ export async function createRedisClient(config) {
     // Create client with secured options
     const client = createClient(clientOptions);
     client.on("error", (err) => {
-        const sanitizedMessage = err.message.replace(/redis:\/\/.*?@/g, "redis://[redacted]@");
+        const sanitizedMessage = redactUrlCredentials(err.message);
         logger.error("Redis client error", { error: sanitizedMessage });
     });
     client.on("connect", () => {
@@ -420,7 +478,7 @@ export function getNormalizedConfig(config) {
                 : 0;
         }
         catch (e) {
-            const sanitizedUrl = url.replace(/:\/\/[^@]+@/, "://[redacted]@");
+            const sanitizedUrl = redactUrlCredentials(url);
             logger.warn("[redisUtils] Failed to parse Redis URL, falling back to component-based connection", {
                 url: sanitizedUrl,
                 error: e instanceof Error ? e.message : String(e),

package/dist/utils/toolCallRepair.d.ts

@@ -1,9 +1,51 @@
 import type { ToolCallRepairFunction, ToolSet } from "../types/index.js";
+import type { ToolNameResolution } from "../types/index.js";
 /**
  * Create an `experimental_repairToolCall` handler for streamText/generateText.
  * Fully dynamic — reads the tool schema at repair time, no configuration needed.
  */
 export declare function createToolCallRepair(): ToolCallRepairFunction<ToolSet>;
+/**
+ * Match a possibly-misspelled tool name against a list of available tool
+ * names. Strategies (in order): case-insensitive exact → unambiguous
+ * substring → Levenshtein.
+ *
+ * Pulled out of `repairToolName` so the same matching policy can be reused
+ * outside the AI-SDK generation loop — `experimental_repairToolCall` only
+ * runs inside `streamText`/`generateText`, so a name typo at a direct MCP
+ * execution boundary (`NeuroLink.executeExternalMCPTool`) previously had no
+ * recovery at all. This function is pure name-matching: no `LanguageModelV3ToolCall`,
+ * no logging, so callers with a different call shape can reuse it directly.
+ */
+export declare function resolveToolName(calledName: string, availableTools: string[]): ToolNameResolution | null;
+/**
+ * Rank every available tool name by similarity to `calledName` (ascending
+ * normalized Levenshtein distance) and return the closest `limit`.
+ *
+ * Used to build the candidate list on `ExternalMcpToolNotFoundError` when
+ * `resolveToolName` found no unambiguous match — unlike `resolveToolName`,
+ * this makes no accept/reject judgment, it just orders what is available so
+ * a caller (human or AI) can pick the right name themselves.
+ */
+export declare function rankToolNameCandidates(calledName: string, availableTools: string[], limit?: number): string[];
+/**
+ * Thrown at a direct MCP execution boundary (`NeuroLink.executeExternalMCPTool`)
+ * when `resolveToolName` cannot find an unambiguous match for a requested
+ * tool name against a server's discovered tools. Distinct from the plain
+ * `Error` that `ToolDiscoveryService.executeTool` throws deeper in the stack
+ * for the same condition, so callers can distinguish "no match — here are
+ * the closest names" from every other execution failure programmatically,
+ * instead of parsing a message string.
+ */
+export declare class ExternalMcpToolNotFoundError extends Error {
+    /** The tool name that was requested and could not be resolved. */
+    readonly requestedName: string;
+    /** The server the tool was requested against. */
+    readonly serverId: string;
+    /** Closest available tool names on that server, capped (see `rankToolNameCandidates`). */
+    readonly candidates: string[];
+    constructor(requestedName: string, serverId: string, candidates: string[]);
+}
 /**
  * Coerce a value to match the expected schema type.
  * Handles: string→number, JSON string→object, JSON string→array, value→[value].

package/dist/utils/toolCallRepair.js

@@ -25,31 +25,36 @@ export function createToolCallRepair() {
 }
 // ─── Tool Name Repair ──────────────────────────────────────────────
 /**
- * Attempt to match a wrong tool name against available tool names.
- * Strategies (in order): case-insensitive exact → substring → Levenshtein.
+ * Match a possibly-misspelled tool name against a list of available tool
+ * names. Strategies (in order): case-insensitive exact → unambiguous
+ * substring → Levenshtein.
+ *
+ * Pulled out of `repairToolName` so the same matching policy can be reused
+ * outside the AI-SDK generation loop — `experimental_repairToolCall` only
+ * runs inside `streamText`/`generateText`, so a name typo at a direct MCP
+ * execution boundary (`NeuroLink.executeExternalMCPTool`) previously had no
+ * recovery at all. This function is pure name-matching: no `LanguageModelV3ToolCall`,
+ * no logging, so callers with a different call shape can reuse it directly.
  */
-function repairToolName(toolCall, availableTools) {
-    const called = toolCall.toolName;
+export function resolveToolName(calledName, availableTools) {
     // Guard: empty or whitespace-only tool name cannot be meaningfully repaired
-    if (!called || called.trim().length === 0) {
+    if (!calledName || calledName.trim().length === 0) {
         return null;
     }
     // 1. Case-insensitive exact match
-    const ciMatch = availableTools.find((t) => t.toLowerCase() === called.toLowerCase());
+    const ciMatch = availableTools.find((t) => t.toLowerCase() === calledName.toLowerCase());
     if (ciMatch) {
-        logger.debug(`[ToolCallRepair] Name repair (case): "${called}" → "${ciMatch}"`);
-        return { ...toolCall, toolName: ciMatch };
+        return { name: ciMatch, strategy: "case" };
     }
     // 2. Substring match: "search_file" is substring of "search_files" or vice versa.
     // Only accept when exactly one tool matches to avoid ambiguous repairs.
-    const calledLower = called.toLowerCase();
+    const calledLower = calledName.toLowerCase();
     const subCandidates = availableTools.filter((t) => {
         const tLower = t.toLowerCase();
         return tLower.includes(calledLower) || calledLower.includes(tLower);
     });
     if (subCandidates.length === 1) {
-        logger.debug(`[ToolCallRepair] Name repair (substring): "${called}" → "${subCandidates[0]}"`);
-        return { ...toolCall, toolName: subCandidates[0] };
+        return { name: subCandidates[0], strategy: "substring" };
     }
     // 3. Levenshtein distance — accept if normalized distance < 0.3
     // Compare by normalized score (not raw edits) so length differences don't skew selection.
@@ -57,7 +62,7 @@ function repairToolName(toolCall, availableTools) {
     let bestNormalized = Infinity;
     for (const t of availableTools) {
         const dist = levenshtein(calledLower, t.toLowerCase());
-        const maxLen = Math.max(called.length, t.length);
+        const maxLen = Math.max(calledName.length, t.length);
         const normalized = maxLen === 0 ? 0 : dist / maxLen;
         if (normalized < 0.3 && normalized < bestNormalized) {
             bestNormalized = normalized;
@@ -65,12 +70,70 @@ function repairToolName(toolCall, availableTools) {
         }
     }
     if (bestMatch) {
-        logger.debug(`[ToolCallRepair] Name repair (levenshtein ${bestNormalized.toFixed(2)}): "${called}" → "${bestMatch}"`);
-        return { ...toolCall, toolName: bestMatch };
+        return { name: bestMatch, strategy: "levenshtein", score: bestNormalized };
     }
-    logger.debug(`[ToolCallRepair] Could not repair tool name "${called}". Available: [${availableTools.join(", ")}]`);
     return null;
 }
+/**
+ * Rank every available tool name by similarity to `calledName` (ascending
+ * normalized Levenshtein distance) and return the closest `limit`.
+ *
+ * Used to build the candidate list on `ExternalMcpToolNotFoundError` when
+ * `resolveToolName` found no unambiguous match — unlike `resolveToolName`,
+ * this makes no accept/reject judgment, it just orders what is available so
+ * a caller (human or AI) can pick the right name themselves.
+ */
+export function rankToolNameCandidates(calledName, availableTools, limit = 5) {
+    const calledLower = calledName.toLowerCase();
+    return [...availableTools]
+        .sort((a, b) => levenshtein(calledLower, a.toLowerCase()) -
+        levenshtein(calledLower, b.toLowerCase()))
+        .slice(0, limit);
+}
+/**
+ * Thrown at a direct MCP execution boundary (`NeuroLink.executeExternalMCPTool`)
+ * when `resolveToolName` cannot find an unambiguous match for a requested
+ * tool name against a server's discovered tools. Distinct from the plain
+ * `Error` that `ToolDiscoveryService.executeTool` throws deeper in the stack
+ * for the same condition, so callers can distinguish "no match — here are
+ * the closest names" from every other execution failure programmatically,
+ * instead of parsing a message string.
+ */
+export class ExternalMcpToolNotFoundError extends Error {
+    /** The tool name that was requested and could not be resolved. */
+    requestedName;
+    /** The server the tool was requested against. */
+    serverId;
+    /** Closest available tool names on that server, capped (see `rankToolNameCandidates`). */
+    candidates;
+    constructor(requestedName, serverId, candidates) {
+        const candidateList = candidates.length > 0 ? candidates.join(", ") : "(none registered)";
+        super(`Tool '${requestedName}' not found for server '${serverId}'. Closest available: ${candidateList}`);
+        this.name = "ExternalMcpToolNotFoundError";
+        this.requestedName = requestedName;
+        this.serverId = serverId;
+        this.candidates = candidates;
+    }
+}
+/**
+ * Attempt to match a wrong tool name against available tool names and
+ * produce a repaired `LanguageModelV3ToolCall` for the AI-SDK generation
+ * path. Thin wrapper around `resolveToolName` that restores this function's
+ * original debug-log wording so generation-path behaviour is unchanged.
+ */
+function repairToolName(toolCall, availableTools) {
+    const called = toolCall.toolName;
+    const resolution = resolveToolName(called, availableTools);
+    if (!resolution) {
+        logger.debug(`[ToolCallRepair] Could not repair tool name "${called}". Available: [${availableTools.join(", ")}]`);
+        return null;
+    }
+    const label = resolution.strategy === "levenshtein"
+        ? `levenshtein ${resolution.score.toFixed(2)}`
+        : resolution.strategy;
+    logger.debug(`[ToolCallRepair] Name repair (${label}): "${called}" → "${resolution.name}"`);
+    return { ...toolCall, toolName: resolution.name };
+}
 // ─── Tool Input Repair ─────────────────────────────────────────────
 /**
  * Attempt to repair wrong parameter names and types using the JSON schema.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "12.9.5",
+  "version": "12.10.0",
   "packageManager": "pnpm@10.15.1",
   "description": "TypeScript AI SDK with 24+ LLM providers behind one consistent API. MCP-native (connect any MCP server), voice TTS/STT/realtime, RAG, agents, memory, context compaction. OpenAI · Anthropic · Gemini · Bedrock · Azure · Ollama · DeepSeek · NVIDIA NIM and more.",
   "author": {
@@ -86,6 +86,7 @@
     "test:mcp:sdk": "pnpm exec tsx test/continuous-test-suite-mcp-sdk.ts",
     "test:mcp:cli": "pnpm exec tsx test/continuous-test-suite-mcp-cli.ts",
     "test:mcp:stdio-lifecycle": "pnpm exec tsx test/continuous-test-suite-mcp-stdio-lifecycle.ts",
+    "test:mcp-direct-name-repair": "pnpm exec tsx test/continuous-test-suite-mcp-direct-name-repair.ts",
     "test:mcp:full": "pnpm run test:mcp:infra && pnpm run test:mcp:spans && pnpm run test:mcp:stdio-lifecycle && pnpm run test:mcp:sdk && pnpm run test:mcp:cli && pnpm run test:mcp:http",
     "test:media": "pnpm exec tsx test/continuous-test-suite-media-gen.ts",
     "test:media-registry-collisions": "pnpm exec tsx test/continuous-test-suite-media-registry-collisions.ts",
@@ -154,7 +155,7 @@
     "// CI tier — fast, no live AI calls, safe for every commit (test:unit; also see the separate provider-safety-net CI job, which runs build + test:providers-mocked + test:provider-structure + test:error-classifier-contract on every PR)": "",
     "test:tool-routing": "pnpm exec tsx test/continuous-test-suite-tool-routing.ts",
     "test:tool-routing-semantic": "pnpm exec tsx test/continuous-test-suite-tool-routing-semantic.ts",
-    "test:unit": "pnpm run test:bugfixes && pnpm run test:mcp:infra && pnpm run test:mcp:spans && pnpm run test:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:classifier-router && pnpm run test:tool-routing-semantic && pnpm run test:mcp-result-cache && pnpm run test:model-not-found-retryable && pnpm run test:archive:security && pnpm run test:office:security && pnpm run test:vector-chroma && pnpm run test:vector-pgvector && pnpm run test:vector-pinecone && pnpm run test:provider-wiring && pnpm run test:docs-mcp",
+    "test:unit": "pnpm run test:bugfixes && pnpm run test:mcp:infra && pnpm run test:mcp:spans && pnpm run test:tool-routing && pnpm run test:tool-routing-cli && pnpm run test:tool-dedup && pnpm run test:model-pool && pnpm run test:classifier-router && pnpm run test:tool-routing-semantic && pnpm run test:mcp-result-cache && pnpm run test:mcp-direct-name-repair && pnpm run test:model-not-found-retryable && pnpm run test:archive:security && pnpm run test:office:security && pnpm run test:vector-chroma && pnpm run test:vector-pgvector && pnpm run test:vector-pinecone && pnpm run test:provider-wiring && pnpm run test:docs-mcp",
     "// 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:matrix, a different suite covering the full provider capability matrix, runs nightly via .github/workflows/live-matrix.yml — test:providers itself is still only wired into test:live, not any GitHub Actions workflow)": "",
     "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 (not wired into any GitHub Actions workflow as of this comment; run manually or add to live-matrix.yml if nightly coverage is needed)": "",
@@ -455,7 +456,7 @@
     "exceljs": "^4.4.0",
     "express": "^5.1.0",
     "express-rate-limit": "^8.2.1",
-    "fastify": "^5.8.5",
+    "fastify": "^5.12.1",
     "ffmpeg-static": "^5.3.0",
     "fluent-ffmpeg": "^2.1.3",
     "koa": "^3.1.1",
@@ -604,7 +605,7 @@
       "@opentelemetry/sdk-trace-node": "^2.6.0",
       "jws@<4.0.1": ">=4.0.1",
       "tar@<7.5.8": ">=7.5.8",
-      "qs@<6.15.2": ">=6.15.2",
+      "qs@<6.16.0": ">=6.16.0",
       "minimatch@>=10.0.0 <10.2.3": ">=10.2.3",
       "minimatch@>=9.0.0 <9.0.7": ">=9.0.7",
       "typedoc>minimatch": ">=10.2.3",
@@ -621,7 +622,7 @@
       "ajv@>=8.0.0 <8.18.0": ">=8.18.0",
       "@grpc/grpc-js@<1.14.4": ">=1.14.4",
       "@protobufjs/utf8@<1.1.1": ">=1.1.1",
-      "fast-uri@<3.1.5": ">=3.1.5 <4",
+      "fast-uri@<3.1.6": ">=3.1.6 <4",
       "ip-address@<10.1.1": ">=10.1.1",
       "basic-ftp@<5.2.2": ">=5.2.2",
       "fast-xml-builder@<1.1.7": ">=1.1.7",
@@ -631,7 +632,7 @@
       "undici@>=8.0.0": ">=7.24.0 <8.0.0",
       "pdfjs-dist": "5.4.624",
       "markdown-it@<14.2.0": ">=14.2.0",
-      "@xmldom/xmldom@<0.9.11": ">=0.9.11",
+      "@xmldom/xmldom@<0.9.12": ">=0.9.12",
       "protobufjs@<7.6.5": ">=7.6.5",
       "brace-expansion@>=5.0.0 <5.0.9": ">=5.0.9",
       "@opentelemetry/core@>=2.0.0 <2.8.0": ">=2.8.0"