@inkeep/agents-api 0.0.0-dev-20260121225854 → 0.0.0-dev-20260122001146

package/dist/domains/manage/routes/mcp.d.ts

@@ -1,7 +1,7 @@
 import { Hono } from "hono";
-import * as hono_types8 from "hono/types";
+import * as hono_types5 from "hono/types";
 
 //#region src/domains/manage/routes/mcp.d.ts
-declare const app: Hono<hono_types8.BlankEnv, hono_types8.BlankSchema, "/">;
+declare const app: Hono<hono_types5.BlankEnv, hono_types5.BlankSchema, "/">;
 //#endregion
 export { app as default };

package/dist/domains/manage/routes/signoz.d.ts

@@ -1,10 +1,10 @@
 import { ManageAppVariables } from "../../../types/app.js";
 import { Hono } from "hono";
-import * as hono_types5 from "hono/types";
+import * as hono_types7 from "hono/types";
 
 //#region src/domains/manage/routes/signoz.d.ts
 declare const app: Hono<{
   Variables: ManageAppVariables;
-}, hono_types5.BlankSchema, "/">;
+}, hono_types7.BlankSchema, "/">;
 //#endregion
 export { app as default };

package/dist/domains/run/agents/Agent.js

@@ -728,7 +728,7 @@ var Agent = class {
 			})).data ?? [];
 			if (functionToolsData.length === 0) return functionTools;
 			const { SandboxExecutorFactory } = await import("../tools/SandboxExecutorFactory.js");
