@inkeep/agents-api 0.0.1 → 0.43.0

package/dist/domains/run/tools/VercelSandboxExecutor.js

@@ -11,11 +11,11 @@ const logger = getLogger("VercelSandboxExecutor");
 * Executes function tools in isolated Vercel Sandbox MicroVMs
 * Caches and reuses sandboxes based on dependencies to improve performance
 */
-var VercelSandboxExecutor = class VercelSandboxExecutor {
-	static instance;
+var VercelSandboxExecutor = class {
 	config;
 	sandboxPool = /* @__PURE__ */ new Map();
 	cleanupInterval = null;
+	sandboxInitPromises = /* @__PURE__ */ new Map();
 	constructor(config) {
 		this.config = config;
 		logger.info({
@@ -27,12 +27,74 @@ var VercelSandboxExecutor = class VercelSandboxExecutor {
 		}, "VercelSandboxExecutor initialized with pooling");
 		this.startPoolCleanup();
 	}
-	/**
-	* Get singleton instance of VercelSandboxExecutor
-	*/
-	static getInstance(config) {
-		if (!VercelSandboxExecutor.instance) VercelSandboxExecutor.instance = new VercelSandboxExecutor(config);
-		return VercelSandboxExecutor.instance;
+	async getOrCreateSandbox(params) {
+		const cached = this.getCachedSandbox(params.dependencyHash);
+		if (cached) return cached;
+		const existingInit = this.sandboxInitPromises.get(params.dependencyHash);
+		if (existingInit) {
+			await existingInit;
+			const afterInit = this.getCachedSandbox(params.dependencyHash);
+			if (!afterInit) throw new Error("Sandbox initialization finished but sandbox not found in pool");
+			return afterInit;
+		}
+		const initPromise = (async () => {
+			let sandbox = null;
+			try {
+				sandbox = await Sandbox.create({
+					token: this.config.token,
+					teamId: this.config.teamId,
+					projectId: this.config.projectId,
+					timeout: this.config.timeout,
+					resources: { vcpus: this.config.vcpus || 1 },
+					runtime: this.config.runtime
+				});
+				logger.info({
+					functionId: params.functionId,
+					functionName: params.toolName,
+					sandboxId: sandbox.sandboxId,
+					dependencyHash: params.dependencyHash
+				}, "New sandbox created");
+				this.addToPool(params.dependencyHash, sandbox, params.dependencies);
+				if (Object.keys(params.dependencies).length > 0) {
+					logger.debug({
+						functionId: params.functionId,
+						functionName: params.toolName,
+						dependencyHash: params.dependencyHash,
+						dependencies: params.dependencies
+					}, "Installing dependencies in new sandbox");
+					const packageJsonContent = JSON.stringify({ dependencies: params.dependencies }, null, 2);
+					await sandbox.writeFiles([{
+						path: "package.json",
+						content: Buffer.from(packageJsonContent, "utf-8")
+					}]);
+					const installCmd = await sandbox.runCommand({
+						cmd: "npm",
+						args: ["install", "--omit=dev"],
+						cwd: "/vercel/sandbox"
+					});
+					const installStdout = await installCmd.stdout();
+					const installStderr = await installCmd.stderr();
+					if (installStdout) logger.debug({ functionId: params.functionId }, installStdout);
+					if (installStderr) logger.debug({ functionId: params.functionId }, installStderr);
+					if (installCmd.exitCode !== 0) throw new Error(`Failed to install dependencies: ${installStderr}`);
+					logger.info({
+						functionId: params.functionId,
+						dependencyHash: params.dependencyHash
+					}, "Dependencies installed successfully");
+				}
+				return sandbox;
+			} catch (error) {
+				await this.removeSandbox(params.dependencyHash);
+				if (sandbox) try {
+					await sandbox.stop();
+				} catch {}
+				throw error;
+			} finally {
+				this.sandboxInitPromises.delete(params.dependencyHash);
+			}
+		})();
+		this.sandboxInitPromises.set(params.dependencyHash, initPromise);
+		return initPromise;
 	}
 	/**
 	* Generate a hash for dependencies to use as cache key
@@ -48,13 +110,17 @@ var VercelSandboxExecutor = class VercelSandboxExecutor {
 		const cached = this.sandboxPool.get(dependencyHash);
 		if (!cached) return null;
 		const age = Date.now() - cached.createdAt;
-		if (age > FUNCTION_TOOL_SANDBOX_POOL_TTL_MS || cached.useCount >= FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) {
+		const timeoutSafetyMs = 2e3;
+		const timeRemaining = cached.timeoutMs - age;
+		if (age > FUNCTION_TOOL_SANDBOX_POOL_TTL_MS || cached.useCount >= FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT || timeRemaining <= timeoutSafetyMs) {
 			logger.debug({
 				dependencyHash,
 				age,
 				useCount: cached.useCount,
 				ttl: FUNCTION_TOOL_SANDBOX_POOL_TTL_MS,
-				maxUseCount: FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT
+				maxUseCount: FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT,
+				timeoutMs: cached.timeoutMs,
+				timeRemaining
 			}, "Sandbox expired, will create new one");
 			this.removeSandbox(dependencyHash);
 			return null;
@@ -62,7 +128,9 @@ var VercelSandboxExecutor = class VercelSandboxExecutor {
 		logger.debug({
 			dependencyHash,
 			useCount: cached.useCount,
-			age
+			age,
+			timeoutMs: cached.timeoutMs,
+			timeRemaining
 		}, "Reusing cached sandbox");
 		return cached.sandbox;
 	}
@@ -73,6 +141,7 @@ var VercelSandboxExecutor = class VercelSandboxExecutor {
 		this.sandboxPool.set(dependencyHash, {
 			sandbox,
 			createdAt: Date.now(),
+			timeoutMs: sandbox.timeout,
 			useCount: 0,
 			dependencies
 		});
@@ -94,6 +163,7 @@ var VercelSandboxExecutor = class VercelSandboxExecutor {
 	async removeSandbox(dependencyHash) {
 		const cached = this.sandboxPool.get(dependencyHash);
 		if (cached) {
+			this.sandboxPool.delete(dependencyHash);
 			try {
 				await cached.sandbox.stop();
 				logger.debug({ dependencyHash }, "Sandbox stopped");
@@ -103,7 +173,6 @@ var VercelSandboxExecutor = class VercelSandboxExecutor {
 					dependencyHash
 				}, "Error stopping sandbox");
 			}
-			this.sandboxPool.delete(dependencyHash);
 		}
 	}
 	/**
@@ -113,7 +182,12 @@ var VercelSandboxExecutor = class VercelSandboxExecutor {
 		this.cleanupInterval = setInterval(() => {
 			const now = Date.now();
 			const toRemove = [];
-			for (const [hash, cached] of this.sandboxPool.entries()) if (now - cached.createdAt > FUNCTION_TOOL_SANDBOX_POOL_TTL_MS || cached.useCount >= FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) toRemove.push(hash);
+			for (const [hash, cached] of this.sandboxPool.entries()) {
+				const age = now - cached.createdAt;
+				const timeoutSafetyMs = 2e3;
+				const timeRemaining = cached.timeoutMs - age;
+				if (age > FUNCTION_TOOL_SANDBOX_POOL_TTL_MS || cached.useCount >= FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT || timeRemaining <= timeoutSafetyMs) toRemove.push(hash);
+			}
 			if (toRemove.length > 0) {
 				logger.info({
 					count: toRemove.length,
@@ -132,6 +206,7 @@ var VercelSandboxExecutor = class VercelSandboxExecutor {
 			this.cleanupInterval = null;
 		}
 		logger.info({ poolSize: this.sandboxPool.size }, "Cleaning up all sandboxes");
+		this.sandboxInitPromises.clear();
 		const promises = Array.from(this.sandboxPool.keys()).map((hash) => this.removeSandbox(hash));
 		await Promise.all(promises);
 	}
@@ -156,18 +231,6 @@ var VercelSandboxExecutor = class VercelSandboxExecutor {
 		return envVars;
 	}
 	/**
-	* Create .env file content from environment variables
-	* Note: Currently creates empty placeholders. Values will be populated in the future.
-	*/
-	createEnvFileContent(envVarNames) {
-		const envLines = [];
-		for (const varName of envVarNames) {
-			envLines.push(`${varName}=""`);
-			logger.debug({ varName }, "Adding environment variable placeholder to sandbox");
-		}
-		return envLines.join("\n");
-	}
-	/**
 	* Execute a function tool in Vercel Sandbox with pooling
 	*/
 	async executeFunctionTool(functionId, args, toolConfig) {
@@ -175,6 +238,9 @@ var VercelSandboxExecutor = class VercelSandboxExecutor {
 		const logs = [];
 		const dependencies = toolConfig.dependencies || {};
 		const dependencyHash = this.generateDependencyHash(dependencies);
+		const runRelDir = `runs/${`${Date.now()}-${crypto.randomBytes(6).toString("hex")}`}`;
+		const filename = this.config.runtime === "typescript" ? "execute.ts" : "execute.js";
+		const runFilePath = `${runRelDir}/${filename}`;
 		try {
 			logger.info({
 				functionId,
@@ -182,109 +248,44 @@ var VercelSandboxExecutor = class VercelSandboxExecutor {
 				dependencyHash,
 				poolSize: this.sandboxPool.size
 			}, "Executing function in Vercel Sandbox");
-			let sandbox = this.getCachedSandbox(dependencyHash);
-			let isNewSandbox = false;
-			if (!sandbox) {
-				isNewSandbox = true;
-				sandbox = await Sandbox.create({
-					token: this.config.token,
-					teamId: this.config.teamId,
-					projectId: this.config.projectId,
-					timeout: this.config.timeout,
-					resources: { vcpus: this.config.vcpus || 1 },
-					runtime: this.config.runtime
-				});
-				logger.info({
-					functionId,
-					sandboxId: sandbox.sandboxId,
-					dependencyHash
-				}, `New sandbox created for function ${functionId}`);
-				this.addToPool(dependencyHash, sandbox, dependencies);
-			} else logger.info({
+			const sandbox = await this.getOrCreateSandbox({
 				functionId,
-				sandboxId: sandbox.sandboxId,
-				dependencyHash
-			}, `Reusing cached sandbox for function ${functionId}`);
+				toolName: toolConfig.name,
+				dependencyHash,
+				dependencies
+			});
 			this.incrementUseCount(dependencyHash);
 			try {
-				if (isNewSandbox && toolConfig.dependencies && Object.keys(toolConfig.dependencies).length > 0) {
-					logger.debug({
-						functionId,
-						functionName: toolConfig.name,
-						dependencies: toolConfig.dependencies
-					}, "Installing dependencies in new sandbox");
-					const packageJson = { dependencies: toolConfig.dependencies };
-					const packageJsonContent = JSON.stringify(packageJson, null, 2);
-					await sandbox.writeFiles([{
-						path: "package.json",
-						content: Buffer.from(packageJsonContent, "utf-8")
-					}]);
-					const installCmd = await sandbox.runCommand({
-						cmd: "npm",
-						args: ["install", "--omit=dev"]
-					});
-					const installStdout = await installCmd.stdout();
-					const installStderr = await installCmd.stderr();
-					if (installStdout) logs.push(installStdout);
-					if (installStderr) logs.push(installStderr);
-					if (installCmd.exitCode !== 0) throw new Error(`Failed to install dependencies: ${installStderr}`);
-					logger.info({
-						functionId,
-						dependencyHash
-					}, "Dependencies installed successfully");
-				}
 				const executionCode = createExecutionWrapper(toolConfig.executeCode, args);
 				const envVars = this.extractEnvVars(toolConfig.executeCode);
-				const filesToWrite = [];
-				const filename = this.config.runtime === "typescript" ? "execute.ts" : "execute.js";
-				filesToWrite.push({
-					path: filename,
+				const env = envVars.size > 0 ? Object.fromEntries(Array.from(envVars).map((k) => [k, ""])) : {};
+				const mkdirCmd = await sandbox.runCommand({
+					cmd: "mkdir",
+					args: ["-p", runRelDir],
+					cwd: "/vercel/sandbox"
+				});
+				const mkdirStderr = await mkdirCmd.stderr();
+				if (mkdirCmd.exitCode !== 0) throw new Error(mkdirStderr || "Failed to create run directory");
+				await sandbox.writeFiles([{
+					path: runFilePath,
 					content: Buffer.from(executionCode, "utf-8")
+				}]);
+				const runtime = this.config.runtime === "typescript" ? "tsx" : "node";
+				const executeCmd = this.config.runtime === "typescript" ? await sandbox.runCommand({
+					cmd: "npx",
+					args: [
+						"--yes",
+						"tsx",
+						filename
+					],
+					cwd: `/vercel/sandbox/${runRelDir}`,
+					env
+				}) : await sandbox.runCommand({
+					cmd: runtime,
+					args: [filename],
+					cwd: `/vercel/sandbox/${runRelDir}`,
+					env
 				});
-				if (envVars.size > 0) {
-					const envFileContent = this.createEnvFileContent(envVars);
-					if (envFileContent) {
-						filesToWrite.push({
-							path: ".env",
-							content: Buffer.from(envFileContent, "utf-8")
-						});
-						logger.info({
-							functionId,
-							envVarCount: envVars.size,
-							envVars: Array.from(envVars)
-						}, "Creating environment variable placeholders in sandbox");
-					}
-				}
-				await sandbox.writeFiles(filesToWrite);
-				logger.info({
-					functionId,
-					runtime: this.config.runtime === "typescript" ? "tsx" : "node",
-					hasEnvVars: envVars.size > 0
-				}, `Execution code written to file for runtime ${this.config.runtime}`);
-				const executeCmd = await (async () => {
-					if (envVars.size > 0) return sandbox.runCommand({
-						cmd: "npx",
-						args: this.config.runtime === "typescript" ? [
-							"--yes",
-							"dotenv-cli",
-							"--",
-							"npx",
-							"tsx",
-							filename
-						] : [
-							"--yes",
-							"dotenv-cli",
-							"--",
-							"node",
-							filename
-						]
-					});
-					const runtime = this.config.runtime === "typescript" ? "tsx" : "node";
-					return sandbox.runCommand({
-						cmd: runtime,
-						args: [filename]
-					});
-				})();
 				const executeStdout = await executeCmd.stdout();
 				const executeStderr = await executeCmd.stderr();
 				if (executeStdout) logs.push(executeStdout);
@@ -294,7 +295,8 @@ var VercelSandboxExecutor = class VercelSandboxExecutor {
 					logger.error({
 						functionId,
 						exitCode: executeCmd.exitCode,
-						stderr: executeStderr
+						stderr: executeStderr,
+						logs
 					}, "Function execution failed");
 					return {
 						success: false,
@@ -306,7 +308,8 @@ var VercelSandboxExecutor = class VercelSandboxExecutor {
 				const result = parseExecutionResult(executeStdout, functionId, logger);
 				logger.info({
 					functionId,
-					executionTime
+					executionTime,
+					logs
 				}, "Function executed successfully in Vercel Sandbox");
 				return {
 					success: true,
@@ -314,9 +317,14 @@ var VercelSandboxExecutor = class VercelSandboxExecutor {
 					logs,
 					executionTime
 				};
-			} catch (innerError) {
-				await this.removeSandbox(dependencyHash);
-				throw innerError;
+			} finally {
+				try {
+					await sandbox.runCommand({
+						cmd: "rm",
+						args: ["-rf", runRelDir],
+						cwd: "/vercel/sandbox"
+					});
+				} catch {}
 			}
 		} catch (error) {
 			const executionTime = Date.now() - startTime;
@@ -324,7 +332,9 @@ var VercelSandboxExecutor = class VercelSandboxExecutor {
 			logger.error({
 				functionId,
 				error: errorMessage,
-				executionTime
+				stack: error,
+				executionTime,
+				logs
 			}, "Vercel Sandbox execution error");
 			return {
 				success: false,

package/dist/domains/run/types/xml.d.ts

@@ -1,9 +1,5 @@
 //#region src/domains/run/types/xml.d.ts
-declare module '*.xml' {
-  const content: string;
-  export default content;
-}
-declare module '*.md' {
+declare module '*?raw' {
   const content: string;
   export default content;
 }

package/dist/domains/run/utils/stream-helpers.d.ts

@@ -12,6 +12,36 @@ interface StreamHelper {
   writeData(type: string, data: any): Promise<void>;
   writeOperation(operation: OperationEvent): Promise<void>;
   writeSummary(summary: SummaryEvent): Promise<void>;
+  writeToolInputStart(params: {
+    toolCallId: string;
+    toolName: string;
+  }): Promise<void>;
+  writeToolInputDelta(params: {
+    toolCallId: string;
+    inputTextDelta: string;
+  }): Promise<void>;
+  writeToolInputAvailable(params: {
+    toolCallId: string;
+    toolName: string;
+    input: any;
+    providerMetadata?: any;
+  }): Promise<void>;
+  writeToolOutputAvailable(params: {
+    toolCallId: string;
+    output: any;
+  }): Promise<void>;
+  writeToolOutputError(params: {
+    toolCallId: string;
+    errorText: string;
+    output?: any;
+  }): Promise<void>;
+  writeToolApprovalRequest(params: {
+    approvalId: string;
+    toolCallId: string;
+  }): Promise<void>;
+  writeToolOutputDenied(params: {
+    toolCallId: string;
+  }): Promise<void>;
 }
 interface HonoSSEStream {
   writeSSE(message: {
@@ -31,6 +61,15 @@ interface ChatCompletionChunk {
     delta: {
       role?: string;
       content?: string;
+      tool_calls?: Array<{
+        index: number;
+        id: string | null;
+        type: 'function' | null;
+        function: {
+          name: string | null;
+          arguments: string;
+        };
+      }>;
     };
     finish_reason: string | null;
   }>;
@@ -41,6 +80,7 @@ declare class SSEStreamHelper implements StreamHelper {
   private timestamp;
   private isTextStreaming;
   private queuedEvents;
+  private toolCallIndexById;
   constructor(stream: HonoSSEStream, requestId: string, timestamp: number);
   /**
    * Write the initial role message
@@ -50,6 +90,8 @@ declare class SSEStreamHelper implements StreamHelper {
    * Write content chunk
    */
   writeContent(content: string): Promise<void>;
+  private getToolIndex;
+  private writeToolCallsDelta;
   /**
    * Stream text word by word with optional delay
    */
@@ -64,6 +106,36 @@ declare class SSEStreamHelper implements StreamHelper {
    */
   writeCompletion(finishReason?: string): Promise<void>;
   writeData(type: string, data: any): Promise<void>;
+  writeToolInputStart(params: {
+    toolCallId: string;
+    toolName: string;
+  }): Promise<void>;
+  writeToolInputDelta(params: {
+    toolCallId: string;
+    inputTextDelta: string;
+  }): Promise<void>;
+  writeToolInputAvailable(params: {
+    toolCallId: string;
+    toolName: string;
+    input: any;
+    providerMetadata?: any;
+  }): Promise<void>;
+  writeToolOutputAvailable(params: {
+    toolCallId: string;
+    output: any;
+  }): Promise<void>;
+  writeToolOutputError(params: {
+    toolCallId: string;
+    errorText: string;
+    output?: any;
+  }): Promise<void>;
+  writeToolApprovalRequest(params: {
+    approvalId: string;
+    toolCallId: string;
+  }): Promise<void>;
+  writeToolOutputDenied(params: {
+    toolCallId: string;
+  }): Promise<void>;
   writeSummary(summary: SummaryEvent): Promise<void>;
   writeOperation(operation: OperationEvent): Promise<void>;
   /**
@@ -101,11 +173,42 @@ declare class VercelDataStreamHelper implements StreamHelper {
   private lastTextEndTimestamp;
   private connectionDropTimer?;
   constructor(writer: VercelUIWriter);
+  setSessionId(_sessionId: string): void;
   writeRole(_?: string): Promise<void>;
   writeContent(content: string): Promise<void>;
   streamText(text: string, delayMs?: number): Promise<void>;
   writeData(type: string, data: any): Promise<void>;
   writeError(error: string | ErrorEvent): Promise<void>;
+  writeToolInputStart(params: {
+    toolCallId: string;
+    toolName: string;
+  }): Promise<void>;
+  writeToolInputDelta(params: {
+    toolCallId: string;
+    inputTextDelta: string;
+  }): Promise<void>;
+  writeToolInputAvailable(params: {
+    toolCallId: string;
+    toolName: string;
+    input: any;
+    providerMetadata?: any;
+  }): Promise<void>;
+  writeToolOutputAvailable(params: {
+    toolCallId: string;
+    output: any;
+  }): Promise<void>;
+  writeToolOutputError(params: {
+    toolCallId: string;
+    errorText: string;
+    output?: any;
+  }): Promise<void>;
+  writeToolApprovalRequest(params: {
+    approvalId: string;
+    toolCallId: string;
+  }): Promise<void>;
+  writeToolOutputDenied(params: {
+    toolCallId: string;
+  }): Promise<void>;
   streamData(data: any): Promise<void>;
   mergeStream(stream: any): Promise<void>;
   /**
@@ -164,6 +267,7 @@ declare class BufferingStreamHelper implements StreamHelper {
   private capturedSummaries;
   private hasError;
   private errorMessage;
+  setSessionId(_sessionId: string): void;
   writeRole(_role?: string): Promise<void>;
   writeContent(content: string): Promise<void>;
   streamText(text: string, _delayMs?: number): Promise<void>;
@@ -174,6 +278,36 @@ declare class BufferingStreamHelper implements StreamHelper {
   writeSummary(summary: SummaryEvent): Promise<void>;
   writeOperation(operation: OperationEvent): Promise<void>;
   writeError(error: string | ErrorEvent): Promise<void>;
+  writeToolInputStart(params: {
+    toolCallId: string;
+    toolName: string;
+  }): Promise<void>;
+  writeToolInputDelta(params: {
+    toolCallId: string;
+    inputTextDelta: string;
+  }): Promise<void>;
+  writeToolInputAvailable(params: {
+    toolCallId: string;
+    toolName: string;
+    input: any;
+    providerMetadata?: any;
+  }): Promise<void>;
+  writeToolOutputAvailable(params: {
+    toolCallId: string;
+    output: any;
+  }): Promise<void>;
+  writeToolOutputError(params: {
+    toolCallId: string;
+    errorText: string;
+    output?: any;
+  }): Promise<void>;
+  writeToolApprovalRequest(params: {
+    approvalId: string;
+    toolCallId: string;
+  }): Promise<void>;
+  writeToolOutputDenied(params: {
+    toolCallId: string;
+  }): Promise<void>;
   complete(): Promise<void>;
   /**
    * Get the captured response for non-streaming output