@juspay/neurolink 9.51.2 → 9.51.4

package/dist/cli/commands/mcp.d.ts

@@ -67,6 +67,12 @@ export declare class MCPCommandFactory {
      * Execute exec command
      */
     private static executeExec;
+    /**
+     * Run the actual MCP tool execution and format/write the output.
+     * Extracted to keep executeExec nesting within ESLint max-depth limit.
+     * Returns 0 on success, 1 on failure.
+     */
+    private static runExecTool;
     /**
      * Execute remove command
      */

package/dist/cli/commands/mcp.js

@@ -656,104 +656,146 @@ export class MCPCommandFactory {
                 }
             }
             const sdk = new NeuroLink();
-            await this.getMCPStatusWithTimeout(sdk);
-            // Check if server exists and is connected
-            const allServers = await sdk.listMCPServers();
-            const server = allServers.find((s) => s.name === serverName);
-            if (!server) {
-                if (spinner) {
-                    spinner.fail();
-                }
-                logger.error(chalk.red(`❌ Server not found: ${serverName}`));
-                process.exit(1);
-            }
-            if (server.status !== "connected") {
-                if (spinner) {
-                    spinner.fail();
-                }
-                logger.error(chalk.red(`❌ Server not connected: ${serverName}`));
-                logger.always(chalk.yellow("💡 Try: neurolink mcp test " + serverName));
-                process.exit(1);
-            }
-            // Check if tool exists
-            const tool = server.tools?.find((t) => t.name === toolName);
-            if (!tool) {
-                if (spinner) {
-                    spinner.fail();
-                }
-                logger.error(chalk.red(`❌ Tool not found: ${toolName}`));
-                if (server.tools?.length) {
-                    logger.always(chalk.blue("Available tools:"));
-                    server.tools.forEach((t) => {
-                        logger.always(`  • ${t.name}: ${t.description}`);
-                    });
-                }
-                process.exit(1);
-            }
-            // Execute the tool using the NeuroLink MCP tool registry
+            let exitCode = 0;
             try {
-                const { toolRegistry } = await import("../../lib/mcp/toolRegistry.js");
-                const executionResult = await toolRegistry.executeTool(toolName, params, {
-                    sessionId: `cli-${Date.now()}`,
-                    userId: process.env.USER || "cli-user",
-                    config: {
-                        domainType: "cli-execution",
-                        customData: { serverName },
-                    },
-                });
-                const result = {
-                    tool: toolName,
-                    server: serverName,
-                    params,
-                    result: executionResult,
-                    success: true,
-                    timestamp: new Date().toISOString(),
-                };
-                if (spinner) {
-                    spinner.succeed(chalk.green("✅ Tool executed successfully"));
-                }
-                // Display results
-                if (argv.format === "json") {
-                    logger.always(JSON.stringify(result, null, 2));
-                }
-                else {
-                    logger.always(chalk.green("🔧 Tool Execution Results:"));
-                    logger.always(`   Tool: ${chalk.cyan(toolName)}`);
-                    logger.always(`   Server: ${chalk.cyan(serverName)}`);
-                    logger.always(`   Result: ${JSON.stringify(executionResult, null, 2)}`);
-                    logger.always(`   Timestamp: ${result.timestamp}`);
-                }
-            }
-            catch (toolError) {
-                const errorMessage = toolError instanceof Error ? toolError.message : String(toolError);
-                if (spinner) {
-                    spinner.fail(chalk.red("❌ Tool execution failed"));
+                await this.getMCPStatusWithTimeout(sdk);
+                // Check if server exists and is connected
+                const allServers = await sdk.listMCPServers();
+                const server = allServers.find((s) => s.name === serverName);
+                if (!server) {
+                    if (spinner) {
+                        spinner.fail();
+                    }
+                    logger.error(chalk.red(`❌ Server not found: ${serverName}`));
+                    exitCode = 1;
                 }
-                const result = {
-                    tool: toolName,
-                    server: serverName,
-                    params,
-                    _error: errorMessage,
-                    success: false,
-                    timestamp: new Date().toISOString(),
-                };
-                if (argv.format === "json") {
-                    logger.always(JSON.stringify(result, null, 2));
+                else if (server.status !== "connected") {
+                    if (spinner) {
+                        spinner.fail();
+                    }
+                    logger.error(chalk.red(`❌ Server not connected: ${serverName}`));
+                    logger.always(chalk.yellow("💡 Try: neurolink mcp test " + serverName));
+                    exitCode = 1;
                 }
                 else {
-                    logger.error(chalk.red("🔧 Tool Execution Failed:"));
-                    logger.error(`   Tool: ${chalk.cyan(toolName)}`);
-                    logger.error(`   Server: ${chalk.cyan(serverName)}`);
-                    logger.error(`   Error: ${chalk.red(errorMessage)}`);
+                    // Check if tool exists
+                    const tool = server.tools?.find((t) => t.name === toolName);
+                    if (!tool) {
+                        if (spinner) {
+                            spinner.fail();
+                        }
+                        logger.error(chalk.red(`❌ Tool not found: ${toolName}`));
+                        if (server.tools?.length) {
+                            logger.always(chalk.blue("Available tools:"));
+                            server.tools.forEach((t) => {
+                                logger.always(`  • ${t.name}: ${t.description}`);
+                            });
+                        }
+                        exitCode = 1;
+                    }
+                    else {
+                        exitCode = await this.runExecTool(toolName, serverName, params, argv, spinner);
+                    }
                 }
-                process.exit(1);
             }
+            finally {
+                // Always shut down MCP connections to prevent lingering child processes
+                await sdk.shutdown().catch(() => undefined);
+            }
+            // Flush stdout/stderr before exit so buffered output (spinner lines,
+            // result text) is not truncated by process.exit(). process.exit() is
+            // still required because MCP stdio connections and health-check timers
+            // keep the Node.js event loop alive even after sdk.shutdown().
+            await new Promise((resolve) => {
+                process.stdout.write("", () => {
+                    process.stderr.write("", () => resolve());
+                });
+            });
+            process.exit(exitCode);
         }
         catch (_error) {
             logger.error(chalk.red(`❌ Exec command failed: ${_error.message}`));
             process.exit(1);
         }
     }
