@inkeep/agents-api 0.0.0-dev-20260121234635 → 0.0.0-dev-20260122001454

package/dist/.well-known/workflow/v1/manifest.debug.json

@@ -1,5 +1,16 @@
 {
   "steps": {
+    "node_modules/.pnpm/workflow@4.0.1-beta.33_@aws-sdk+client-sts@3.970.0_@opentelemetry+api@1.9.0_@types+reac_5c488396978166b4f12e99cb3aa4a769/node_modules/workflow/dist/internal/builtins.js": {
+      "__builtin_response_array_buffer": {
+        "stepId": "__builtin_response_array_buffer"
+      },
+      "__builtin_response_json": {
+        "stepId": "__builtin_response_json"
+      },
+      "__builtin_response_text": {
+        "stepId": "__builtin_response_text"
+      }
+    },
     "src/domains/evals/workflow/functions/evaluateConversation.ts": {
       "executeEvaluatorStep": {
         "stepId": "step//src/domains/evals/workflow/functions/evaluateConversation.ts//executeEvaluatorStep"
@@ -14,17 +25,6 @@
         "stepId": "step//src/domains/evals/workflow/functions/evaluateConversation.ts//logStep"
       }
     },
-    "node_modules/.pnpm/workflow@4.0.1-beta.33_@aws-sdk+client-sts@3.970.0_@opentelemetry+api@1.9.0_@types+reac_5c488396978166b4f12e99cb3aa4a769/node_modules/workflow/dist/internal/builtins.js": {
-      "__builtin_response_array_buffer": {
-        "stepId": "__builtin_response_array_buffer"
-      },
-      "__builtin_response_json": {
-        "stepId": "__builtin_response_json"
-      },
-      "__builtin_response_text": {
-        "stepId": "__builtin_response_text"
-      }
-    },
     "src/domains/evals/workflow/functions/runDatasetItem.ts": {
       "callChatApiStep": {
         "stepId": "step//src/domains/evals/workflow/functions/runDatasetItem.ts//callChatApiStep"

package/dist/createApp.d.ts

@@ -1,10 +1,10 @@
 import { AppConfig } from "./types/app.js";
 import "./types/index.js";
 import { Hono } from "hono";
-import * as hono_types0 from "hono/types";
+import * as hono_types8 from "hono/types";
 
 //#region src/createApp.d.ts
 declare const isWebhookRoute: (path: string) => boolean;
-declare function createAgentsHono(config: AppConfig): Hono<hono_types0.BlankEnv, hono_types0.BlankSchema, "/">;
+declare function createAgentsHono(config: AppConfig): Hono<hono_types8.BlankEnv, hono_types8.BlankSchema, "/">;
 //#endregion
 export { createAgentsHono, isWebhookRoute };

package/dist/domains/evals/routes/datasetTriggers.d.ts

@@ -1,7 +1,7 @@
 import { OpenAPIHono } from "@hono/zod-openapi";
-import * as hono14 from "hono";
+import * as hono16 from "hono";
 
 //#region src/domains/evals/routes/datasetTriggers.d.ts
-declare const app: OpenAPIHono<hono14.Env, {}, "/">;
+declare const app: OpenAPIHono<hono16.Env, {}, "/">;
 //#endregion
 export { app as default };

package/dist/domains/evals/routes/index.d.ts

@@ -1,7 +1,7 @@
 import { OpenAPIHono } from "@hono/zod-openapi";
-import * as hono15 from "hono";
+import * as hono17 from "hono";
 
 //#region src/domains/evals/routes/index.d.ts
-declare const app: OpenAPIHono<hono15.Env, {}, "/">;
+declare const app: OpenAPIHono<hono17.Env, {}, "/">;
 //#endregion
 export { app as default };

package/dist/domains/evals/workflow/routes.d.ts

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

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

@@ -1,7 +1,7 @@
 import { OpenAPIHono } from "@hono/zod-openapi";
-import * as hono17 from "hono";
+import * as hono14 from "hono";
 
 //#region src/domains/manage/routes/conversations.d.ts
-declare const app: OpenAPIHono<hono17.Env, {}, "/">;
+declare const app: OpenAPIHono<hono14.Env, {}, "/">;
 //#endregion
 export { app as default };

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

@@ -1,7 +1,7 @@
 import { OpenAPIHono } from "@hono/zod-openapi";
-import * as hono16 from "hono";
+import * as hono15 from "hono";
 
 //#region src/domains/manage/routes/index.d.ts
-declare const app: OpenAPIHono<hono16.Env, {}, "/">;
+declare const app: OpenAPIHono<hono15.Env, {}, "/">;
 //#endregion
 export { app as default };

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_types3 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_types3.BlankEnv, hono_types3.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_core2 from "@inkeep/agents-core";
+import * as _inkeep_agents_core1 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_core2.Message | _inkeep_agents_core2.Task;
+  result: _inkeep_agents_core1.Message | _inkeep_agents_core1.Task;
 }>;
 /**
  * Parameters for building a transfer relation config

package/dist/domains/run/routes/webhooks.js

@@ -6,7 +6,7 @@ import { createSSEStreamHelper } from "../utils/stream-helpers.js";
 import { ExecutionHandler } from "../handlers/executionHandler.js";
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
 import { JsonTransformer, createApiError, createMessage, createOrGetConversation, createTriggerInvocation, generateId, getConversationId, getFullProjectWithRelationIds, getTriggerById, interpolateTemplate, setActiveAgentForConversation, updateTriggerInvocationStatus, verifySigningSecret, verifyTriggerAuth, withRef } from "@inkeep/agents-core";
-import { context, propagation, trace } from "@opentelemetry/api";
+import { ROOT_CONTEXT, context, propagation, trace } from "@opentelemetry/api";
 import Ajv from "ajv";
 
 //#region src/domains/run/routes/webhooks.ts
@@ -232,18 +232,12 @@ async function invokeAgentAsync(params) {
 		"message.content": userMessage,
 		"message.parts": JSON.stringify(messageParts),
 		"message.timestamp": (/* @__PURE__ */ new Date()).toISOString()
-	} }, async (span) => {
-		let currentBag = propagation.getBaggage(context.active());
-		if (!currentBag) currentBag = propagation.createBaggage();
-		currentBag = currentBag.setEntry("conversation.id", { value: conversationId });
-		currentBag = currentBag.setEntry("tenant.id", { value: tenantId });
-		currentBag = currentBag.setEntry("project.id", { value: projectId });
-		currentBag = currentBag.setEntry("agent.id", { value: agentId });
-		currentBag = currentBag.setEntry("invocation.type", { value: "trigger" });
-		currentBag = currentBag.setEntry("trigger.id", { value: triggerId });
-		currentBag = currentBag.setEntry("trigger.invocation.id", { value: invocationId });
-		const ctxWithBaggage = propagation.setBaggage(context.active(), currentBag);
-		return await context.with(ctxWithBaggage, async () => {
+	} }, ROOT_CONTEXT, async (span) => {
+		const spanCtx = trace.setSpan(ROOT_CONTEXT, span);
+		let bag = propagation.getBaggage(spanCtx) ?? propagation.createBaggage();
+		bag = bag.setEntry("conversation.id", { value: conversationId }).setEntry("tenant.id", { value: tenantId }).setEntry("project.id", { value: projectId }).setEntry("agent.id", { value: agentId }).setEntry("invocation.type", { value: "trigger" }).setEntry("trigger.id", { value: triggerId }).setEntry("trigger.invocation.id", { value: invocationId });
+		const ctx = propagation.setBaggage(spanCtx, bag);
+		return await context.with(ctx, async () => {
 			try {
 				logger.info({
 					tenantId,

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
    */

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/utils/token-estimator.d.ts

@@ -1,4 +1,4 @@
-import * as _inkeep_agents_core1 from "@inkeep/agents-core";
+import * as _inkeep_agents_core3 from "@inkeep/agents-core";
 import { BreakdownComponentDef, ContextBreakdown, calculateBreakdownTotal, createEmptyBreakdown } from "@inkeep/agents-core";
 
 //#region src/domains/run/utils/token-estimator.d.ts
@@ -17,7 +17,7 @@ interface AssembleResult {
   /** The assembled prompt string */
   prompt: string;
   /** Token breakdown for each component */
-  breakdown: _inkeep_agents_core1.ContextBreakdown;
+  breakdown: _inkeep_agents_core3.ContextBreakdown;
 }
 //#endregion
 export { AssembleResult, type BreakdownComponentDef, type ContextBreakdown, calculateBreakdownTotal, createEmptyBreakdown, estimateTokens };

package/dist/factory.d.ts

@@ -7,7 +7,7 @@ import * as hono0 from "hono";
 import { CredentialStore, ServerConfig } from "@inkeep/agents-core";
 import * as zod0 from "zod";
 import { SSOProviderConfig, UserAuthConfig } from "@inkeep/agents-core/auth";
-import * as hono_types1 from "hono/types";
+import * as hono_types0 from "hono/types";
 import * as better_auth0 from "better-auth";
 import * as better_auth_plugins0 from "better-auth/plugins";
 import * as _better_auth_sso0 from "@better-auth/sso";
@@ -1536,6 +1536,6 @@ declare function createAgentsApp(config?: {
   auth?: UserAuthConfig;
   sandboxConfig?: SandboxConfig;
   skipInitialization?: boolean;
-}): hono0.Hono<hono_types1.BlankEnv, hono_types1.BlankSchema, "/">;
+}): hono0.Hono<hono_types0.BlankEnv, hono_types0.BlankSchema, "/">;
 //#endregion
 export { type SSOProviderConfig, type UserAuthConfig, createAgentsApp, createAgentsAuth, createAgentsHono, createAuth0Provider, createOIDCProvider, initializeDefaultUser };

package/dist/index.d.ts

@@ -8,7 +8,7 @@ import { createAuth0Provider, createOIDCProvider } from "./ssoHelpers.js";
 import { SSOProviderConfig, UserAuthConfig, createAgentsApp } from "./factory.js";
 import { Hono } from "hono";
 import * as zod205 from "zod";
-import * as hono_types3 from "hono/types";
+import * as hono_types5 from "hono/types";
 import * as better_auth78 from "better-auth";
 import * as better_auth_plugins69 from "better-auth/plugins";
 import * as _better_auth_sso10 from "@better-auth/sso";
@@ -1531,6 +1531,6 @@ declare const auth: better_auth78.Auth<{
     }>;
   }];
 }> | null;
-declare const app: Hono<hono_types3.BlankEnv, hono_types3.BlankSchema, "/">;
+declare const app: Hono<hono_types5.BlankEnv, hono_types5.BlankSchema, "/">;
 //#endregion
 export { type AppConfig, type AppVariables, Hono, type NativeSandboxConfig, type SSOProviderConfig, type SandboxConfig, type UserAuthConfig, type VercelSandboxConfig, auth, createAgentsApp, createAgentsHono, createAuth0Provider, createOIDCProvider, app as default, initializeDefaultUser };

package/dist/middleware/manageAuth.d.ts

@@ -1,4 +1,4 @@
-import * as hono3 from "hono";
+import * as hono12 from "hono";
 import { BaseExecutionContext } from "@inkeep/agents-core";
 import { createAuth } from "@inkeep/agents-core/auth";
 
@@ -12,7 +12,7 @@ import { createAuth } from "@inkeep/agents-core/auth";
  * 3. Database API key
  * 4. Internal service token
  */
-declare const manageApiKeyAuth: () => hono3.MiddlewareHandler<{
+declare const manageApiKeyAuth: () => hono12.MiddlewareHandler<{
   Variables: {
     executionContext: BaseExecutionContext;
     userId?: string;

package/dist/middleware/projectAccess.d.ts

@@ -1,5 +1,5 @@
 import { ManageAppVariables } from "../types/app.js";
-import * as hono4 from "hono";
+import * as hono13 from "hono";
 
 //#region src/middleware/projectAccess.d.ts
 
@@ -26,6 +26,6 @@ declare const requireProjectPermission: <Env$1 extends {
   Variables: ManageAppVariables;
 } = {
   Variables: ManageAppVariables;
-}>(permission?: ProjectPermission) => hono4.MiddlewareHandler<Env$1, string, {}, Response>;
+}>(permission?: ProjectPermission) => hono13.MiddlewareHandler<Env$1, string, {}, Response>;
 //#endregion
 export { ProjectPermission, requireProjectPermission };

package/dist/middleware/requirePermission.d.ts

@@ -1,5 +1,5 @@
 import { ManageAppVariables } from "../types/app.js";
-import * as hono5 from "hono";
+import * as hono3 from "hono";
 
 //#region src/middleware/requirePermission.d.ts
 type Permission = {
@@ -9,6 +9,6 @@ declare const requirePermission: <Env$1 extends {
   Variables: ManageAppVariables;
 } = {
   Variables: ManageAppVariables;
-}>(permissions: Permission) => hono5.MiddlewareHandler<Env$1, string, {}, Response>;
+}>(permissions: Permission) => hono3.MiddlewareHandler<Env$1, string, {}, Response>;
 //#endregion
 export { requirePermission };

package/dist/middleware/runAuth.d.ts

@@ -1,8 +1,8 @@
-import * as hono11 from "hono";
+import * as hono4 from "hono";
 import { BaseExecutionContext } from "@inkeep/agents-core";
 
 //#region src/middleware/runAuth.d.ts
-declare const runApiKeyAuth: () => hono11.MiddlewareHandler<{
+declare const runApiKeyAuth: () => hono4.MiddlewareHandler<{
   Variables: {
     executionContext: BaseExecutionContext;
   };
@@ -11,7 +11,7 @@ declare const runApiKeyAuth: () => hono11.MiddlewareHandler<{
  * Creates a middleware that applies API key authentication except for specified route patterns
  * @param skipRouteCheck - Function that returns true if the route should skip authentication
  */
-declare const runApiKeyAuthExcept: (skipRouteCheck: (path: string) => boolean) => hono11.MiddlewareHandler<{
+declare const runApiKeyAuthExcept: (skipRouteCheck: (path: string) => boolean) => hono4.MiddlewareHandler<{
   Variables: {
     executionContext: BaseExecutionContext;
   };
@@ -20,7 +20,7 @@ declare const runApiKeyAuthExcept: (skipRouteCheck: (path: string) => boolean) =
  * Helper middleware for endpoints that optionally support API key authentication
  * If no auth header is present, it continues without setting the executionContext
  */
-declare const runOptionalAuth: () => hono11.MiddlewareHandler<{
+declare const runOptionalAuth: () => hono4.MiddlewareHandler<{
   Variables: {
     executionContext?: BaseExecutionContext;
   };

package/dist/middleware/tenantAccess.d.ts

@@ -1,4 +1,4 @@
-import * as hono6 from "hono";
+import * as hono9 from "hono";
 
 //#region src/middleware/tenantAccess.d.ts
 
@@ -11,7 +11,7 @@ import * as hono6 from "hono";
  * - API key user: Access only to the tenant associated with the API key
  * - Session user: Access based on organization membership
  */
-declare const requireTenantAccess: () => hono6.MiddlewareHandler<{
+declare const requireTenantAccess: () => hono9.MiddlewareHandler<{
   Variables: {
     userId: string;
     tenantId: string;

package/dist/middleware/tracing.d.ts

@@ -1,7 +1,7 @@
-import * as hono9 from "hono";
+import * as hono10 from "hono";
 
 //#region src/middleware/tracing.d.ts
-declare const otelBaggageMiddleware: () => hono9.MiddlewareHandler<any, string, {}, Response>;
-declare const executionBaggageMiddleware: () => hono9.MiddlewareHandler<any, string, {}, Response>;
+declare const otelBaggageMiddleware: () => hono10.MiddlewareHandler<any, string, {}, Response>;
+declare const executionBaggageMiddleware: () => hono10.MiddlewareHandler<any, string, {}, Response>;
 //#endregion
 export { executionBaggageMiddleware, otelBaggageMiddleware };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/agents-api",
-  "version": "0.0.0-dev-20260121234635",
+  "version": "0.0.0-dev-20260122001454",
   "description": "Unified Inkeep Agents API - combines management, runtime, and evaluation capabilities",
   "types": "dist/index.d.ts",
   "exports": {
@@ -70,8 +70,8 @@
     "openid-client": "^6.8.1",
     "pg": "^8.16.3",
     "workflow": "4.0.1-beta.33",
-    "@inkeep/agents-core": "^0.0.0-dev-20260121234635",
-    "@inkeep/agents-manage-mcp": "^0.0.0-dev-20260121234635"
+    "@inkeep/agents-core": "^0.0.0-dev-20260122001454",
+    "@inkeep/agents-manage-mcp": "^0.0.0-dev-20260122001454"
   },
   "peerDependencies": {
     "@hono/zod-openapi": "^1.1.5",