@inkeep/agents-run-api 0.39.2 → 0.39.3

package/dist/SandboxExecutorFactory-2N27SE3B.js

@@ -1,943 +0,0 @@
-import { getLogger } from './chunk-A2S7GSHL.js';
-import { FUNCTION_TOOL_SANDBOX_POOL_TTL_MS, FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES, FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS } from './chunk-THWNUGWP.js';
-import { spawn } from 'child_process';
-import crypto, { createHash } from 'crypto';
-import { mkdirSync, existsSync, rmSync, writeFileSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-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)};
-
-// 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 {
-  permits;
-  waitQueue = [];
-  maxWaitTime;
-  constructor(permits, maxWaitTimeMs = FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS) {
-    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 NativeSandboxExecutor = class _NativeSandboxExecutor {
-  tempDir;
-  sandboxPool = {};
-  static instance = null;
-  executionSemaphores = /* @__PURE__ */ new Map();
-  constructor() {
-    this.tempDir = join(tmpdir(), "inkeep-sandboxes");
-    this.ensureTempDir();
-    this.startPoolCleanup();
-  }
-  static getInstance() {
-    if (!_NativeSandboxExecutor.instance) {
-      _NativeSandboxExecutor.instance = new _NativeSandboxExecutor();
-    }
-    return _NativeSandboxExecutor.instance;
-  }
-  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;
-  }
-  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 });
-    } catch {
-    }
-  }
-  generateDependencyHash(dependencies) {
-    const sortedDeps = Object.keys(dependencies).sort().map((key) => `${key}@${dependencies[key]}`).join(",");
-    return createHash("sha256").update(sortedDeps).digest("hex").substring(0, 16);
-  }
-  getCachedSandbox(dependencyHash) {
-    const poolKey = dependencyHash;
-    const sandbox = this.sandboxPool[poolKey];
-    if (sandbox && existsSync(sandbox.sandboxDir)) {
-      const now = Date.now();
-      if (now - sandbox.lastUsed < FUNCTION_TOOL_SANDBOX_POOL_TTL_MS && sandbox.useCount < FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) {
-        sandbox.lastUsed = now;
-        sandbox.useCount++;
-        logger.debug(
-          {
-            poolKey,
-            useCount: sandbox.useCount,
-            sandboxDir: sandbox.sandboxDir,
-            lastUsed: new Date(sandbox.lastUsed)
-          },
-          "Reusing cached sandbox"
-        );
-        return sandbox.sandboxDir;
-      }
-      this.cleanupSandbox(sandbox.sandboxDir);
-      delete this.sandboxPool[poolKey];
-    }
-    return null;
-  }
-  addToPool(dependencyHash, sandboxDir, dependencies) {
-    const poolKey = dependencyHash;
-    if (this.sandboxPool[poolKey]) {
-      this.cleanupSandbox(this.sandboxPool[poolKey].sandboxDir);
-    }
-    this.sandboxPool[poolKey] = {
-      sandboxDir,
-      lastUsed: Date.now(),
-      useCount: 1,
-      dependencies
-    };
-    logger.debug({ poolKey, sandboxDir }, "Added sandbox to pool");
-  }
-  cleanupSandbox(sandboxDir) {
-    try {
-      rmSync(sandboxDir, { recursive: true, force: true });
-      logger.debug({ sandboxDir }, "Cleaned up sandbox");
-    } catch (error) {
-      logger.warn({ sandboxDir, error }, "Failed to clean up sandbox");
-    }
-  }
-  startPoolCleanup() {
-    setInterval(() => {
-      const now = Date.now();
-      const keysToDelete = [];
-      for (const [key, sandbox] of Object.entries(this.sandboxPool)) {
-        if (now - sandbox.lastUsed > FUNCTION_TOOL_SANDBOX_POOL_TTL_MS || sandbox.useCount >= FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) {
-          this.cleanupSandbox(sandbox.sandboxDir);
-          keysToDelete.push(key);
-        }
-      }
-      keysToDelete.forEach((key) => {
-        delete this.sandboxPool[key];
-      });
-      if (keysToDelete.length > 0) {
-        logger.debug({ cleanedCount: keysToDelete.length }, "Cleaned up expired sandboxes");
-      }
-    }, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS);
-  }
-  detectModuleType(executeCode, configuredRuntime) {
-    const esmPatterns = [
-      /import\s+.*\s+from\s+['"]/g,
-      // import ... from '...'
-      /import\s*\(/g,
-      // import(...)
-      /export\s+(default|const|let|var|function|class)/g,
-      // export statements
-      /export\s*\{/g
-      // export { ... }
-    ];
-    const cjsPatterns = [
-      /require\s*\(/g,
-      // require(...)
-      /module\.exports/g,
-      // module.exports
-      /exports\./g
-      // exports.something
-    ];
-    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)}...` },
-        "Both ESM and CommonJS syntax detected, defaulting to ESM"
-      );
-      return "esm";
-    }
-    if (hasEsmSyntax) {
-      return "esm";
-    }
-    if (hasCjsSyntax) {
-      return "cjs";
-    }
-    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(
-      {
-        toolId,
-        dependencies,
-        dependencyHash,
-        sandboxConfig: config.sandboxConfig,
-        poolSize: Object.keys(this.sandboxPool).length
-      },
-      "Executing function tool"
-    );
-    let sandboxDir = this.getCachedSandbox(dependencyHash);
-    let isNewSandbox = false;
-    if (!sandboxDir) {
-      sandboxDir = join(this.tempDir, `sandbox-${dependencyHash}-${Date.now()}`);
-      mkdirSync(sandboxDir, { recursive: true });
-      isNewSandbox = true;
-      logger.debug(
-        {
-          toolId,
-          dependencyHash,
-          sandboxDir,
-          dependencies
-        },
-        "Creating new sandbox"
-      );
-      const moduleType = this.detectModuleType(config.executeCode, config.sandboxConfig?.runtime);
-      const packageJson = {
-        name: `function-tool-${toolId}`,
-        version: "1.0.0",
-        ...moduleType === "esm" && { type: "module" },
-        dependencies,
-        scripts: {
-          start: moduleType === "esm" ? "node index.mjs" : "node index.js"
-        }
-      };
-      writeFileSync(join(sandboxDir, "package.json"), JSON.stringify(packageJson, null, 2), "utf8");
-      if (Object.keys(dependencies).length > 0) {
-        await this.installDependencies(sandboxDir);
-      }
-      this.addToPool(dependencyHash, sandboxDir, dependencies);
-    }
-    try {
-      const moduleType = this.detectModuleType(config.executeCode, config.sandboxConfig?.runtime);
-      const executionCode = createExecutionWrapper(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 || FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT,
-        moduleType,
-        config.sandboxConfig
-      );
-      return result;
-    } catch (error) {
-      if (isNewSandbox) {
-        this.cleanupSandbox(sandboxDir);
-        const poolKey = dependencyHash;
-        delete this.sandboxPool[poolKey];
-      }
-      throw error;
-    }
-  }
-  async installDependencies(sandboxDir) {
-    return new Promise((resolve, reject) => {
-      const npmEnv = {
-        ...process.env,
-        npm_config_cache: join(sandboxDir, ".npm-cache"),
-        npm_config_logs_dir: join(sandboxDir, ".npm-logs"),
-        npm_config_tmp: join(sandboxDir, ".npm-tmp"),
-        HOME: sandboxDir,
-        npm_config_update_notifier: "false",
-        npm_config_progress: "false",
-        npm_config_loglevel: "error"
-      };
-      const npm = spawn("npm", ["install", "--no-audit", "--no-fund"], {
-        cwd: sandboxDir,
-        stdio: "pipe",
-        env: npmEnv
-      });
-      let stderr = "";
-      npm.stdout?.on("data", () => {
-      });
-      npm.stderr?.on("data", (data) => {
-        stderr += data.toString();
-      });
-      npm.on("close", (code) => {
-        if (code === 0) {
-          logger.debug({ sandboxDir }, "Dependencies installed successfully");
-          resolve();
-        } else {
-          logger.error({ sandboxDir, code, stderr }, "Failed to install dependencies");
-          reject(new Error(`npm install failed with code ${code}: ${stderr}`));
-        }
-      });
-      npm.on("error", (err) => {
-        logger.error({ sandboxDir, error: err }, "Failed to spawn npm install");
-        reject(err);
-      });
-    });
-  }
-  async executeInSandbox(sandboxDir, timeout, moduleType, _sandboxConfig) {
-    return new Promise((resolve, reject) => {
-      const fileExtension = moduleType === "esm" ? "mjs" : "js";
-      const spawnOptions = {
-        cwd: sandboxDir,
-        stdio: "pipe",
-        uid: process.getuid ? process.getuid() : void 0,
-        gid: process.getgid ? process.getgid() : void 0
-      };
-      const node = spawn("node", [`index.${fileExtension}`], spawnOptions);
-      let stdout = "";
-      let stderr = "";
-      let outputSize = 0;
-      node.stdout?.on("data", (data) => {
-        const dataStr = data.toString();
-        outputSize += dataStr.length;
-        if (outputSize > FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES) {
-          node.kill("SIGTERM");
-          reject(
-            new Error(
-              `Output size exceeded limit of ${FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES} bytes`
-            )
-          );
-          return;
-        }
-        stdout += dataStr;
-      });
-      node.stderr?.on("data", (data) => {
-        const dataStr = data.toString();
-        outputSize += dataStr.length;
-        if (outputSize > FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES) {
-          node.kill("SIGTERM");
-          reject(
-            new Error(
-              `Output size exceeded limit of ${FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES} bytes`
-            )
-          );
-          return;
-        }
-        stderr += dataStr;
-      });
-      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 {
-          }
-        }, forceKillTimeout);
-        reject(new Error(`Function execution timed out after ${timeout}ms`));
-      }, timeout);
-      node.on("close", (code, signal) => {
-        clearTimeout(timeoutId);
-        if (code === 0) {
-          try {
-            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 {
-              resolve(result);
-            }
-          } catch (parseError) {
-            logger.error({ stdout, stderr, parseError }, "Failed to parse function result");
-            reject(new Error(`Invalid function result: ${stdout}`));
-          }
-        } else {
-          const errorMsg = signal ? `Function execution killed by signal ${signal}: ${stderr}` : `Function execution failed with code ${code}: ${stderr}`;
-          logger.error({ code, signal, stderr }, "Function execution failed");
-          reject(new Error(errorMsg));
-        }
-      });
-      node.on("error", (error) => {
-        clearTimeout(timeoutId);
-        logger.error({ sandboxDir, error }, "Failed to spawn node process");
-        reject(error);
-      });
-    });
-  }
-};
-var logger2 = getLogger("VercelSandboxExecutor");
-var VercelSandboxExecutor = class _VercelSandboxExecutor {
-  static instance;
-  config;
-  sandboxPool = /* @__PURE__ */ new Map();
-  cleanupInterval = null;
-  constructor(config) {
-    this.config = config;
-    logger2.info(
-      {
-        teamId: config.teamId,
-        projectId: config.projectId,
-        runtime: config.runtime,
-        timeout: config.timeout,
-        vcpus: config.vcpus
-      },
-      "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;
-  }
-  /**
-   * 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 > FUNCTION_TOOL_SANDBOX_POOL_TTL_MS || cached.useCount >= FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) {
-      logger2.debug(
-        {
-          dependencyHash,
-          age,
-          useCount: cached.useCount,
-          ttl: FUNCTION_TOOL_SANDBOX_POOL_TTL_MS,
-          maxUseCount: FUNCTION_TOOL_SANDBOX_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 > FUNCTION_TOOL_SANDBOX_POOL_TTL_MS || cached.useCount >= FUNCTION_TOOL_SANDBOX_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);
-        }
-      }
-    }, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS);
-  }
-  /**
-   * 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
-   * Note: Currently creates empty placeholders. Values will be populated in the future.
-   */
-  createEnvFileContent(envVarNames) {
-    const envLines = [];
-    for (const varName of envVarNames) {
-      envLines.push(`${varName}=""`);
-      logger2.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) {
-    const startTime = Date.now();
-    const logs = [];
-    const dependencies = toolConfig.dependencies || {};
-    const dependencyHash = this.generateDependencyHash(dependencies);
-    try {
-      logger2.info(
-        {
-          functionId,
-          functionName: toolConfig.name,
-          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
-        });
-        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 (isNewSandbox && toolConfig.dependencies && Object.keys(toolConfig.dependencies).length > 0) {
-          logger2.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}`);
-          }
-          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";
-        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)
-              },
-              "Creating environment variable placeholders in sandbox"
-            );
-          }
-        }
-        await sandbox.writeFiles(filesToWrite);
-        logger2.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);
-        }
-        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
-        };
-      } catch (innerError) {
-        await this.removeSandbox(dependencyHash);
-        throw innerError;
-      }
-    } 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
-      };
-    }
-  }
-};
-
-// src/tools/SandboxExecutorFactory.ts
-var logger3 = getLogger("SandboxExecutorFactory");
-var SandboxExecutorFactory = class _SandboxExecutorFactory {
-  static instance;
-  nativeExecutor = null;
-  vercelExecutors = /* @__PURE__ */ new Map();
-  constructor() {
-    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");
-  }
-};
-
-export { SandboxExecutorFactory };