@inkeep/agents-run-api 0.18.0 → 0.18.1

package/dist/{LocalSandboxExecutor-PQIRECLQ.js → LocalSandboxExecutor-2UQ32ZZH.js}

@@ -7,6 +7,58 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 
 var logger = getLogger("local-sandbox-executor");
+var ExecutionSemaphore = class {
+  constructor(permits, maxWaitTimeMs = 3e4) {
+    __publicField(this, "permits");
+    __publicField(this, "waitQueue", []);
+    __publicField(this, "maxWaitTime");
+    this.permits = Math.max(1, permits);
+    this.maxWaitTime = maxWaitTimeMs;
+  }
+  async acquire(fn) {
+    await new Promise((resolve, reject) => {
+      if (this.permits > 0) {
+        this.permits--;
+        resolve();
+        return;
+      }
+      const timeoutId = setTimeout(() => {
+        const index = this.waitQueue.findIndex((item) => item.resolve === resolve);
+        if (index !== -1) {
+          this.waitQueue.splice(index, 1);
+          reject(
+            new Error(
+              `Function execution queue timeout after ${this.maxWaitTime}ms. Too many concurrent executions.`
+            )
+          );
+        }
+      }, this.maxWaitTime);
+      this.waitQueue.push({
+        resolve: () => {
+          clearTimeout(timeoutId);
+          this.permits--;
+          resolve();
+        },
+        reject
+      });
+    });
+    try {
+      return await fn();
+    } finally {
+      this.permits++;
+      const next = this.waitQueue.shift();
+      if (next) {
+        next.resolve();
+      }
+    }
+  }
+  getAvailablePermits() {
+    return this.permits;
+  }
+  getQueueLength() {
+    return this.waitQueue.length;
+  }
+};
 var _LocalSandboxExecutor = class _LocalSandboxExecutor {
   constructor() {
     __publicField(this, "tempDir");
@@ -14,6 +66,7 @@ var _LocalSandboxExecutor = class _LocalSandboxExecutor {
     __publicField(this, "POOL_TTL", 5 * 60 * 1e3);
     // 5 minutes
     __publicField(this, "MAX_USE_COUNT", 50);
+    __publicField(this, "executionSemaphores", /* @__PURE__ */ new Map());
     this.tempDir = join(tmpdir(), "inkeep-sandboxes");
     this.ensureTempDir();
     this.startPoolCleanup();
@@ -24,6 +77,34 @@ var _LocalSandboxExecutor = class _LocalSandboxExecutor {
     }
     return _LocalSandboxExecutor.instance;
   }
+  /**
+   * Get or create a semaphore for the specified vCPU limit
+   */
+  getSemaphore(vcpus) {
+    const effectiveVcpus = Math.max(1, vcpus || 1);
+    if (!this.executionSemaphores.has(effectiveVcpus)) {
+      logger.debug({ vcpus: effectiveVcpus }, "Creating new execution semaphore");
+      this.executionSemaphores.set(effectiveVcpus, new ExecutionSemaphore(effectiveVcpus));
+    }
+    const semaphore = this.executionSemaphores.get(effectiveVcpus);
+    if (!semaphore) {
+      throw new Error(`Failed to create semaphore for ${effectiveVcpus} vCPUs`);
+    }
+    return semaphore;
+  }
+  /**
+   * Get execution statistics for monitoring and debugging
+   */
+  getExecutionStats() {
+    const stats = {};
+    for (const [vcpus, semaphore] of this.executionSemaphores.entries()) {
+      stats[`vcpu_${vcpus}`] = {
+        availablePermits: semaphore.getAvailablePermits(),
+        queueLength: semaphore.getQueueLength()
+      };
+    }
+    return stats;
+  }
   ensureTempDir() {
     try {
       mkdirSync(this.tempDir, { recursive: true });
@@ -98,7 +179,7 @@ var _LocalSandboxExecutor = class _LocalSandboxExecutor {
       }
     }, 6e4);
   }
-  detectModuleType(executeCode) {
+  detectModuleType(executeCode, configuredRuntime) {
     const esmPatterns = [
       /import\s+.*\s+from\s+['"]/g,
       // import ... from '...'
@@ -119,6 +200,9 @@ var _LocalSandboxExecutor = class _LocalSandboxExecutor {
     ];
     const hasEsmSyntax = esmPatterns.some((pattern) => pattern.test(executeCode));
     const hasCjsSyntax = cjsPatterns.some((pattern) => pattern.test(executeCode));
+    if (configuredRuntime === "typescript") {
+      return hasCjsSyntax ? "cjs" : "esm";
+    }
     if (hasEsmSyntax && hasCjsSyntax) {
       logger.warn(
         { executeCode: `${executeCode.substring(0, 100)}...` },
@@ -135,6 +219,24 @@ var _LocalSandboxExecutor = class _LocalSandboxExecutor {
     return "cjs";
   }
   async executeFunctionTool(toolId, args, config) {
+    const vcpus = config.sandboxConfig?.vcpus || 1;
+    const semaphore = this.getSemaphore(vcpus);
+    logger.debug(
+      {
+        toolId,
+        vcpus,
+        availablePermits: semaphore.getAvailablePermits(),
+        queueLength: semaphore.getQueueLength(),
+        sandboxConfig: config.sandboxConfig,
+        poolSize: Object.keys(this.sandboxPool).length
+      },
+      "Acquiring execution slot for function tool"
+    );
+    return semaphore.acquire(async () => {
+      return this.executeInSandbox_Internal(toolId, args, config);
+    });
+  }
+  async executeInSandbox_Internal(toolId, args, config) {
     const dependencies = config.dependencies || {};
     const dependencyHash = this.generateDependencyHash(dependencies);
     logger.debug(
@@ -142,6 +244,7 @@ var _LocalSandboxExecutor = class _LocalSandboxExecutor {
         toolId,
         dependencies,
         dependencyHash,
+        sandboxConfig: config.sandboxConfig,
         poolSize: Object.keys(this.sandboxPool).length
       },
       "Executing function tool"
@@ -161,7 +264,7 @@ var _LocalSandboxExecutor = class _LocalSandboxExecutor {
         },
         "Creating new sandbox"
       );
-      const moduleType = this.detectModuleType(config.executeCode);
+      const moduleType = this.detectModuleType(config.executeCode, config.sandboxConfig?.runtime);
       const packageJson = {
         name: `function-tool-${toolId}`,
         version: "1.0.0",
@@ -178,14 +281,15 @@ var _LocalSandboxExecutor = class _LocalSandboxExecutor {
       this.addToPool(dependencyHash, sandboxDir, dependencies);
     }
     try {
-      const moduleType = this.detectModuleType(config.executeCode);
+      const moduleType = this.detectModuleType(config.executeCode, config.sandboxConfig?.runtime);
       const executionCode = this.wrapFunctionCode(config.executeCode, args);
       const fileExtension = moduleType === "esm" ? "mjs" : "js";
       writeFileSync(join(sandboxDir, `index.${fileExtension}`), executionCode, "utf8");
       const result = await this.executeInSandbox(
         sandboxDir,
         config.sandboxConfig?.timeout || 3e4,
-        moduleType
+        moduleType,
+        config.sandboxConfig
       );
       return result;
     } catch (error) {
@@ -224,7 +328,7 @@ var _LocalSandboxExecutor = class _LocalSandboxExecutor {
       });
     });
   }
-  async executeInSandbox(sandboxDir, timeout, moduleType) {
+  async executeInSandbox(sandboxDir, timeout, moduleType, _sandboxConfig) {
     return new Promise((resolve, reject) => {
       const fileExtension = moduleType === "esm" ? "mjs" : "js";
       const spawnOptions = {
@@ -262,12 +366,13 @@ var _LocalSandboxExecutor = class _LocalSandboxExecutor {
       const timeoutId = setTimeout(() => {
         logger.warn({ sandboxDir, timeout }, "Function execution timed out, killing process");
         node.kill("SIGTERM");
+        const forceKillTimeout = Math.min(Math.max(timeout / 10, 2e3), 5e3);
         setTimeout(() => {
           try {
             node.kill("SIGKILL");
           } catch {
           }
-        }, 5e3);
+        }, forceKillTimeout);
         reject(new Error(`Function execution timed out after ${timeout}ms`));
       }, timeout);
       node.on("close", (code, signal) => {

package/dist/index.cjs

@@ -389,10 +389,62 @@ var LocalSandboxExecutor_exports = {};
 __export(LocalSandboxExecutor_exports, {
   LocalSandboxExecutor: () => LocalSandboxExecutor
 });
-var logger17, _LocalSandboxExecutor, LocalSandboxExecutor;
+var logger17, ExecutionSemaphore, _LocalSandboxExecutor, LocalSandboxExecutor;
 var init_LocalSandboxExecutor = __esm({
   "src/tools/LocalSandboxExecutor.ts"() {
     logger17 = agentsCore.getLogger("local-sandbox-executor");
+    ExecutionSemaphore = class {
+      constructor(permits, maxWaitTimeMs = 3e4) {
+        __publicField(this, "permits");
+        __publicField(this, "waitQueue", []);
+        __publicField(this, "maxWaitTime");
+        this.permits = Math.max(1, permits);
+        this.maxWaitTime = maxWaitTimeMs;
+      }
+      async acquire(fn) {
+        await new Promise((resolve, reject) => {
+          if (this.permits > 0) {
+            this.permits--;
+            resolve();
+            return;
+          }
+          const timeoutId = setTimeout(() => {
+            const index = this.waitQueue.findIndex((item) => item.resolve === resolve);
+            if (index !== -1) {
+              this.waitQueue.splice(index, 1);
+              reject(
+                new Error(
+                  `Function execution queue timeout after ${this.maxWaitTime}ms. Too many concurrent executions.`
+                )
+              );
+            }
+          }, this.maxWaitTime);
+          this.waitQueue.push({
+            resolve: () => {
+              clearTimeout(timeoutId);
+              this.permits--;
+              resolve();
+            },
+            reject
+          });
+        });
+        try {
+          return await fn();
+        } finally {
+          this.permits++;
+          const next = this.waitQueue.shift();
+          if (next) {
+            next.resolve();
+          }
+        }
+      }
+      getAvailablePermits() {
+        return this.permits;
+      }
+      getQueueLength() {
+        return this.waitQueue.length;
+      }
+    };
     _LocalSandboxExecutor = class _LocalSandboxExecutor {
       constructor() {
         __publicField(this, "tempDir");
@@ -400,6 +452,7 @@ var init_LocalSandboxExecutor = __esm({
         __publicField(this, "POOL_TTL", 5 * 60 * 1e3);
         // 5 minutes
         __publicField(this, "MAX_USE_COUNT", 50);
+        __publicField(this, "executionSemaphores", /* @__PURE__ */ new Map());
         this.tempDir = path.join(os.tmpdir(), "inkeep-sandboxes");
         this.ensureTempDir();
         this.startPoolCleanup();
@@ -410,6 +463,34 @@ var init_LocalSandboxExecutor = __esm({
         }
         return _LocalSandboxExecutor.instance;
       }
+      /**
+       * Get or create a semaphore for the specified vCPU limit
+       */
+      getSemaphore(vcpus) {
+        const effectiveVcpus = Math.max(1, vcpus || 1);
+        if (!this.executionSemaphores.has(effectiveVcpus)) {
+          logger17.debug({ vcpus: effectiveVcpus }, "Creating new execution semaphore");
+          this.executionSemaphores.set(effectiveVcpus, new ExecutionSemaphore(effectiveVcpus));
+        }
+        const semaphore = this.executionSemaphores.get(effectiveVcpus);
+        if (!semaphore) {
+          throw new Error(`Failed to create semaphore for ${effectiveVcpus} vCPUs`);
+        }
+        return semaphore;
+      }
+      /**
+       * Get execution statistics for monitoring and debugging
+       */
+      getExecutionStats() {
+        const stats = {};
+        for (const [vcpus, semaphore] of this.executionSemaphores.entries()) {
+          stats[`vcpu_${vcpus}`] = {
+            availablePermits: semaphore.getAvailablePermits(),
+            queueLength: semaphore.getQueueLength()
+          };
+        }
+        return stats;
+      }
       ensureTempDir() {
         try {
           fs.mkdirSync(this.tempDir, { recursive: true });
@@ -484,7 +565,7 @@ var init_LocalSandboxExecutor = __esm({
           }
         }, 6e4);
       }
-      detectModuleType(executeCode) {
+      detectModuleType(executeCode, configuredRuntime) {
         const esmPatterns = [
           /import\s+.*\s+from\s+['"]/g,
           // import ... from '...'
@@ -505,6 +586,9 @@ var init_LocalSandboxExecutor = __esm({
         ];
         const hasEsmSyntax = esmPatterns.some((pattern) => pattern.test(executeCode));
         const hasCjsSyntax = cjsPatterns.some((pattern) => pattern.test(executeCode));
+        if (configuredRuntime === "typescript") {
+          return hasCjsSyntax ? "cjs" : "esm";
+        }
         if (hasEsmSyntax && hasCjsSyntax) {
           logger17.warn(
             { executeCode: `${executeCode.substring(0, 100)}...` },
@@ -521,6 +605,24 @@ var init_LocalSandboxExecutor = __esm({
         return "cjs";
       }
       async executeFunctionTool(toolId, args, config) {
+        const vcpus = config.sandboxConfig?.vcpus || 1;
+        const semaphore = this.getSemaphore(vcpus);
+        logger17.debug(
+          {
+            toolId,
+            vcpus,
+            availablePermits: semaphore.getAvailablePermits(),
+            queueLength: semaphore.getQueueLength(),
+            sandboxConfig: config.sandboxConfig,
+            poolSize: Object.keys(this.sandboxPool).length
+          },
+          "Acquiring execution slot for function tool"
+        );
+        return semaphore.acquire(async () => {
+          return this.executeInSandbox_Internal(toolId, args, config);
+        });
+      }
+      async executeInSandbox_Internal(toolId, args, config) {
         const dependencies = config.dependencies || {};
         const dependencyHash = this.generateDependencyHash(dependencies);
         logger17.debug(
@@ -528,6 +630,7 @@ var init_LocalSandboxExecutor = __esm({
             toolId,
             dependencies,
             dependencyHash,
+            sandboxConfig: config.sandboxConfig,
             poolSize: Object.keys(this.sandboxPool).length
           },
           "Executing function tool"
@@ -547,7 +650,7 @@ var init_LocalSandboxExecutor = __esm({
             },
             "Creating new sandbox"
           );
-          const moduleType = this.detectModuleType(config.executeCode);
+          const moduleType = this.detectModuleType(config.executeCode, config.sandboxConfig?.runtime);
           const packageJson = {
             name: `function-tool-${toolId}`,
             version: "1.0.0",
@@ -564,14 +667,15 @@ var init_LocalSandboxExecutor = __esm({
           this.addToPool(dependencyHash, sandboxDir, dependencies);
         }
         try {
-          const moduleType = this.detectModuleType(config.executeCode);
+          const moduleType = this.detectModuleType(config.executeCode, config.sandboxConfig?.runtime);
           const executionCode = this.wrapFunctionCode(config.executeCode, args);
           const fileExtension = moduleType === "esm" ? "mjs" : "js";
           fs.writeFileSync(path.join(sandboxDir, `index.${fileExtension}`), executionCode, "utf8");
           const result = await this.executeInSandbox(
             sandboxDir,
             config.sandboxConfig?.timeout || 3e4,
-            moduleType
+            moduleType,
+            config.sandboxConfig
           );
           return result;
         } catch (error) {
@@ -610,7 +714,7 @@ var init_LocalSandboxExecutor = __esm({
           });
         });
       }
-      async executeInSandbox(sandboxDir, timeout, moduleType) {
+      async executeInSandbox(sandboxDir, timeout, moduleType, _sandboxConfig) {
         return new Promise((resolve, reject) => {
           const fileExtension = moduleType === "esm" ? "mjs" : "js";
           const spawnOptions = {
@@ -648,12 +752,13 @@ var init_LocalSandboxExecutor = __esm({
           const timeoutId = setTimeout(() => {
             logger17.warn({ sandboxDir, timeout }, "Function execution timed out, killing process");
             node.kill("SIGTERM");
+            const forceKillTimeout = Math.min(Math.max(timeout / 10, 2e3), 5e3);
             setTimeout(() => {
               try {
                 node.kill("SIGKILL");
               } catch {
               }
-            }, 5e3);
+            }, forceKillTimeout);
             reject(new Error(`Function execution timed out after ${timeout}ms`));
           }, timeout);
           node.on("close", (code, signal) => {
@@ -8001,11 +8106,21 @@ var Agent = class {
               "Function Tool Called"
             );
             try {
+              const project = await agentsCore.getProject(dbClient_default)({
+                scopes: { tenantId: this.config.tenantId, projectId: this.config.projectId }
+              });
+              const defaultSandboxConfig = {
+                provider: "local",
+                runtime: "node22",
+                timeout: 3e4,
+                vcpus: 1
+              };
               const result = await sandboxExecutor.executeFunctionTool(functionToolDef.id, args, {
                 description: functionToolDef.description || functionToolDef.name,
                 inputSchema: functionData.inputSchema || {},
                 executeCode: functionData.executeCode,
-                dependencies: functionData.dependencies || {}
+                dependencies: functionData.dependencies || {},
+                sandboxConfig: project?.sandboxConfig || defaultSandboxConfig
               });
               toolSessionManager.recordToolResult(sessionId || "", {
                 toolCallId,

package/dist/index.js

@@ -7129,7 +7129,7 @@ var Agent = class {
       if (functionToolsData.length === 0) {
         return functionTools;
       }
-      const { LocalSandboxExecutor } = await import('./LocalSandboxExecutor-PQIRECLQ.js');
+      const { LocalSandboxExecutor } = await import('./LocalSandboxExecutor-2UQ32ZZH.js');
       const sandboxExecutor = LocalSandboxExecutor.getInstance();
       for (const functionToolDef of functionToolsData) {
         const functionId = functionToolDef.functionId;
@@ -7164,11 +7164,21 @@ var Agent = class {
               "Function Tool Called"
             );
             try {
+              const project = await getProject(dbClient_default)({
+                scopes: { tenantId: this.config.tenantId, projectId: this.config.projectId }
+              });
+              const defaultSandboxConfig = {
+                provider: "local",
+                runtime: "node22",
+                timeout: 3e4,
+                vcpus: 1
+              };
               const result = await sandboxExecutor.executeFunctionTool(functionToolDef.id, args, {
                 description: functionToolDef.description || functionToolDef.name,
                 inputSchema: functionData.inputSchema || {},
                 executeCode: functionData.executeCode,
-                dependencies: functionData.dependencies || {}
+                dependencies: functionData.dependencies || {},
+                sandboxConfig: project?.sandboxConfig || defaultSandboxConfig
               });
               toolSessionManager.recordToolResult(sessionId || "", {
                 toolCallId,

package/package.json

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