@inkeep/agents-run-api 0.18.0 → 0.19.0

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/{chunk-DQQRVSJS.js → chunk-QRT6EIUX.js}

@@ -75,7 +75,7 @@ async function getScopedHistory({
       let matchesAgent = true;
       let matchesTask = true;
       if (filters.subAgentId) {
-        matchesAgent = msg.role === "agent" && msg.visibility === "user-facing" || msg.toAgentId === filters.subAgentId || msg.fromAgentId === filters.subAgentId;
+        matchesAgent = msg.role === "agent" && msg.visibility === "user-facing" || msg.toSubAgentId === filters.subAgentId || msg.fromSubAgentId === filters.subAgentId;
       }
       if (filters.taskId) {
         matchesTask = msg.taskId === filters.taskId || msg.a2aTaskId === filters.taskId;
@@ -150,12 +150,12 @@ async function getFormattedConversationHistory({
     if (msg.role === "user") {
       roleLabel = "user";
     } else if (msg.role === "agent" && (msg.messageType === "a2a-request" || msg.messageType === "a2a-response")) {
-      const fromAgent = msg.fromAgentId || msg.fromExternalAgentId || "unknown";
-      const toAgent = msg.toAgentId || msg.toExternalAgentId || "unknown";
-      roleLabel = `${fromAgent} to ${toAgent}`;
+      const fromSubAgent = msg.fromSubAgentId || msg.fromExternalAgentId || "unknown";
+      const toSubAgent = msg.toSubAgentId || msg.toExternalAgentId || "unknown";
+      roleLabel = `${fromSubAgent} to ${toSubAgent}`;
     } else if (msg.role === "agent" && msg.messageType === "chat") {
-      const fromAgent = msg.fromAgentId || "unknown";
-      roleLabel = `${fromAgent} to User`;
+      const fromSubAgent = msg.fromSubAgentId || "unknown";
+      roleLabel = `${fromSubAgent} to User`;
     } else {
       roleLabel = msg.role || "system";
     }

package/dist/{conversations-JSORLLWS.js → conversations-OFIM2WLJ.js}

@@ -1 +1 @@
-export { createDefaultConversationHistoryConfig, getConversationScopedArtifacts, getFormattedConversationHistory, getFullConversationContext, getScopedHistory, getUserFacingHistory, saveA2AMessageResponse } from './chunk-DQQRVSJS.js';
+export { createDefaultConversationHistoryConfig, getConversationScopedArtifacts, getFormattedConversationHistory, getFullConversationContext, getScopedHistory, getUserFacingHistory, saveA2AMessageResponse } from './chunk-QRT6EIUX.js';