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

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_core3 from "@inkeep/agents-core";
+import * as _inkeep_agents_core1 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_core3.ContextBreakdown;
+  breakdown: _inkeep_agents_core1.ContextBreakdown;
 }
 //#endregion
 export { AssembleResult, type BreakdownComponentDef, type ContextBreakdown, calculateBreakdownTotal, createEmptyBreakdown, estimateTokens };

package/dist/middleware/evalsAuth.d.ts

@@ -1,4 +1,4 @@
-import * as hono6 from "hono";
+import * as hono1 from "hono";
 import { BaseExecutionContext } from "@inkeep/agents-core";
 
 //#region src/middleware/evalsAuth.d.ts
@@ -7,7 +7,7 @@ import { BaseExecutionContext } from "@inkeep/agents-core";
  * Middleware to authenticate API requests using Bearer token authentication
  * First checks if token matches INKEEP_AGENTS_EVAL_API_BYPASS_SECRET,
  */
-declare const evalApiKeyAuth: () => hono6.MiddlewareHandler<{
+declare const evalApiKeyAuth: () => hono1.MiddlewareHandler<{
   Variables: {
     executionContext: BaseExecutionContext;
   };

package/dist/middleware/manageAuth.d.ts

@@ -1,4 +1,4 @@
-import * as hono0 from "hono";
+import * as hono2 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: () => hono0.MiddlewareHandler<{
+declare const manageApiKeyAuth: () => hono2.MiddlewareHandler<{
   Variables: {
     executionContext: BaseExecutionContext;
     userId?: string;

package/dist/middleware/projectAccess.d.ts

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

package/dist/middleware/projectConfig.d.ts

@@ -1,11 +1,11 @@
-import * as hono2 from "hono";
+import * as hono4 from "hono";
 import { BaseExecutionContext, ResolvedRef } from "@inkeep/agents-core";
 
 //#region src/middleware/projectConfig.d.ts
 /**
  * Middleware that fetches the full project definition from the Management API
  */
-declare const projectConfigMiddleware: hono2.MiddlewareHandler<{
+declare const projectConfigMiddleware: hono4.MiddlewareHandler<{
   Variables: {
     executionContext: BaseExecutionContext;
     resolvedRef: ResolvedRef;
@@ -15,7 +15,7 @@ declare const projectConfigMiddleware: hono2.MiddlewareHandler<{
  * Creates a middleware that applies project config fetching except for specified route patterns
  * @param skipRouteCheck - Function that returns true if the route should skip the middleware
  */
-declare const projectConfigMiddlewareExcept: (skipRouteCheck: (path: string) => boolean) => hono2.MiddlewareHandler<{
+declare const projectConfigMiddlewareExcept: (skipRouteCheck: (path: string) => boolean) => hono4.MiddlewareHandler<{
   Variables: {
     executionContext: BaseExecutionContext;
     resolvedRef: ResolvedRef;

package/dist/middleware/requirePermission.d.ts

@@ -1,5 +1,5 @@
 import { ManageAppVariables } from "../types/app.js";
-import * as hono7 from "hono";
+import * as hono6 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) => hono7.MiddlewareHandler<Env$1, string, {}, Response>;
+}>(permissions: Permission) => hono6.MiddlewareHandler<Env$1, string, {}, Response>;
 //#endregion
 export { requirePermission };

package/dist/middleware/runAuth.d.ts

@@ -1,8 +1,8 @@
-import * as hono13 from "hono";
+import * as hono7 from "hono";
 import { BaseExecutionContext } from "@inkeep/agents-core";
 
 //#region src/middleware/runAuth.d.ts
-declare const runApiKeyAuth: () => hono13.MiddlewareHandler<{
+declare const runApiKeyAuth: () => hono7.MiddlewareHandler<{
   Variables: {
     executionContext: BaseExecutionContext;
   };
@@ -11,7 +11,7 @@ declare const runApiKeyAuth: () => hono13.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) => hono13.MiddlewareHandler<{
+declare const runApiKeyAuthExcept: (skipRouteCheck: (path: string) => boolean) => hono7.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: () => hono13.MiddlewareHandler<{
+declare const runOptionalAuth: () => hono7.MiddlewareHandler<{
   Variables: {
     executionContext?: BaseExecutionContext;
   };

package/dist/middleware/sessionAuth.d.ts

@@ -1,4 +1,4 @@
-import * as hono8 from "hono";
+import * as hono10 from "hono";
 
 //#region src/middleware/sessionAuth.d.ts
 
@@ -7,11 +7,11 @@ import * as hono8 from "hono";
  * Requires that a user has already been authenticated via Better Auth session.
  * Used primarily for manage routes that require an active user session.
  */
-declare const sessionAuth: () => hono8.MiddlewareHandler<any, string, {}, Response>;
+declare const sessionAuth: () => hono10.MiddlewareHandler<any, string, {}, Response>;
 /**
  * Global session middleware - sets user and session in context for all routes
  * Used for all routes that require an active user session.
  */
-declare const sessionContext: () => hono8.MiddlewareHandler<any, string, {}, Response>;
+declare const sessionContext: () => hono10.MiddlewareHandler<any, string, {}, Response>;
 //#endregion
 export { sessionAuth, sessionContext };

package/dist/middleware/tenantAccess.d.ts

@@ -1,4 +1,4 @@
-import * as hono10 from "hono";
+import * as hono12 from "hono";
 
 //#region src/middleware/tenantAccess.d.ts
 
@@ -11,7 +11,7 @@ import * as hono10 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: () => hono10.MiddlewareHandler<{
+declare const requireTenantAccess: () => hono12.MiddlewareHandler<{
   Variables: {
     userId: string;
     tenantId: string;

package/dist/middleware/tracing.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/agents-api",
-  "version": "0.0.0-dev-20260121225854",
+  "version": "0.0.0-dev-20260122001146",
   "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-20260121225854",
-    "@inkeep/agents-manage-mcp": "^0.0.0-dev-20260121225854"
+    "@inkeep/agents-core": "^0.0.0-dev-20260122001146",
+    "@inkeep/agents-manage-mcp": "^0.0.0-dev-20260122001146"
   },
   "peerDependencies": {
     "@hono/zod-openapi": "^1.1.5",