@inkeep/agents-run-api 0.22.12 → 0.23.0

package/dist/{SandboxExecutorFactory-FMNUKYDI.js → SandboxExecutorFactory-VKLSUHMW.js}

@@ -1,7 +1,7 @@
 import { getLogger as getLogger$1 } from './chunk-A2S7GSHL.js';
 import { __publicField } from './chunk-PKBMQBKP.js';
 import { spawn } from 'child_process';
-import { createHash } from 'crypto';
+import crypto, { createHash } from 'crypto';
 import { mkdirSync, existsSync, rmSync, writeFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
@@ -466,6 +466,11 @@ var logger2 = getLogger$1("VercelSandboxExecutor");
 var _VercelSandboxExecutor = class _VercelSandboxExecutor {
   constructor(config) {
     __publicField(this, "config");
+    __publicField(this, "sandboxPool", /* @__PURE__ */ new Map());
+    __publicField(this, "POOL_TTL", 5 * 60 * 1e3);
+    // 5 minutes
+    __publicField(this, "MAX_USE_COUNT", 50);
+    __publicField(this, "cleanupInterval", null);
     this.config = config;
     logger2.info(
       {
@@ -475,8 +480,9 @@ var _VercelSandboxExecutor = class _VercelSandboxExecutor {
         timeout: config.timeout,
         vcpus: config.vcpus
       },
-      "VercelSandboxExecutor initialized"
+      "VercelSandboxExecutor initialized with pooling"
     );
+    this.startPoolCleanup();
   }
   /**
    * Get singleton instance of VercelSandboxExecutor
@@ -488,45 +494,235 @@ var _VercelSandboxExecutor = class _VercelSandboxExecutor {
     return _VercelSandboxExecutor.instance;
   }
   /**
-   * Execute a function tool in Vercel Sandbox
+   * Generate a hash for dependencies to use as cache key
+   */
+  generateDependencyHash(dependencies) {
+    const sorted = Object.keys(dependencies).sort().map((key) => `${key}@${dependencies[key]}`).join(",");
+    return crypto.createHash("md5").update(sorted).digest("hex").substring(0, 8);
+  }
+  /**
+   * Get a cached sandbox if available and still valid
+   */
+  getCachedSandbox(dependencyHash) {
+    const cached = this.sandboxPool.get(dependencyHash);
+    if (!cached) return null;
+    const now = Date.now();
+    const age = now - cached.createdAt;
+    if (age > this.POOL_TTL || cached.useCount >= this.MAX_USE_COUNT) {
+      logger2.debug(
+        {
+          dependencyHash,
+          age,
+          useCount: cached.useCount,
+          ttl: this.POOL_TTL,
+          maxUseCount: this.MAX_USE_COUNT
+        },
+        "Sandbox expired, will create new one"
+      );
+      this.removeSandbox(dependencyHash);
+      return null;
+    }
+    logger2.debug(
+      {
+        dependencyHash,
+        useCount: cached.useCount,
+        age
+      },
+      "Reusing cached sandbox"
+    );
+    return cached.sandbox;
+  }
+  /**
+   * Add sandbox to pool
+   */
+  addToPool(dependencyHash, sandbox, dependencies) {
+    this.sandboxPool.set(dependencyHash, {
+      sandbox,
+      createdAt: Date.now(),
+      useCount: 0,
+      dependencies
+    });
+    logger2.debug(
+      {
+        dependencyHash,
+        poolSize: this.sandboxPool.size
+      },
+      "Sandbox added to pool"
+    );
+  }
+  /**
+   * Increment use count for a sandbox
+   */
+  incrementUseCount(dependencyHash) {
+    const cached = this.sandboxPool.get(dependencyHash);
+    if (cached) {
+      cached.useCount++;
+    }
+  }
+  /**
+   * Remove and clean up a sandbox
+   */
+  async removeSandbox(dependencyHash) {
+    const cached = this.sandboxPool.get(dependencyHash);
+    if (cached) {
+      try {
+        await cached.sandbox.stop();
+        logger2.debug({ dependencyHash }, "Sandbox stopped");
+      } catch (error) {
+        logger2.warn({ error, dependencyHash }, "Error stopping sandbox");
+      }
+      this.sandboxPool.delete(dependencyHash);
+    }
+  }
+  /**
+   * Start periodic cleanup of expired sandboxes
+   */
+  startPoolCleanup() {
+    this.cleanupInterval = setInterval(
+      () => {
+        const now = Date.now();
+        const toRemove = [];
+        for (const [hash, cached] of this.sandboxPool.entries()) {
+          const age = now - cached.createdAt;
+          if (age > this.POOL_TTL || cached.useCount >= this.MAX_USE_COUNT) {
+            toRemove.push(hash);
+          }
+        }
+        if (toRemove.length > 0) {
+          logger2.info(
+            {
+              count: toRemove.length,
+              poolSize: this.sandboxPool.size
+            },
+            "Cleaning up expired sandboxes"
+          );
+          for (const hash of toRemove) {
+            this.removeSandbox(hash);
+          }
+        }
+      },
+      60 * 1e3
+      // Run every minute
+    );
+  }
+  /**
+   * Cleanup all sandboxes and stop cleanup interval
+   */
+  async cleanup() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    logger2.info(
+      {
+        poolSize: this.sandboxPool.size
+      },
+      "Cleaning up all sandboxes"
+    );
+    const promises = Array.from(this.sandboxPool.keys()).map((hash) => this.removeSandbox(hash));
+    await Promise.all(promises);
+  }
+  /**
+   * Extract environment variable names from code
+   * Matches patterns like process.env.VAR_NAME or process.env['VAR_NAME']
+   */
+  extractEnvVars(code) {
+    const envVars = /* @__PURE__ */ new Set();
+    const dotNotationRegex = /process\.env\.([A-Z_][A-Z0-9_]*)/g;
+    let match = dotNotationRegex.exec(code);
+    while (match !== null) {
+      envVars.add(match[1]);
+      match = dotNotationRegex.exec(code);
+    }
+    const bracketNotationRegex = /process\.env\[['"]([A-Z_][A-Z0-9_]*)['"]\]/g;
+    match = bracketNotationRegex.exec(code);
+    while (match !== null) {
+      envVars.add(match[1]);
+      match = bracketNotationRegex.exec(code);
+    }
+    return envVars;
+  }
+  /**
+   * Create .env file content from environment variables
+   */
+  createEnvFileContent(envVarNames) {
+    const envLines = [];
+    for (const varName of envVarNames) {
+      const value = process.env[varName];
+      if (value !== void 0) {
+        const escapedValue = value.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+        envLines.push(`${varName}="${escapedValue}"`);
+        logger2.debug({ varName }, "Adding environment variable to sandbox");
+      } else {
+        logger2.warn(
+          { varName },
+          "Environment variable referenced in code but not found in host environment"
+        );
+      }
+    }
+    return envLines.join("\n");
+  }
+  /**
+   * Execute a function tool in Vercel Sandbox with pooling
    */
   async executeFunctionTool(functionId, args, toolConfig) {
     const startTime = Date.now();
     const logs = [];
+    const dependencies = toolConfig.dependencies || {};
+    const dependencyHash = this.generateDependencyHash(dependencies);
     try {
       logger2.info(
         {
           functionId,
-          functionName: toolConfig.name
+          functionName: toolConfig.name,
+          dependencyHash,
+          poolSize: this.sandboxPool.size
         },
         "Executing function in Vercel Sandbox"
       );
-      const 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
-      });
-      logger2.info(
-        {
-          functionId,
-          sandboxId: sandbox.sandboxId
-        },
-        `Sandbox created for function ${functionId}`
-      );
+      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
+        });
+        logger2.info(
+          {
+            functionId,
+            sandboxId: sandbox.sandboxId,
+            dependencyHash
+          },
+          `New sandbox created for function ${functionId}`
+        );
+        this.addToPool(dependencyHash, sandbox, dependencies);
+      } else {
+        logger2.info(
+          {
+            functionId,
+            sandboxId: sandbox.sandboxId,
+            dependencyHash
+          },
+          `Reusing cached sandbox for function ${functionId}`
+        );
+      }
+      this.incrementUseCount(dependencyHash);
       try {
-        if (toolConfig.dependencies && Object.keys(toolConfig.dependencies).length > 0) {
+        if (isNewSandbox && toolConfig.dependencies && Object.keys(toolConfig.dependencies).length > 0) {
           logger2.debug(
             {
               functionId,
               functionName: toolConfig.name,
               dependencies: toolConfig.dependencies
             },
-            "Installing dependencies"
+            "Installing dependencies in new sandbox"
           );
           const packageJson = {
             dependencies: toolConfig.dependencies
@@ -553,15 +749,40 @@ var _VercelSandboxExecutor = class _VercelSandboxExecutor {
           if (installCmd.exitCode !== 0) {
             throw new Error(`Failed to install dependencies: ${installStderr}`);
           }
+          logger2.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";
-        await sandbox.writeFiles([
-          {
-            path: filename,
-            content: Buffer.from(executionCode, "utf-8")
+        filesToWrite.push({
+          path: filename,
+          content: Buffer.from(executionCode, "utf-8")
+        });
+        if (envVars.size > 0) {
+          const envFileContent = this.createEnvFileContent(envVars);
+          if (envFileContent) {
+            filesToWrite.push({
+              path: ".env",
+              content: Buffer.from(envFileContent, "utf-8")
+            });
+            logger2.info(
+              {
+                functionId,
+                envVarCount: envVars.size,
+                envVars: Array.from(envVars)
+              },
+              "Injecting environment variables into sandbox"
+            );
           }
-        ]);
+        }
+        await sandbox.writeFiles(filesToWrite);
         logger2.info(
           {
             functionId,
@@ -569,11 +790,19 @@ var _VercelSandboxExecutor = class _VercelSandboxExecutor {
           },
           `Execution code written to file for runtime ${this.config.runtime}`
         );
-        const runtime = this.config.runtime === "typescript" ? "tsx" : "node";
-        const executeCmd = await sandbox.runCommand({
-          cmd: runtime,
-          args: [filename]
-        });
+        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) {
@@ -613,8 +842,9 @@ var _VercelSandboxExecutor = class _VercelSandboxExecutor {
           logs,
           executionTime
         };
-      } finally {
-        await sandbox.stop();
+      } catch (innerError) {
+        await this.removeSandbox(dependencyHash);
+        throw innerError;
       }
     } catch (error) {
       const executionTime = Date.now() - startTime;
@@ -635,12 +865,6 @@ var _VercelSandboxExecutor = class _VercelSandboxExecutor {
       };
     }
   }
-  /**
-   * Clean up resources
-   */
-  async cleanup() {
-    logger2.info({}, "VercelSandboxExecutor cleanup completed");
-  }
 };
 __publicField(_VercelSandboxExecutor, "instance");
 var VercelSandboxExecutor = _VercelSandboxExecutor;

package/dist/index.cjs

@@ -48,6 +48,7 @@ var fetchToNode = require('fetch-to-node');
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var z6__default = /*#__PURE__*/_interopDefault(z6);
+var crypto__default = /*#__PURE__*/_interopDefault(crypto);
 var jmespath__default = /*#__PURE__*/_interopDefault(jmespath);
 var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
 var destr__default = /*#__PURE__*/_interopDefault(destr);
@@ -858,6 +859,11 @@ var init_VercelSandboxExecutor = __esm({
     _VercelSandboxExecutor = class _VercelSandboxExecutor {
       constructor(config) {
         __publicField(this, "config");
+        __publicField(this, "sandboxPool", /* @__PURE__ */ new Map());
+        __publicField(this, "POOL_TTL", 5 * 60 * 1e3);
+        // 5 minutes
+        __publicField(this, "MAX_USE_COUNT", 50);
+        __publicField(this, "cleanupInterval", null);
         this.config = config;
         logger17.info(
           {
@@ -867,8 +873,9 @@ var init_VercelSandboxExecutor = __esm({
             timeout: config.timeout,
             vcpus: config.vcpus
           },
-          "VercelSandboxExecutor initialized"
+          "VercelSandboxExecutor initialized with pooling"
         );
+        this.startPoolCleanup();
       }
       /**
        * Get singleton instance of VercelSandboxExecutor
@@ -880,45 +887,235 @@ var init_VercelSandboxExecutor = __esm({
         return _VercelSandboxExecutor.instance;
       }
       /**
-       * Execute a function tool in Vercel Sandbox
+       * Generate a hash for dependencies to use as cache key
+       */
+      generateDependencyHash(dependencies) {
+        const sorted = Object.keys(dependencies).sort().map((key) => `${key}@${dependencies[key]}`).join(",");
+        return crypto__default.default.createHash("md5").update(sorted).digest("hex").substring(0, 8);
+      }
+      /**
+       * Get a cached sandbox if available and still valid
+       */
+      getCachedSandbox(dependencyHash) {
+        const cached = this.sandboxPool.get(dependencyHash);
+        if (!cached) return null;
+        const now = Date.now();
+        const age = now - cached.createdAt;
+        if (age > this.POOL_TTL || cached.useCount >= this.MAX_USE_COUNT) {
+          logger17.debug(
+            {
+              dependencyHash,
+              age,
+              useCount: cached.useCount,
+              ttl: this.POOL_TTL,
+              maxUseCount: this.MAX_USE_COUNT
+            },
+            "Sandbox expired, will create new one"
+          );
+          this.removeSandbox(dependencyHash);
+          return null;
+        }
+        logger17.debug(
+          {
+            dependencyHash,
+            useCount: cached.useCount,
+            age
+          },
+          "Reusing cached sandbox"
+        );
+        return cached.sandbox;
+      }
+      /**
+       * Add sandbox to pool
+       */
+      addToPool(dependencyHash, sandbox, dependencies) {
+        this.sandboxPool.set(dependencyHash, {
+          sandbox,
+          createdAt: Date.now(),
+          useCount: 0,
+          dependencies
+        });
+        logger17.debug(
+          {
+            dependencyHash,
+            poolSize: this.sandboxPool.size
+          },
+          "Sandbox added to pool"
+        );
+      }
+      /**
+       * Increment use count for a sandbox
+       */
+      incrementUseCount(dependencyHash) {
+        const cached = this.sandboxPool.get(dependencyHash);
+        if (cached) {
+          cached.useCount++;
+        }
+      }
+      /**
+       * Remove and clean up a sandbox
+       */
+      async removeSandbox(dependencyHash) {
+        const cached = this.sandboxPool.get(dependencyHash);
+        if (cached) {
+          try {
+            await cached.sandbox.stop();
+            logger17.debug({ dependencyHash }, "Sandbox stopped");
+          } catch (error) {
+            logger17.warn({ error, dependencyHash }, "Error stopping sandbox");
+          }
+          this.sandboxPool.delete(dependencyHash);
+        }
+      }
+      /**
+       * Start periodic cleanup of expired sandboxes
+       */
+      startPoolCleanup() {
+        this.cleanupInterval = setInterval(
+          () => {
+            const now = Date.now();
+            const toRemove = [];
+            for (const [hash, cached] of this.sandboxPool.entries()) {
+              const age = now - cached.createdAt;
+              if (age > this.POOL_TTL || cached.useCount >= this.MAX_USE_COUNT) {
+                toRemove.push(hash);
+              }
+            }
+            if (toRemove.length > 0) {
+              logger17.info(
+                {
+                  count: toRemove.length,
+                  poolSize: this.sandboxPool.size
+                },
+                "Cleaning up expired sandboxes"
+              );
+              for (const hash of toRemove) {
+                this.removeSandbox(hash);
+              }
+            }
+          },
+          60 * 1e3
+          // Run every minute
+        );
+      }
+      /**
+       * Cleanup all sandboxes and stop cleanup interval
+       */
+      async cleanup() {
+        if (this.cleanupInterval) {
+          clearInterval(this.cleanupInterval);
+          this.cleanupInterval = null;
+        }
+        logger17.info(
+          {
+            poolSize: this.sandboxPool.size
+          },
+          "Cleaning up all sandboxes"
+        );
+        const promises = Array.from(this.sandboxPool.keys()).map((hash) => this.removeSandbox(hash));
+        await Promise.all(promises);
+      }
+      /**
+       * Extract environment variable names from code
+       * Matches patterns like process.env.VAR_NAME or process.env['VAR_NAME']
+       */
+      extractEnvVars(code) {
+        const envVars = /* @__PURE__ */ new Set();
+        const dotNotationRegex = /process\.env\.([A-Z_][A-Z0-9_]*)/g;
+        let match = dotNotationRegex.exec(code);
+        while (match !== null) {
+          envVars.add(match[1]);
+          match = dotNotationRegex.exec(code);
+        }
+        const bracketNotationRegex = /process\.env\[['"]([A-Z_][A-Z0-9_]*)['"]\]/g;
+        match = bracketNotationRegex.exec(code);
+        while (match !== null) {
+          envVars.add(match[1]);
+          match = bracketNotationRegex.exec(code);
+        }
+        return envVars;
+      }
+      /**
+       * Create .env file content from environment variables
+       */
+      createEnvFileContent(envVarNames) {
+        const envLines = [];
+        for (const varName of envVarNames) {
+          const value = process.env[varName];
+          if (value !== void 0) {
+            const escapedValue = value.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+            envLines.push(`${varName}="${escapedValue}"`);
+            logger17.debug({ varName }, "Adding environment variable to sandbox");
+          } else {
+            logger17.warn(
+              { varName },
+              "Environment variable referenced in code but not found in host environment"
+            );
+          }
+        }
+        return envLines.join("\n");
+      }
+      /**
+       * Execute a function tool in Vercel Sandbox with pooling
        */
       async executeFunctionTool(functionId, args, toolConfig) {
         const startTime = Date.now();
         const logs = [];
+        const dependencies = toolConfig.dependencies || {};
+        const dependencyHash = this.generateDependencyHash(dependencies);
         try {
           logger17.info(
             {
               functionId,
-              functionName: toolConfig.name
+              functionName: toolConfig.name,
+              dependencyHash,
+              poolSize: this.sandboxPool.size
             },
             "Executing function in Vercel Sandbox"
           );
-          const sandbox$1 = await sandbox.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
-          });
-          logger17.info(
-            {
-              functionId,
-              sandboxId: sandbox$1.sandboxId
-            },
-            `Sandbox created for function ${functionId}`
-          );
+          let sandbox$1 = this.getCachedSandbox(dependencyHash);
+          let isNewSandbox = false;
+          if (!sandbox$1) {
+            isNewSandbox = true;
+            sandbox$1 = await sandbox.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
+            });
+            logger17.info(
+              {
+                functionId,
+                sandboxId: sandbox$1.sandboxId,
+                dependencyHash
+              },
+              `New sandbox created for function ${functionId}`
+            );
+            this.addToPool(dependencyHash, sandbox$1, dependencies);
+          } else {
+            logger17.info(
+              {
+                functionId,
+                sandboxId: sandbox$1.sandboxId,
+                dependencyHash
+              },
+              `Reusing cached sandbox for function ${functionId}`
+            );
+          }
+          this.incrementUseCount(dependencyHash);
           try {
-            if (toolConfig.dependencies && Object.keys(toolConfig.dependencies).length > 0) {
+            if (isNewSandbox && toolConfig.dependencies && Object.keys(toolConfig.dependencies).length > 0) {
               logger17.debug(
                 {
                   functionId,
                   functionName: toolConfig.name,
                   dependencies: toolConfig.dependencies
                 },
-                "Installing dependencies"
+                "Installing dependencies in new sandbox"
               );
               const packageJson = {
                 dependencies: toolConfig.dependencies
@@ -945,15 +1142,40 @@ var init_VercelSandboxExecutor = __esm({
               if (installCmd.exitCode !== 0) {
                 throw new Error(`Failed to install dependencies: ${installStderr}`);
               }
+              logger17.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";
-            await sandbox$1.writeFiles([
-              {
-                path: filename,
-                content: Buffer.from(executionCode, "utf-8")
+            filesToWrite.push({
+              path: filename,
+              content: Buffer.from(executionCode, "utf-8")
+            });
+            if (envVars.size > 0) {
+              const envFileContent = this.createEnvFileContent(envVars);
+              if (envFileContent) {
+                filesToWrite.push({
+                  path: ".env",
+                  content: Buffer.from(envFileContent, "utf-8")
+                });
+                logger17.info(
+                  {
+                    functionId,
+                    envVarCount: envVars.size,
+                    envVars: Array.from(envVars)
+                  },
+                  "Injecting environment variables into sandbox"
+                );
               }
-            ]);
+            }
+            await sandbox$1.writeFiles(filesToWrite);
             logger17.info(
               {
                 functionId,
@@ -961,11 +1183,19 @@ var init_VercelSandboxExecutor = __esm({
               },
               `Execution code written to file for runtime ${this.config.runtime}`
             );
-            const runtime = this.config.runtime === "typescript" ? "tsx" : "node";
-            const executeCmd = await sandbox$1.runCommand({
-              cmd: runtime,
-              args: [filename]
-            });
+            const executeCmd = await (async () => {
+              if (envVars.size > 0) {
+                return sandbox$1.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$1.runCommand({
+                cmd: runtime,
+                args: [filename]
+              });
+            })();
             const executeStdout = await executeCmd.stdout();
             const executeStderr = await executeCmd.stderr();
             if (executeStdout) {
@@ -1005,8 +1235,9 @@ var init_VercelSandboxExecutor = __esm({
               logs,
               executionTime
             };
-          } finally {
-            await sandbox$1.stop();
+          } catch (innerError) {
+            await this.removeSandbox(dependencyHash);
+            throw innerError;
           }
         } catch (error) {
           const executionTime = Date.now() - startTime;
@@ -1027,12 +1258,6 @@ var init_VercelSandboxExecutor = __esm({
           };
         }
       }
-      /**
-       * Clean up resources
-       */
-      async cleanup() {
-        logger17.info({}, "VercelSandboxExecutor cleanup completed");
-      }
     };
     __publicField(_VercelSandboxExecutor, "instance");
     VercelSandboxExecutor = _VercelSandboxExecutor;

package/dist/index.js

@@ -7048,7 +7048,7 @@ var Agent = class {
       if (functionToolsData.length === 0) {
         return functionTools;
       }
-      const { SandboxExecutorFactory } = await import('./SandboxExecutorFactory-FMNUKYDI.js');
+      const { SandboxExecutorFactory } = await import('./SandboxExecutorFactory-VKLSUHMW.js');
       const sandboxExecutor = SandboxExecutorFactory.getInstance();
       for (const functionToolDef of functionToolsData) {
         const functionId = functionToolDef.functionId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/agents-run-api",
-  "version": "0.22.12",
+  "version": "0.23.0",
   "description": "Agents Run API for Inkeep Agent Framework - handles chat, agent execution, and streaming",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -52,7 +52,7 @@
     "traverse": "^0.6.11",
     "ts-pattern": "^5.7.1",
     "zod": "^4.1.11",
-    "@inkeep/agents-core": "^0.22.12"
+    "@inkeep/agents-core": "^0.23.0"
   },
   "optionalDependencies": {
     "keytar": "^7.9.0"