-			const sandboxExecutor = SandboxExecutorFactory.getInstance();
+			const sandboxExecutor = sessionId ? SandboxExecutorFactory.getForSession(sessionId) : new SandboxExecutorFactory();
 			for (const functionToolDef of functionToolsData) {
 				const functionId = functionToolDef.functionId;
 				if (!functionId) {

package/dist/domains/run/agents/relationTools.d.ts

@@ -1,6 +1,6 @@
 import { AgentConfig, DelegateRelation } from "./Agent.js";
 import { InternalRelation } from "../utils/project.js";
-import * as _inkeep_agents_core0 from "@inkeep/agents-core";
+import * as _inkeep_agents_core2 from "@inkeep/agents-core";
 import { CredentialStoreRegistry, FullExecutionContext } from "@inkeep/agents-core";
 import * as ai0 from "ai";
 
@@ -44,7 +44,7 @@ declare function createDelegateToAgentTool({
   message: string;
 }, {
   toolCallId: any;
-  result: _inkeep_agents_core0.Message | _inkeep_agents_core0.Task;
+  result: _inkeep_agents_core2.Message | _inkeep_agents_core2.Task;
 }>;
 /**
  * Parameters for building a transfer relation config

package/dist/domains/run/services/AgentSession.js

@@ -345,6 +345,15 @@ var AgentSession = class {
 		this.artifactProcessingErrors.clear();
 		this.artifactCache.clear();
 		if (this.sessionId) toolSessionManager.endSession(this.sessionId);
+		if (this.sessionId) try {
+			const { SandboxExecutorFactory } = await import("../tools/SandboxExecutorFactory.js");
+			await SandboxExecutorFactory.cleanupSession(this.sessionId);
+		} catch (error) {
+			logger.warn({
+				sessionId: this.sessionId,
+				error
+			}, "Failed to cleanup session-scoped sandbox executors");
+		}
 		if (this.scheduledTimeouts) {
 			for (const timeoutId of this.scheduledTimeouts) clearTimeout(timeoutId);
 			this.scheduledTimeouts.clear();

package/dist/domains/run/tools/NativeSandboxExecutor.d.ts

@@ -13,10 +13,11 @@ interface FunctionToolConfig {
 declare class NativeSandboxExecutor {
   private tempDir;
   private sandboxPool;
-  private static instance;
   private executionSemaphores;
+  private poolCleanupInterval;
+  private sandboxInitPromises;
   constructor();
-  static getInstance(): NativeSandboxExecutor;
+  cleanup(): Promise<void>;
   private getSemaphore;
   getExecutionStats(): Record<string, {
     availablePermits: number;

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

@@ -3,7 +3,7 @@ import { FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, FUNCTION_TOOL_SANDBOX_CLEAN
 import { createExecutionWrapper, parseExecutionResult } from "./sandbox-utils.js";
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { tmpdir } from "node:os";
 
@@ -52,8 +52,7 @@ import { tmpdir } from "node:os";
 * - Works in Docker, Kubernetes, serverless (Vercel, Lambda)
 * - No files left in project directory (no git pollution)
 *
-* The singleton pattern here is important - we need one shared pool
-* across all tool executions, otherwise caching doesn't work.
+* Note: In this repo, sandbox pooling is scoped to a single message/session via SandboxExecutorFactory.
 */
 const logger = getLogger("native-sandbox-executor");
 /**
@@ -105,19 +104,25 @@ var ExecutionSemaphore = class {
 		return this.waitQueue.length;
 	}
 };
-var NativeSandboxExecutor = class NativeSandboxExecutor {
+var NativeSandboxExecutor = class {
 	tempDir;
 	sandboxPool = {};
-	static instance = null;
 	executionSemaphores = /* @__PURE__ */ new Map();
+	poolCleanupInterval = null;
+	sandboxInitPromises = /* @__PURE__ */ new Map();
 	constructor() {
 		this.tempDir = join(tmpdir(), "inkeep-sandboxes");
 		this.ensureTempDir();
 		this.startPoolCleanup();
 	}
-	static getInstance() {
-		if (!NativeSandboxExecutor.instance) NativeSandboxExecutor.instance = new NativeSandboxExecutor();
-		return NativeSandboxExecutor.instance;
+	async cleanup() {
+		if (this.poolCleanupInterval) {
+			clearInterval(this.poolCleanupInterval);
+			this.poolCleanupInterval = null;
+		}
+		this.sandboxInitPromises.clear();
+		for (const sandbox of Object.values(this.sandboxPool)) this.cleanupSandbox(sandbox.sandboxDir);
+		this.sandboxPool = {};
 	}
 	getSemaphore(vcpus) {
 		const effectiveVcpus = Math.max(1, vcpus || 1);
@@ -154,16 +159,20 @@ var NativeSandboxExecutor = class NativeSandboxExecutor {
 			if (now - sandbox.lastUsed < FUNCTION_TOOL_SANDBOX_POOL_TTL_MS && sandbox.useCount < FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) {
 				sandbox.lastUsed = now;
 				sandbox.useCount++;
+				sandbox.activeCount++;
 				logger.debug({
 					poolKey,
 					useCount: sandbox.useCount,
 					sandboxDir: sandbox.sandboxDir,
-					lastUsed: new Date(sandbox.lastUsed)
+					lastUsed: new Date(sandbox.lastUsed),
+					activeCount: sandbox.activeCount
 				}, "Reusing cached sandbox");
 				return sandbox.sandboxDir;
 			}
-			this.cleanupSandbox(sandbox.sandboxDir);
-			delete this.sandboxPool[poolKey];
+			if (sandbox.activeCount === 0) {
+				this.cleanupSandbox(sandbox.sandboxDir);
+				delete this.sandboxPool[poolKey];
+			}
 		}
 		return null;
 	}
@@ -174,7 +183,8 @@ var NativeSandboxExecutor = class NativeSandboxExecutor {
 			sandboxDir,
 			lastUsed: Date.now(),
 			useCount: 1,
-			dependencies
+			dependencies,
+			activeCount: 0
 		};
 		logger.debug({
 			poolKey,
@@ -196,10 +206,10 @@ var NativeSandboxExecutor = class NativeSandboxExecutor {
 		}
 	}
 	startPoolCleanup() {
-		setInterval(() => {
+		this.poolCleanupInterval = setInterval(() => {
 			const now = Date.now();
 			const keysToDelete = [];
-			for (const [key, sandbox] of Object.entries(this.sandboxPool)) if (now - sandbox.lastUsed > FUNCTION_TOOL_SANDBOX_POOL_TTL_MS || sandbox.useCount >= FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) {
+			for (const [key, sandbox] of Object.entries(this.sandboxPool)) if (sandbox.activeCount === 0 && (now - sandbox.lastUsed > FUNCTION_TOOL_SANDBOX_POOL_TTL_MS || sandbox.useCount >= FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT)) {
 				this.cleanupSandbox(sandbox.sandboxDir);
 				keysToDelete.push(key);
 			}
@@ -257,42 +267,62 @@ var NativeSandboxExecutor = class NativeSandboxExecutor {
 			sandboxConfig: config.sandboxConfig,
 			poolSize: Object.keys(this.sandboxPool).length
 		}, "Executing function tool");
-		let sandboxDir = this.getCachedSandbox(dependencyHash);
-		let isNewSandbox = false;
-		if (!sandboxDir) {
-			sandboxDir = join(this.tempDir, `sandbox-${dependencyHash}-${Date.now()}`);
-			mkdirSync(sandboxDir, { recursive: true });
-			isNewSandbox = true;
-			logger.debug({
-				toolId,
-				dependencyHash,
-				sandboxDir,
-				dependencies
-			}, "Creating new sandbox");
-			const moduleType = this.detectModuleType(config.executeCode, config.sandboxConfig?.runtime);
-			const packageJson = {
-				name: `function-tool-${toolId}`,
-				version: "1.0.0",
-				...moduleType === "esm" && { type: "module" },
-				dependencies,
-				scripts: { start: moduleType === "esm" ? "node index.mjs" : "node index.js" }
-			};
-			writeFileSync(join(sandboxDir, "package.json"), JSON.stringify(packageJson, null, 2), "utf8");
-			if (Object.keys(dependencies).length > 0) await this.installDependencies(sandboxDir);
-			this.addToPool(dependencyHash, sandboxDir, dependencies);
-		}
+		const sandboxDir = await (async () => {
+			const cachedDir = this.getCachedSandbox(dependencyHash);
+			if (cachedDir) return cachedDir;
+			const existingInit = this.sandboxInitPromises.get(dependencyHash);
+			if (existingInit) {
+				const dir = await existingInit;
+				const poolEntry = this.sandboxPool[dependencyHash];
+				if (poolEntry) poolEntry.activeCount++;
+				return dir;
+			}
+			const initPromise = (async () => {
+				const dir = join(this.tempDir, `sandbox-${dependencyHash}-${Date.now()}`);
+				mkdirSync(dir, { recursive: true });
+				logger.debug({
+					toolId,
+					dependencyHash,
+					sandboxDir: dir,
+					dependencies
+				}, "Creating new sandbox");
+				const packageJson = {
+					name: `function-tool-${toolId}`,
+					version: "1.0.0",
+					dependencies
+				};
+				writeFileSync(join(dir, "package.json"), JSON.stringify(packageJson, null, 2), "utf8");
+				if (Object.keys(dependencies).length > 0) await this.installDependencies(dir);
+				this.addToPool(dependencyHash, dir, dependencies);
+				this.sandboxPool[dependencyHash].activeCount++;
+				return dir;
+			})();
+			this.sandboxInitPromises.set(dependencyHash, initPromise);
+			try {
+				return await initPromise;
+			} finally {
+				this.sandboxInitPromises.delete(dependencyHash);
+			}
+		})();
+		let runDir = null;
 		try {
 			const moduleType = this.detectModuleType(config.executeCode, config.sandboxConfig?.runtime);
 			const executionCode = createExecutionWrapper(config.executeCode, args);
-			writeFileSync(join(sandboxDir, `index.${moduleType === "esm" ? "mjs" : "js"}`), executionCode, "utf8");
-			return await this.executeInSandbox(sandboxDir, config.sandboxConfig?.timeout || FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, moduleType, config.sandboxConfig);
+			runDir = join(sandboxDir, "runs", `${Date.now()}-${createHash("sha256").update(randomUUID()).digest("hex").substring(0, 8)}`);
+			mkdirSync(runDir, { recursive: true });
+			writeFileSync(join(runDir, `index.${moduleType === "esm" ? "mjs" : "cjs"}`), executionCode, "utf8");
+			return await this.executeInSandbox(runDir, config.sandboxConfig?.timeout || FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, moduleType, config.sandboxConfig);
 		} catch (error) {
-			if (isNewSandbox) {
-				this.cleanupSandbox(sandboxDir);
-				const poolKey = dependencyHash;
-				delete this.sandboxPool[poolKey];
-			}
 			throw error;
+		} finally {
+			if (runDir) try {
+				rmSync(runDir, {
+					recursive: true,
+					force: true
+				});
+			} catch {}
+			const poolEntry = this.sandboxPool[dependencyHash];
+			if (poolEntry) poolEntry.activeCount = Math.max(0, poolEntry.activeCount - 1);
 		}
 	}
 	async installDependencies(sandboxDir) {
@@ -344,7 +374,7 @@ var NativeSandboxExecutor = class NativeSandboxExecutor {
 	}
 	async executeInSandbox(sandboxDir, timeout, moduleType, _sandboxConfig) {
 		return new Promise((resolve$1, reject) => {
-			const fileExtension = moduleType === "esm" ? "mjs" : "js";
+			const fileExtension = moduleType === "esm" ? "mjs" : "cjs";
 			const spawnOptions = {
 				cwd: sandboxDir,
 				stdio: "pipe",

package/dist/domains/run/tools/SandboxExecutorFactory.d.ts

@@ -8,13 +8,23 @@ import { FunctionToolConfig } from "./NativeSandboxExecutor.js";
  */
 declare class SandboxExecutorFactory {
   private static instance;
+  private static sessionFactories;
   private nativeExecutor;
   private vercelExecutors;
-  private constructor();
+  constructor();
   /**
    * Get singleton instance of SandboxExecutorFactory
    */
   static getInstance(): SandboxExecutorFactory;
+  /**
+   * Get a session-scoped instance of SandboxExecutorFactory.
+   * Intended to scope Vercel sandbox pooling to a single message/session.
+   */
+  static getForSession(sessionId: string): SandboxExecutorFactory;
+  /**
+   * Cleanup and remove a session-scoped SandboxExecutorFactory.
+   */
+  static cleanupSession(sessionId: string): Promise<void>;
   /**
    * Execute a function tool using the appropriate sandbox provider
    */

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

@@ -10,6 +10,7 @@ const logger = getLogger("SandboxExecutorFactory");
 */
 var SandboxExecutorFactory = class SandboxExecutorFactory {
 	static instance;
+	static sessionFactories = /* @__PURE__ */ new Map();
 	nativeExecutor = null;
 	vercelExecutors = /* @__PURE__ */ new Map();
 	constructor() {
@@ -23,6 +24,26 @@ var SandboxExecutorFactory = class SandboxExecutorFactory {
 		return SandboxExecutorFactory.instance;
 	}
 	/**
+	* Get a session-scoped instance of SandboxExecutorFactory.
+	* Intended to scope Vercel sandbox pooling to a single message/session.
+	*/
+	static getForSession(sessionId) {
+		const existing = SandboxExecutorFactory.sessionFactories.get(sessionId);
+		if (existing) return existing;
+		const created = new SandboxExecutorFactory();
+		SandboxExecutorFactory.sessionFactories.set(sessionId, created);
+		return created;
+	}
+	/**
+	* Cleanup and remove a session-scoped SandboxExecutorFactory.
+	*/
+	static async cleanupSession(sessionId) {
+		const factory = SandboxExecutorFactory.sessionFactories.get(sessionId);
+		if (!factory) return;
+		await factory.cleanup();
+		SandboxExecutorFactory.sessionFactories.delete(sessionId);
+	}
+	/**
 	* Execute a function tool using the appropriate sandbox provider
 	*/
 	async executeFunctionTool(functionId, args, config) {
@@ -37,7 +58,7 @@ var SandboxExecutorFactory = class SandboxExecutorFactory {
 	*/
 	async executeInNativeSandbox(functionId, args, config) {
 		if (!this.nativeExecutor) {
-			this.nativeExecutor = NativeSandboxExecutor.getInstance();
+			this.nativeExecutor = new NativeSandboxExecutor();
 			logger.info({}, "Native sandbox executor created");
 		}
 		return this.nativeExecutor.executeFunctionTool(functionId, args, config);
@@ -49,7 +70,7 @@ var SandboxExecutorFactory = class SandboxExecutorFactory {
 		const vercelConfig = config.sandboxConfig;
 		const configKey = `${vercelConfig.teamId}:${vercelConfig.projectId}`;
 		if (!this.vercelExecutors.has(configKey)) {
-			const executor$1 = VercelSandboxExecutor.getInstance(vercelConfig);
+			const executor$1 = new VercelSandboxExecutor(vercelConfig);
 			this.vercelExecutors.set(configKey, executor$1);
 			logger.info({
 				teamId: vercelConfig.teamId,
@@ -67,7 +88,10 @@ var SandboxExecutorFactory = class SandboxExecutorFactory {
 	*/
 	async cleanup() {
 		logger.info({}, "Cleaning up sandbox executors");
-		this.nativeExecutor = null;
+		if (this.nativeExecutor) {
+			await this.nativeExecutor.cleanup();
+			this.nativeExecutor = null;
+		}
 		for (const [key, executor] of this.vercelExecutors.entries()) {
 			await executor.cleanup();
 			this.vercelExecutors.delete(key);

package/dist/domains/run/tools/VercelSandboxExecutor.d.ts

@@ -15,15 +15,12 @@ interface ExecutionResult {
  * Caches and reuses sandboxes based on dependencies to improve performance
  */
 declare class VercelSandboxExecutor {
-  private static instance;
   private config;
   private sandboxPool;
   private cleanupInterval;
-  private constructor();
-  /**
-   * Get singleton instance of VercelSandboxExecutor
-   */
-  static getInstance(config: VercelSandboxConfig): VercelSandboxExecutor;
+  private sandboxInitPromises;
+  constructor(config: VercelSandboxConfig);
+  private getOrCreateSandbox;
   /**
    * Generate a hash for dependencies to use as cache key
    */
@@ -57,11 +54,6 @@ declare class VercelSandboxExecutor {
    * Matches patterns like process.env.VAR_NAME or process.env['VAR_NAME']
    */
   private extractEnvVars;
-  /**
-   * Create .env file content from environment variables
-   * Note: Currently creates empty placeholders. Values will be populated in the future.
-   */
-  private createEnvFileContent;
   /**
    * Execute a function tool in Vercel Sandbox with pooling
    */