+    /**
+     * Run the actual MCP tool execution and format/write the output.
+     * Extracted to keep executeExec nesting within ESLint max-depth limit.
+     * Returns 0 on success, 1 on failure.
+     */
+    static async runExecTool(toolName, serverName, params, argv, spinner) {
+        const WARN_BYTES = 50 * 1024; // 50 KB
+        try {
+            const { toolRegistry } = await import("../../lib/mcp/toolRegistry.js");
+            const executionResult = await withTimeout(toolRegistry.executeTool(toolName, params, {
+                sessionId: `cli-${Date.now()}`,
+                userId: process.env.USER || "cli-user",
+                config: { domainType: "cli-execution", customData: { serverName } },
+            }), MCP_STATUS_TIMEOUT_MS, ErrorFactory.toolTimeout(toolName, MCP_STATUS_TIMEOUT_MS));
+            const result = {
+                tool: toolName,
+                server: serverName,
+                params,
+                result: executionResult,
+                success: true,
+                timestamp: new Date().toISOString(),
+            };
+            if (spinner) {
+                spinner.succeed(chalk.green("✅ Tool executed successfully"));
+            }
+            const resultJson = JSON.stringify(result, null, 2);
+            const resultBytes = Buffer.byteLength(resultJson, "utf-8");
+            const outputFile = argv.output;
+            if (outputFile) {
+                await fs.promises.writeFile(outputFile, resultJson, "utf-8");
+                logger.always(chalk.green(`✅ Result saved to: ${chalk.cyan(outputFile)}`));
+                logger.always(`   Size: ${resultBytes >= 1024 ? `${(resultBytes / 1024).toFixed(1)} KB` : `${resultBytes} B`}`);
+            }
+            else if (argv.format === "json") {
+                if (resultBytes > WARN_BYTES) {
+                    logger.warn(chalk.yellow(`⚠  Large result (${(resultBytes / 1024).toFixed(1)} KB). ` +
+                        `Use --output <file> to save to disk instead.`));
+                }
+                logger.always(resultJson);
+            }
+            else {
+                if (resultBytes > WARN_BYTES) {
+                    logger.warn(chalk.yellow(`⚠  Large result (${(resultBytes / 1024).toFixed(1)} KB). ` +
+                        `Use --output <file> to save to disk instead.`));
+                }
+                logger.always(chalk.green("🔧 Tool Execution Results:"));
+                logger.always(`   Tool: ${chalk.cyan(toolName)}`);
+                logger.always(`   Server: ${chalk.cyan(serverName)}`);
+                logger.always(`   Result: ${JSON.stringify(executionResult, null, 2)}`);
+                logger.always(`   Timestamp: ${result.timestamp}`);
+            }
+            return 0;
+        }
+        catch (toolError) {
+            const errorMessage = toolError instanceof Error ? toolError.message : String(toolError);
+            if (spinner) {
+                spinner.fail(chalk.red("❌ Tool execution failed"));
+            }
+            const result = {
+                tool: toolName,
+                server: serverName,
+                params,
+                _error: errorMessage,
+                success: false,
+                timestamp: new Date().toISOString(),
+            };
+            if (argv.format === "json") {
+                logger.always(JSON.stringify(result, null, 2));
+            }
+            else {
+                logger.error(chalk.red("🔧 Tool Execution Failed:"));
+                logger.error(`   Tool: ${chalk.cyan(toolName)}`);
+                logger.error(`   Server: ${chalk.cyan(serverName)}`);
+                logger.error(`   Error: ${chalk.red(errorMessage)}`);
+            }
+            return 1;
+        }
+    }
     /**
      * Execute remove command
      */

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/core/redisConversationMemoryManager.js

