@inkeep/agents-run-api 0.21.1 → 0.22.1

package/dist/{LocalSandboxExecutor-TSOIXW7O.js → SandboxExecutorFactory-FMNUKYDI.js}

@@ -1,12 +1,60 @@
+import { getLogger as getLogger$1 } from './chunk-A2S7GSHL.js';
 import { __publicField } from './chunk-PKBMQBKP.js';
-import { getLogger } from '@inkeep/agents-core';
 import { spawn } from 'child_process';
 import { createHash } from 'crypto';
 import { mkdirSync, existsSync, rmSync, writeFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
+import { getLogger } from '@inkeep/agents-core';
+import { Sandbox } from '@vercel/sandbox';
+
+// src/tools/sandbox-utils.ts
+function createExecutionWrapper(executeCode, args) {
+  return `
+// Function tool execution wrapper
+const args = ${JSON.stringify(args, null, 2)};
 
-var logger = getLogger("local-sandbox-executor");
+// User's function code
+const execute = ${executeCode}
+
+// Execute the function and output the result
+(async () => {
+  try {
+    const result = await execute(args);
+    // Output result as JSON on the last line
+    console.log(JSON.stringify({ success: true, result }));
+  } catch (error) {
+    console.error(JSON.stringify({ 
+      success: false, 
+      error: error instanceof Error ? error.message : String(error) 
+    }));
+    process.exit(1);
+  }
+})();
+`;
+}
+function parseExecutionResult(stdout, functionId, logger4) {
+  try {
+    const outputLines = stdout.split("\n").filter((line) => line.trim());
+    const resultLine = outputLines[outputLines.length - 1];
+    return JSON.parse(resultLine);
+  } catch (parseError) {
+    if (logger4) {
+      logger4.warn(
+        {
+          functionId,
+          stdout,
+          parseError
+        },
+        "Failed to parse execution result"
+      );
+    }
+    return stdout;
+  }
+}
+
+// src/tools/NativeSandboxExecutor.ts
+var logger = getLogger("native-sandbox-executor");
 var ExecutionSemaphore = class {
   constructor(permits, maxWaitTimeMs = 3e4) {
     __publicField(this, "permits");
@@ -59,7 +107,7 @@ var ExecutionSemaphore = class {
     return this.waitQueue.length;
   }
 };
-var _LocalSandboxExecutor = class _LocalSandboxExecutor {
+var _NativeSandboxExecutor = class _NativeSandboxExecutor {
   constructor() {
     __publicField(this, "tempDir");
     __publicField(this, "sandboxPool", {});
@@ -72,10 +120,10 @@ var _LocalSandboxExecutor = class _LocalSandboxExecutor {
     this.startPoolCleanup();
   }
   static getInstance() {
-    if (!_LocalSandboxExecutor.instance) {
-      _LocalSandboxExecutor.instance = new _LocalSandboxExecutor();
+    if (!_NativeSandboxExecutor.instance) {
+      _NativeSandboxExecutor.instance = new _NativeSandboxExecutor();
     }
-    return _LocalSandboxExecutor.instance;
+    return _NativeSandboxExecutor.instance;
   }
   getSemaphore(vcpus) {
     const effectiveVcpus = Math.max(1, vcpus || 1);
@@ -276,7 +324,7 @@ var _LocalSandboxExecutor = class _LocalSandboxExecutor {
     }
     try {
       const moduleType = this.detectModuleType(config.executeCode, config.sandboxConfig?.runtime);
-      const executionCode = this.wrapFunctionCode(config.executeCode, args);
+      const executionCode = createExecutionWrapper(config.executeCode, args);
       const fileExtension = moduleType === "esm" ? "mjs" : "js";
       writeFileSync(join(sandboxDir, `index.${fileExtension}`), executionCode, "utf8");
       const result = await this.executeInSandbox(
@@ -383,11 +431,16 @@ var _LocalSandboxExecutor = class _LocalSandboxExecutor {
         clearTimeout(timeoutId);
         if (code === 0) {
           try {
-            const result = JSON.parse(stdout);
-            if (result.success) {
-              resolve(result.result);
+            const result = parseExecutionResult(stdout, "function", logger);
+            if (typeof result === "object" && result !== null && "success" in result) {
+              const parsed = result;
+              if (parsed.success) {
+                resolve(parsed.result);
+              } else {
+                reject(new Error(parsed.error || "Function execution failed"));
+              }
             } else {
-              reject(new Error(result.error || "Function execution failed"));
+              resolve(result);
             }
           } catch (parseError) {
             logger.error({ stdout, stderr, parseError }, "Failed to parse function result");
@@ -406,36 +459,276 @@ var _LocalSandboxExecutor = class _LocalSandboxExecutor {
       });
     });
   }
-  wrapFunctionCode(executeCode, args) {
-    return `
-// Wrapped function execution (ESM)
-const execute = ${executeCode};
-const args = ${JSON.stringify(args)};
-
-try {
-  const result = execute(args);
-
-  // Handle both sync and async functions
-  if (result && typeof result.then === 'function') {
-    // Async function - result is a Promise
-    result
-      .then(result => {
-        console.log(JSON.stringify({ success: true, result }));
-      })
-      .catch(error => {
-        console.log(JSON.stringify({ success: false, error: error.message }));
+};
+__publicField(_NativeSandboxExecutor, "instance", null);
+var NativeSandboxExecutor = _NativeSandboxExecutor;
+var logger2 = getLogger$1("VercelSandboxExecutor");
+var _VercelSandboxExecutor = class _VercelSandboxExecutor {
+  constructor(config) {
+    __publicField(this, "config");
+    this.config = config;
+    logger2.info(
+      {
+        teamId: config.teamId,
+        projectId: config.projectId,
+        runtime: config.runtime,
+        timeout: config.timeout,
+        vcpus: config.vcpus
+      },
+      "VercelSandboxExecutor initialized"
+    );
+  }
+  /**
+   * Get singleton instance of VercelSandboxExecutor
+   */
+  static getInstance(config) {
+    if (!_VercelSandboxExecutor.instance) {
+      _VercelSandboxExecutor.instance = new _VercelSandboxExecutor(config);
+    }
+    return _VercelSandboxExecutor.instance;
+  }
+  /**
+   * Execute a function tool in Vercel Sandbox
+   */
+  async executeFunctionTool(functionId, args, toolConfig) {
+    const startTime = Date.now();
+    const logs = [];
+    try {
+      logger2.info(
+        {
+          functionId,
+          functionName: toolConfig.name
+        },
+        "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
       });
-  } else {
-    // Sync function - result is immediate
-    console.log(JSON.stringify({ success: true, result }));
+      logger2.info(
+        {
+          functionId,
+          sandboxId: sandbox.sandboxId
+        },
+        `Sandbox created for function ${functionId}`
+      );
+      try {
+        if (toolConfig.dependencies && Object.keys(toolConfig.dependencies).length > 0) {
+          logger2.debug(
+            {
+              functionId,
+              functionName: toolConfig.name,
+              dependencies: toolConfig.dependencies
+            },
+            "Installing dependencies"
+          );
+          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}`);
+          }
+        }
+        const executionCode = createExecutionWrapper(toolConfig.executeCode, args);
+        const filename = this.config.runtime === "typescript" ? "execute.ts" : "execute.js";
+        await sandbox.writeFiles([
+          {
+            path: filename,
+            content: Buffer.from(executionCode, "utf-8")
+          }
+        ]);
+        logger2.info(
+          {
+            functionId,
+            runtime: this.config.runtime === "typescript" ? "tsx" : "node"
+          },
+          `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 executeStdout = await executeCmd.stdout();
+        const executeStderr = await executeCmd.stderr();
+        if (executeStdout) {
+          logs.push(executeStdout);
+        }
+        if (executeStderr) {
+          logs.push(executeStderr);
+        }
+        const executionTime = Date.now() - startTime;
+        if (executeCmd.exitCode !== 0) {
+          logger2.error(
+            {
+              functionId,
+              exitCode: executeCmd.exitCode,
+              stderr: executeStderr
+            },
+            "Function execution failed"
+          );
+          return {
+            success: false,
+            error: executeStderr || "Function execution failed with non-zero exit code",
+            logs,
+            executionTime
+          };
+        }
+        const result = parseExecutionResult(executeStdout, functionId, logger2);
+        logger2.info(
+          {
+            functionId,
+            executionTime
+          },
+          "Function executed successfully in Vercel Sandbox"
+        );
+        return {
+          success: true,
+          result,
+          logs,
+          executionTime
+        };
+      } finally {
+        await sandbox.stop();
+      }
+    } catch (error) {
+      const executionTime = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger2.error(
+        {
+          functionId,
+          error: errorMessage,
+          executionTime
+        },
+        "Vercel Sandbox execution error"
+      );
+      return {
+        success: false,
+        error: errorMessage,
+        logs,
+        executionTime
+      };
+    }
   }
-} catch (error) {
-  console.log(JSON.stringify({ success: false, error: error.message }));
-}
-`;
+  /**
+   * Clean up resources
+   */
+  async cleanup() {
+    logger2.info({}, "VercelSandboxExecutor cleanup completed");
+  }
+};
+__publicField(_VercelSandboxExecutor, "instance");
+var VercelSandboxExecutor = _VercelSandboxExecutor;
+
+// src/tools/SandboxExecutorFactory.ts
+var logger3 = getLogger$1("SandboxExecutorFactory");
+var _SandboxExecutorFactory = class _SandboxExecutorFactory {
+  constructor() {
+    __publicField(this, "nativeExecutor", null);
+    __publicField(this, "vercelExecutors", /* @__PURE__ */ new Map());
+    logger3.info({}, "SandboxExecutorFactory initialized");
+  }
+  /**
+   * Get singleton instance of SandboxExecutorFactory
+   */
+  static getInstance() {
+    if (!_SandboxExecutorFactory.instance) {
+      _SandboxExecutorFactory.instance = new _SandboxExecutorFactory();
+    }
+    return _SandboxExecutorFactory.instance;
+  }
+  /**
+   * Execute a function tool using the appropriate sandbox provider
+   */
+  async executeFunctionTool(functionId, args, config) {
+    const sandboxConfig = config.sandboxConfig;
+    if (!sandboxConfig) {
+      throw new Error("Sandbox configuration is required for function tool execution");
+    }
+    if (sandboxConfig.provider === "native") {
+      return this.executeInNativeSandbox(functionId, args, config);
+    }
+    if (sandboxConfig.provider === "vercel") {
+      return this.executeInVercelSandbox(functionId, args, config);
+    }
+    throw new Error(`Unknown sandbox provider: ${sandboxConfig.provider}`);
+  }
+  /**
+   * Execute in native sandbox
+   */
+  async executeInNativeSandbox(functionId, args, config) {
+    if (!this.nativeExecutor) {
+      this.nativeExecutor = NativeSandboxExecutor.getInstance();
+      logger3.info({}, "Native sandbox executor created");
+    }
+    return this.nativeExecutor.executeFunctionTool(functionId, args, config);
+  }
+  /**
+   * Execute in Vercel sandbox
+   */
+  async executeInVercelSandbox(functionId, args, config) {
+    const vercelConfig = config.sandboxConfig;
+    const configKey = `${vercelConfig.teamId}:${vercelConfig.projectId}`;
+    if (!this.vercelExecutors.has(configKey)) {
+      const executor2 = VercelSandboxExecutor.getInstance(vercelConfig);
+      this.vercelExecutors.set(configKey, executor2);
+      logger3.info(
+        {
+          teamId: vercelConfig.teamId,
+          projectId: vercelConfig.projectId
+        },
+        "Vercel sandbox executor created"
+      );
+    }
+    const executor = this.vercelExecutors.get(configKey);
+    if (!executor) {
+      throw new Error(`Failed to get Vercel executor for config: ${configKey}`);
+    }
+    const result = await executor.executeFunctionTool(functionId, args, config);
+    if (!result.success) {
+      throw new Error(result.error || "Vercel sandbox execution failed");
+    }
+    return result.result;
+  }
+  /**
+   * Clean up all sandbox executors
+   */
+  async cleanup() {
+    logger3.info({}, "Cleaning up sandbox executors");
+    this.nativeExecutor = null;
+    for (const [key, executor] of this.vercelExecutors.entries()) {
+      await executor.cleanup();
+      this.vercelExecutors.delete(key);
+    }
+    logger3.info({}, "Sandbox executor cleanup completed");
   }
 };
-__publicField(_LocalSandboxExecutor, "instance", null);
-var LocalSandboxExecutor = _LocalSandboxExecutor;
+__publicField(_SandboxExecutorFactory, "instance");
+var SandboxExecutorFactory = _SandboxExecutorFactory;
 
-export { LocalSandboxExecutor };
+export { SandboxExecutorFactory };