@@ -7,6 +7,7 @@ import { tracers } from "../telemetry/tracers.js";
 import { randomUUID } from "crypto";
 import { MESSAGES_PER_TURN } from "../config/conversationMemory.js";
 import { generateToolOutputPreview } from "../context/toolOutputLimits.js";
+import { NEUROLINK_ARTIFACT_ID_KEY } from "../mcp/mcpOutputNormalizer.js";
 import { SummarizationEngine } from "../context/summarizationEngine.js";
 import { NeuroLink } from "../neurolink.js";
 import { ConversationMemoryError } from "../types/conversation.js";
@@ -1320,11 +1321,30 @@ User message: "${userMessage}"`;
                     maxBytes: this.config?.contextCompaction?.maxToolOutputBytes,
                     maxLines: this.config?.contextCompaction?.maxToolOutputLines,
                 });
+                // Extract artifact ID if this result was externalized by McpOutputNormalizer.
+                // The surrogate carries `_meta.neurolinkArtifactId` on the raw result object.
+                let artifactId;
+                try {
+                    const rawResult = toolResult.result;
+                    if (rawResult && typeof rawResult === "object") {
+                        const meta = rawResult._meta;
+                        if (meta && typeof meta === "object") {
+                            const idValue = meta[NEUROLINK_ARTIFACT_ID_KEY];
+                            if (typeof idValue === "string") {
+                                artifactId = idValue;
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Ignore extraction errors — artifact ID is best-effort metadata
+                }
                 // Build metadata — only store preview when truncation occurred (no duplication)
                 const metadata = {
                     truncated,
                     ...(truncated && { toolOutputPreview: preview }),
                     ...(truncated && { originalSize }),
+                    ...(artifactId && { artifactId }),
                 };
                 // Build result — success/error metadata only, NOT the output data
                 const result = {

package/dist/lib/artifacts/artifactStore.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Artifact Store
+ *
+ * Pluggable storage for externalized MCP tool outputs.
+ *
+ * When `mcp.outputLimits.strategy = "externalize"` the full tool payload is
+ * written here instead of being sent inline to the LLM. The model receives a
+ * compact surrogate with a preview and an artifact ID. The full payload can be
+ * retrieved on demand via the `retrieve_context` tool.
+ *
+ * Architecture:
+ *   ArtifactStore (interface) — canonical types in src/lib/types/artifactTypes.ts
+ *   LocalTempArtifactStore   — single-process, filesystem-backed implementation
+ *
+ * Distributed backends (S3, Redis blobs) can be added later by implementing
+ * ArtifactStore from types/artifactTypes.ts.
+ *
+ * @module artifacts/artifactStore
+ */
+import type { ArtifactMeta, ArtifactRef, ArtifactStore } from "../types/artifactTypes.js";
+export type { ArtifactMeta, ArtifactRef, ArtifactStore, } from "../types/artifactTypes.js";
+/**
+ * Filesystem-backed artifact store using the OS temp directory.
+ *
+ * Files are written with mode 0o600 (owner read/write only).
+ * An in-memory index tracks metadata without a separate index file.
+ *
+ * Suitable for:
+ *  - CLI usage
+ *  - Single-process SDK deployments
+ *  - Multi-process deployments where each process manages its own artifacts
+ *    (artifacts created in one process are not visible to others)
+ *
+ * @example
+ * ```typescript
+ * const store = new LocalTempArtifactStore();
+ * const ref = await store.store(largeJson, {
+ *   toolName: "list_files",
+ *   serverId: "filesystem-server",
+ *   sizeBytes: Buffer.byteLength(largeJson),
+ *   contentType: "json",
+ * });
+ * // Later, via retrieve_context:
+ * const full = await store.retrieve(ref.id);
+ * ```
+ */
+export declare class LocalTempArtifactStore implements ArtifactStore {
+    private readonly dir;
+    private readonly index;
+    constructor(dir?: string);
+    generatePreview(payload: string): string;
+    store(payload: string, meta: Omit<ArtifactMeta, "createdAt">): Promise<ArtifactRef>;
+    retrieve(id: string): Promise<string | null>;
+    delete(id: string): Promise<void>;
+    cleanup(olderThanMs: number): Promise<number>;
+}