@inkeep/agents-run-api 0.22.0 → 0.22.2

package/dist/index.cjs

@@ -10,6 +10,7 @@ var crypto = require('crypto');
 var fs = require('fs');
 var os = require('os');
 var path = require('path');
+var sandbox = require('@vercel/sandbox');
 var otel = require('@hono/otel');
 var zodOpenapi = require('@hono/zod-openapi');
 var api = require('@opentelemetry/api');
@@ -356,8 +357,8 @@ async function getConversationScopedArtifacts(params) {
       });
       referenceArtifacts.push(...artifacts);
     }
-    const logger27 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
-    logger27.debug(
+    const logger28 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
+    logger28.debug(
       {
         conversationId,
         visibleMessages: visibleMessages.length,
@@ -369,8 +370,8 @@ async function getConversationScopedArtifacts(params) {
     );
     return referenceArtifacts;
   } catch (error) {
-    const logger27 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
-    logger27.error(
+    const logger28 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
+    logger28.error(
       {
         error: error instanceof Error ? error.message : "Unknown error",
         conversationId
@@ -386,15 +387,59 @@ var init_conversations = __esm({
   }
 });
 
-// src/tools/LocalSandboxExecutor.ts
-var LocalSandboxExecutor_exports = {};
-__export(LocalSandboxExecutor_exports, {
-  LocalSandboxExecutor: () => LocalSandboxExecutor
+// 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, logger28) {
+  try {
+    const outputLines = stdout.split("\n").filter((line) => line.trim());
+    const resultLine = outputLines[outputLines.length - 1];
+    return JSON.parse(resultLine);
+  } catch (parseError) {
+    if (logger28) {
+      logger28.warn(
+        {
+          functionId,
+          stdout,
+          parseError
+        },
+        "Failed to parse execution result"
+      );
+    }
+    return stdout;
+  }
+}
+var init_sandbox_utils = __esm({
+  "src/tools/sandbox-utils.ts"() {
+  }
 });
-var logger17, ExecutionSemaphore, _LocalSandboxExecutor, LocalSandboxExecutor;
-var init_LocalSandboxExecutor = __esm({
-  "src/tools/LocalSandboxExecutor.ts"() {
-    logger17 = agentsCore.getLogger("local-sandbox-executor");
+var logger16, ExecutionSemaphore, _NativeSandboxExecutor, NativeSandboxExecutor;
+var init_NativeSandboxExecutor = __esm({
+  "src/tools/NativeSandboxExecutor.ts"() {
+    init_sandbox_utils();
+    logger16 = agentsCore.getLogger("native-sandbox-executor");
     ExecutionSemaphore = class {
       constructor(permits, maxWaitTimeMs = 3e4) {
         __publicField(this, "permits");
@@ -447,7 +492,7 @@ var init_LocalSandboxExecutor = __esm({
         return this.waitQueue.length;
       }
     };
-    _LocalSandboxExecutor = class _LocalSandboxExecutor {
+    _NativeSandboxExecutor = class _NativeSandboxExecutor {
       constructor() {
         __publicField(this, "tempDir");
         __publicField(this, "sandboxPool", {});
@@ -460,15 +505,15 @@ var init_LocalSandboxExecutor = __esm({
         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);
         if (!this.executionSemaphores.has(effectiveVcpus)) {
-          logger17.debug({ vcpus: effectiveVcpus }, "Creating new execution semaphore");
+          logger16.debug({ vcpus: effectiveVcpus }, "Creating new execution semaphore");
           this.executionSemaphores.set(effectiveVcpus, new ExecutionSemaphore(effectiveVcpus));
         }
         const semaphore = this.executionSemaphores.get(effectiveVcpus);
@@ -505,7 +550,7 @@ var init_LocalSandboxExecutor = __esm({
           if (now - sandbox.lastUsed < this.POOL_TTL && sandbox.useCount < this.MAX_USE_COUNT) {
             sandbox.lastUsed = now;
             sandbox.useCount++;
-            logger17.debug(
+            logger16.debug(
               {
                 poolKey,
                 useCount: sandbox.useCount,
@@ -533,14 +578,14 @@ var init_LocalSandboxExecutor = __esm({
           useCount: 1,
           dependencies
         };
-        logger17.debug({ poolKey, sandboxDir }, "Added sandbox to pool");
+        logger16.debug({ poolKey, sandboxDir }, "Added sandbox to pool");
       }
       cleanupSandbox(sandboxDir) {
         try {
           fs.rmSync(sandboxDir, { recursive: true, force: true });
-          logger17.debug({ sandboxDir }, "Cleaned up sandbox");
+          logger16.debug({ sandboxDir }, "Cleaned up sandbox");
         } catch (error) {
-          logger17.warn({ sandboxDir, error }, "Failed to clean up sandbox");
+          logger16.warn({ sandboxDir, error }, "Failed to clean up sandbox");
         }
       }
       startPoolCleanup() {
@@ -557,7 +602,7 @@ var init_LocalSandboxExecutor = __esm({
             delete this.sandboxPool[key];
           });
           if (keysToDelete.length > 0) {
-            logger17.debug({ cleanedCount: keysToDelete.length }, "Cleaned up expired sandboxes");
+            logger16.debug({ cleanedCount: keysToDelete.length }, "Cleaned up expired sandboxes");
           }
         }, 6e4);
       }
@@ -586,7 +631,7 @@ var init_LocalSandboxExecutor = __esm({
           return hasCjsSyntax ? "cjs" : "esm";
         }
         if (hasEsmSyntax && hasCjsSyntax) {
-          logger17.warn(
+          logger16.warn(
             { executeCode: `${executeCode.substring(0, 100)}...` },
             "Both ESM and CommonJS syntax detected, defaulting to ESM"
           );
@@ -603,7 +648,7 @@ var init_LocalSandboxExecutor = __esm({
       async executeFunctionTool(toolId, args, config) {
         const vcpus = config.sandboxConfig?.vcpus || 1;
         const semaphore = this.getSemaphore(vcpus);
-        logger17.debug(
+        logger16.debug(
           {
             toolId,
             vcpus,
@@ -621,7 +666,7 @@ var init_LocalSandboxExecutor = __esm({
       async executeInSandbox_Internal(toolId, args, config) {
         const dependencies = config.dependencies || {};
         const dependencyHash = this.generateDependencyHash(dependencies);
-        logger17.debug(
+        logger16.debug(
           {
             toolId,
             dependencies,
@@ -637,7 +682,7 @@ var init_LocalSandboxExecutor = __esm({
           sandboxDir = path.join(this.tempDir, `sandbox-${dependencyHash}-${Date.now()}`);
           fs.mkdirSync(sandboxDir, { recursive: true });
           isNewSandbox = true;
-          logger17.debug(
+          logger16.debug(
             {
               toolId,
               dependencyHash,
@@ -664,7 +709,7 @@ var init_LocalSandboxExecutor = __esm({
         }
         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";
           fs.writeFileSync(path.join(sandboxDir, `index.${fileExtension}`), executionCode, "utf8");
           const result = await this.executeInSandbox(
@@ -708,15 +753,15 @@ var init_LocalSandboxExecutor = __esm({
           });
           npm.on("close", (code) => {
             if (code === 0) {
-              logger17.debug({ sandboxDir }, "Dependencies installed successfully");
+              logger16.debug({ sandboxDir }, "Dependencies installed successfully");
               resolve();
             } else {
-              logger17.error({ sandboxDir, code, stderr }, "Failed to install dependencies");
+              logger16.error({ sandboxDir, code, stderr }, "Failed to install dependencies");
               reject(new Error(`npm install failed with code ${code}: ${stderr}`));
             }
           });
           npm.on("error", (err) => {
-            logger17.error({ sandboxDir, error: err }, "Failed to spawn npm install");
+            logger16.error({ sandboxDir, error: err }, "Failed to spawn npm install");
             reject(err);
           });
         });
@@ -756,7 +801,7 @@ var init_LocalSandboxExecutor = __esm({
             stderr += dataStr;
           });
           const timeoutId = setTimeout(() => {
-            logger17.warn({ sandboxDir, timeout }, "Function execution timed out, killing process");
+            logger16.warn({ sandboxDir, timeout }, "Function execution timed out, killing process");
             node.kill("SIGTERM");
             const forceKillTimeout = Math.min(Math.max(timeout / 10, 2e3), 5e3);
             setTimeout(() => {
@@ -771,60 +816,324 @@ var init_LocalSandboxExecutor = __esm({
             clearTimeout(timeoutId);
             if (code === 0) {
               try {
-                const result = JSON.parse(stdout);
-                if (result.success) {
-                  resolve(result.result);
+                const result = parseExecutionResult(stdout, "function", logger16);
+                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) {
-                logger17.error({ stdout, stderr, parseError }, "Failed to parse function result");
+                logger16.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}`;
-              logger17.error({ code, signal, stderr }, "Function execution failed");
+              logger16.error({ code, signal, stderr }, "Function execution failed");
               reject(new Error(errorMsg));
             }
           });
           node.on("error", (error) => {
             clearTimeout(timeoutId);
-            logger17.error({ sandboxDir, error }, "Failed to spawn node process");
+            logger16.error({ sandboxDir, error }, "Failed to spawn node process");
             reject(error);
           });
         });
       }
-      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 }));
-      });
-  } else {
-    // Sync function - result is immediate
-    console.log(JSON.stringify({ success: true, result }));
+    };
+    __publicField(_NativeSandboxExecutor, "instance", null);
+    NativeSandboxExecutor = _NativeSandboxExecutor;
   }
-} catch (error) {
-  console.log(JSON.stringify({ success: false, error: error.message }));
-}
-`;
+});
+var logger17, _VercelSandboxExecutor, VercelSandboxExecutor;
+var init_VercelSandboxExecutor = __esm({
+  "src/tools/VercelSandboxExecutor.ts"() {
+    init_logger();
+    init_sandbox_utils();
+    logger17 = agentsCore.getLogger("VercelSandboxExecutor");
+    _VercelSandboxExecutor = class _VercelSandboxExecutor {
+      constructor(config) {
+        __publicField(this, "config");
+        this.config = config;
+        logger17.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 {
+          logger17.info(
+            {
+              functionId,
+              functionName: toolConfig.name
+            },
+            "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}`
+          );
+          try {
+            if (toolConfig.dependencies && Object.keys(toolConfig.dependencies).length > 0) {
+              logger17.debug(
+                {
+                  functionId,
+                  functionName: toolConfig.name,
+                  dependencies: toolConfig.dependencies
+                },
+                "Installing dependencies"
+              );
+              const packageJson = {
+                dependencies: toolConfig.dependencies
+              };
+              const packageJsonContent = JSON.stringify(packageJson, null, 2);
+              await sandbox$1.writeFiles([
+                {
+                  path: "package.json",
+                  content: Buffer.from(packageJsonContent, "utf-8")
+                }
+              ]);
+              const installCmd = await sandbox$1.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$1.writeFiles([
+              {
+                path: filename,
+                content: Buffer.from(executionCode, "utf-8")
+              }
+            ]);
+            logger17.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$1.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) {
+              logger17.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, logger17);
+            logger17.info(
+              {
+                functionId,
+                executionTime
+              },
+              "Function executed successfully in Vercel Sandbox"
+            );
+            return {
+              success: true,
+              result,
+              logs,
+              executionTime
+            };
+          } finally {
+            await sandbox$1.stop();
+          }
+        } catch (error) {
+          const executionTime = Date.now() - startTime;
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          logger17.error(
+            {
+              functionId,
+              error: errorMessage,
+              executionTime
+            },
+            "Vercel Sandbox execution error"
+          );
+          return {
+            success: false,
+            error: errorMessage,
+            logs,
+            executionTime
+          };
+        }
+      }
+      /**
+       * Clean up resources
+       */
+      async cleanup() {
+        logger17.info({}, "VercelSandboxExecutor cleanup completed");
+      }
+    };
+    __publicField(_VercelSandboxExecutor, "instance");
+    VercelSandboxExecutor = _VercelSandboxExecutor;
+  }
+});
+
+// src/tools/SandboxExecutorFactory.ts
+var SandboxExecutorFactory_exports = {};
+__export(SandboxExecutorFactory_exports, {
+  SandboxExecutorFactory: () => SandboxExecutorFactory
+});
+var logger18, _SandboxExecutorFactory, SandboxExecutorFactory;
+var init_SandboxExecutorFactory = __esm({
+  "src/tools/SandboxExecutorFactory.ts"() {
+    init_logger();
+    init_NativeSandboxExecutor();
+    init_VercelSandboxExecutor();
+    logger18 = agentsCore.getLogger("SandboxExecutorFactory");
+    _SandboxExecutorFactory = class _SandboxExecutorFactory {
+      constructor() {
+        __publicField(this, "nativeExecutor", null);
+        __publicField(this, "vercelExecutors", /* @__PURE__ */ new Map());
+        logger18.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();
+          logger18.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);
+          logger18.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() {
+        logger18.info({}, "Cleaning up sandbox executors");
+        this.nativeExecutor = null;
+        for (const [key, executor] of this.vercelExecutors.entries()) {
+          await executor.cleanup();
+          this.vercelExecutors.delete(key);
+        }
+        logger18.info({}, "Sandbox executor cleanup completed");
       }
     };
-    __publicField(_LocalSandboxExecutor, "instance", null);
-    LocalSandboxExecutor = _LocalSandboxExecutor;
+    __publicField(_SandboxExecutorFactory, "instance");
+    SandboxExecutorFactory = _SandboxExecutorFactory;
   }
 });
 
@@ -2603,31 +2912,6 @@ var _ArtifactService = class _ArtifactService {
     }
     return value;
   }
-  /**
-   * Extract properties from data using prop selectors
-   */
-  extractProps(item, propSelectors) {
-    const extracted = {};
-    for (const [propName, selector] of Object.entries(propSelectors)) {
-      try {
-        const sanitizedSelector = this.sanitizeJMESPathSelector(selector);
-        const rawValue = sanitizedSelector ? jmespath__default.default.search(item, sanitizedSelector) : item[propName];
-        if (rawValue !== null && rawValue !== void 0) {
-          extracted[propName] = this.cleanEscapedContent(rawValue);
-        }
-      } catch (error) {
-        logger7.warn(
-          { propName, selector, error: error instanceof Error ? error.message : "Unknown error" },
-          "Failed to extract property"
-        );
-        const fallbackValue = item[propName];
-        if (fallbackValue !== null && fallbackValue !== void 0) {
-          extracted[propName] = this.cleanEscapedContent(fallbackValue);
-        }
-      }
-    }
-    return extracted;
-  }
   /**
    * Extract properties from data using schema-defined fields and custom selectors
    */
@@ -2758,7 +3042,7 @@ var _ArtifactParser = class _ArtifactParser {
     while ((match = _ArtifactParser.ATTR_REGEX.exec(attrString)) !== null) {
       const key = match[1] || match[3] || match[5];
       let value = match[2] || match[4] || match[6];
-      if (value && value.startsWith("{")) {
+      if (value?.startsWith("{")) {
         try {
           value = JSON.parse(value);
         } catch {
@@ -3025,9 +3309,7 @@ var _ArtifactParser = class _ArtifactParser {
     return await this.artifactService.getArtifactSummary(artifactId, toolCallId, artifactMap);
   }
 };
-__publicField(_ArtifactParser, "ARTIFACT_REGEX", /<artifact:ref\s+id=(['"])([^'"]*?)\1\s+tool=(['"])([^'"]*?)\3\s*\/>/gs);
 __publicField(_ArtifactParser, "ARTIFACT_CHECK_REGEX", /<artifact:ref\s+(?=.*id=['"][^'"]+['"])(?=.*tool=['"][^'"]+['"])[^>]*\/>/);
-__publicField(_ArtifactParser, "ARTIFACT_CREATE_REGEX", /<artifact:create\s+([^>]+?)(?:\s*\/)?>(?:(.*?)<\/artifact:create>)?/gs);
 __publicField(_ArtifactParser, "ATTR_REGEX", /(\w+)="([^"]*)"|(\w+)='([^']*)'|(\w+)=({[^}]+})/g);
 __publicField(_ArtifactParser, "ARTIFACT_PATTERNS", [
   "<a",
@@ -4507,7 +4789,7 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
         sharedArtifactService = agentSessionManager.getArtifactService(
           artifactParserOptions.streamRequestId
         );
-      } catch (error) {
+      } catch (_error) {
       }
     }
     this.artifactParser = new ArtifactParser(tenantId, {
@@ -4547,7 +4829,9 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
    */
   async processTextChunk(chunk) {
     if (this.lastChunkWasToolResult && this.buffer === "" && chunk) {
-      chunk = "\n\n" + chunk;
+      chunk = `
+
+${chunk}`;
       this.lastChunkWasToolResult = false;
     }
     this.buffer += chunk;
@@ -4578,7 +4862,7 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
             if (this.isComponentComplete(component)) {
               await this.streamComponent(component);
             }
-          } catch (e) {
+          } catch (_e) {
           }
         }
       }
@@ -4892,7 +5176,7 @@ var ResponseFormatter = class {
         sharedArtifactService = agentSessionManager.getArtifactService(
           artifactParserOptions.streamRequestId
         );
-      } catch (error) {
+      } catch (_error) {
       }
     }
     this.artifactParser = new ArtifactParser(tenantId, {
@@ -5111,7 +5395,7 @@ function jsonSchemaToZod(jsonSchema) {
 
 // src/utils/SchemaProcessor.ts
 init_logger();
-var SchemaProcessor = class {
+var _SchemaProcessor = class _SchemaProcessor {
   /**
    * Transform complex schema types to strings for JMESPath compatibility
    */
@@ -5142,13 +5426,13 @@ var SchemaProcessor = class {
    * Validate if a selector looks like a valid JMESPath expression
    */
   static validateJMESPathSelector(selector) {
-    if (this.isLiteralValue(selector)) {
+    if (_SchemaProcessor.isLiteralValue(selector)) {
       return {
         isLiteral: true,
         isValidSelector: false
       };
     }
-    if (this.looksLikeJMESPath(selector)) {
+    if (_SchemaProcessor.looksLikeJMESPath(selector)) {
       return {
         isLiteral: false,
         isValidSelector: true
@@ -5184,7 +5468,7 @@ var SchemaProcessor = class {
    * Check if a selector appears to be a literal value rather than a JMESPath expression
    */
   static isLiteralValue(selector) {
-    if (this.looksLikeJMESPath(selector)) {
+    if (_SchemaProcessor.looksLikeJMESPath(selector)) {
       return false;
     }
     if (/^https?:\/\//.test(selector)) {
@@ -5206,18 +5490,21 @@ var SchemaProcessor = class {
    */
   static safeJMESPathSearch(data, selector, fallback = null) {
     try {
-      const validation = this.validateJMESPathSelector(selector);
+      const validation = _SchemaProcessor.validateJMESPathSelector(selector);
       if (validation.isLiteral) {
-        this.logger.debug({ selector }, "Selector appears to be literal value, returning as-is");
+        _SchemaProcessor.logger.debug(
+          { selector },
+          "Selector appears to be literal value, returning as-is"
+        );
         return selector;
       }
       if (!validation.isValidSelector) {
-        this.logger.warn({ selector }, "Selector does not appear to be valid JMESPath");
+        _SchemaProcessor.logger.warn({ selector }, "Selector does not appear to be valid JMESPath");
         return fallback;
       }
       return jmespath__default.default.search(data, selector) || fallback;
     } catch (error) {
-      this.logger.warn(
+      _SchemaProcessor.logger.warn(
         { selector, error: error instanceof Error ? error.message : String(error) },
         "JMESPath search failed"
       );
@@ -5239,7 +5526,7 @@ var SchemaProcessor = class {
     if (!schema.properties || typeof schema.properties !== "object") {
       errors.push("Schema must have properties object");
     }
-    const transformedSchema = this.transformSchemaForJMESPath(schema);
+    const transformedSchema = _SchemaProcessor.transformSchemaForJMESPath(schema);
     return {
       isValid: errors.length === 0,
       errors,
@@ -5249,8 +5536,8 @@ var SchemaProcessor = class {
   /**
    * Extract property value with proper type conversion and validation
    */
-  static extractPropertyValue(data, propName, selector, expectedType) {
-    const value = this.safeJMESPathSearch(data, selector);
+  static extractPropertyValue(data, _propName, selector, expectedType) {
+    const value = _SchemaProcessor.safeJMESPathSearch(data, selector);
     if (value === null || value === void 0) {
       return null;
     }
@@ -5258,9 +5545,10 @@ var SchemaProcessor = class {
       switch (expectedType) {
         case "string":
           return String(value);
-        case "number":
+        case "number": {
           const num = Number(value);
-          return isNaN(num) ? null : num;
+          return Number.isNaN(num) ? null : num;
+        }
         case "boolean":
           return Boolean(value);
         case "array":
@@ -5324,7 +5612,8 @@ var SchemaProcessor = class {
     return transformToSelectorSchema(schema);
   }
 };
-__publicField(SchemaProcessor, "logger", agentsCore.getLogger("SchemaProcessor"));
+__publicField(_SchemaProcessor, "logger", agentsCore.getLogger("SchemaProcessor"));
+var SchemaProcessor = _SchemaProcessor;
 
 // src/utils/artifact-component-schema.ts
 agentsCore.getLogger("ArtifactComponentSchema");
@@ -7419,7 +7708,7 @@ function hasToolCallWithPrefix(prefix) {
     return false;
   };
 }
-var logger18 = agentsCore.getLogger("Agent");
+var logger19 = agentsCore.getLogger("Agent");
 var CONSTANTS = {
   MAX_GENERATION_STEPS: 12,
   PHASE_1_TIMEOUT_MS: 27e4,
@@ -7725,14 +8014,14 @@ var Agent = class {
     for (const toolSet of tools) {
       for (const [toolName, originalTool] of Object.entries(toolSet)) {
         if (!isValidTool(originalTool)) {
-          logger18.error({ toolName }, "Invalid MCP tool structure - missing required properties");
+          logger19.error({ toolName }, "Invalid MCP tool structure - missing required properties");
           continue;
         }
         const sessionWrappedTool = ai.tool({
           description: originalTool.description,
           inputSchema: originalTool.inputSchema,
           execute: async (args, { toolCallId }) => {
-            logger18.debug({ toolName, toolCallId }, "MCP Tool Called");
+            logger19.debug({ toolName, toolCallId }, "MCP Tool Called");
             try {
               const rawResult = await originalTool.execute(args, { toolCallId });
               const parsedResult = parseEmbeddedJson(rawResult);
@@ -7746,7 +8035,7 @@ var Agent = class {
               });
               return { result: enhancedResult, toolCallId };
             } catch (error) {
-              logger18.error({ toolName, toolCallId, error }, "MCP tool execution failed");
+              logger19.error({ toolName, toolCallId, error }, "MCP tool execution failed");
               throw error;
             }
           }
@@ -7847,7 +8136,7 @@ var Agent = class {
         headers: agentToolRelationHeaders
       };
     }
-    logger18.info(
+    logger19.info(
       {
         toolName: tool3.name,
         credentialReferenceId,
@@ -7872,7 +8161,7 @@ var Agent = class {
         this.mcpClientCache.set(cacheKey, client);
       } catch (error) {
         this.mcpConnectionLocks.delete(cacheKey);
-        logger18.error(
+        logger19.error(
           {
             toolName: tool3.name,
             subAgentId: this.config.id,
@@ -7936,7 +8225,7 @@ var Agent = class {
       await client.connect();
       return client;
     } catch (error) {
-      logger18.error(
+      logger19.error(
         {
           toolName: tool3.name,
           subAgentId: this.config.id,
@@ -7973,12 +8262,12 @@ var Agent = class {
       if (functionToolsData.length === 0) {
         return functionTools;
       }
-      const { LocalSandboxExecutor: LocalSandboxExecutor2 } = await Promise.resolve().then(() => (init_LocalSandboxExecutor(), LocalSandboxExecutor_exports));
-      const sandboxExecutor = LocalSandboxExecutor2.getInstance();
+      const { SandboxExecutorFactory: SandboxExecutorFactory2 } = await Promise.resolve().then(() => (init_SandboxExecutorFactory(), SandboxExecutorFactory_exports));
+      const sandboxExecutor = SandboxExecutorFactory2.getInstance();
       for (const functionToolDef of functionToolsData) {
         const functionId = functionToolDef.functionId;
         if (!functionId) {
-          logger18.warn(
+          logger19.warn(
             { functionToolId: functionToolDef.id },
             "Function tool missing functionId reference"
           );
@@ -7992,7 +8281,7 @@ var Agent = class {
           }
         });
         if (!functionData) {
-          logger18.warn(
+          logger19.warn(
             { functionId, functionToolId: functionToolDef.id },
             "Function not found in functions table"
           );
@@ -8003,16 +8292,13 @@ var Agent = class {
           description: functionToolDef.description || functionToolDef.name,
           inputSchema: zodSchema,
           execute: async (args, { toolCallId }) => {
-            logger18.debug(
+            logger19.debug(
               { toolName: functionToolDef.name, toolCallId, args },
               "Function Tool Called"
             );
             try {
-              const project = await agentsCore.getProject(dbClient_default)({
-                scopes: { tenantId: this.config.tenantId, projectId: this.config.projectId }
-              });
               const defaultSandboxConfig = {
-                provider: "local",
+                provider: "native",
                 runtime: "node22",
                 timeout: 3e4,
                 vcpus: 1
@@ -8022,7 +8308,7 @@ var Agent = class {
                 inputSchema: functionData.inputSchema || {},
                 executeCode: functionData.executeCode,
                 dependencies: functionData.dependencies || {},
-                sandboxConfig: project?.sandboxConfig || defaultSandboxConfig
+                sandboxConfig: this.config.sandboxConfig || defaultSandboxConfig
               });
               toolSessionManager.recordToolResult(sessionId || "", {
                 toolCallId,
@@ -8033,8 +8319,12 @@ var Agent = class {
               });
               return { result, toolCallId };
             } catch (error) {
-              logger18.error(
-                { toolName: functionToolDef.name, toolCallId, error },
+              logger19.error(
+                {
+                  toolName: functionToolDef.name,
+                  toolCallId,
+                  error: error instanceof Error ? error.message : String(error)
+                },
                 "Function tool execution failed"
               );
               throw error;
@@ -8049,7 +8339,7 @@ var Agent = class {
         );
       }
     } catch (error) {
-      logger18.error({ error }, "Failed to load function tools from database");
+      logger19.error({ error }, "Failed to load function tools from database");
     }
     return functionTools;
   }
@@ -8059,7 +8349,7 @@ var Agent = class {
   async getResolvedContext(conversationId, headers) {
     try {
       if (!this.config.contextConfigId) {
-        logger18.debug({ agentId: this.config.agentId }, "No context config found for agent");
+        logger19.debug({ agentId: this.config.agentId }, "No context config found for agent");
         return null;
       }
       const contextConfig = await agentsCore.getContextConfigById(dbClient_default)({
@@ -8071,7 +8361,7 @@ var Agent = class {
         id: this.config.contextConfigId
       });
       if (!contextConfig) {
-        logger18.warn({ contextConfigId: this.config.contextConfigId }, "Context config not found");
+        logger19.warn({ contextConfigId: this.config.contextConfigId }, "Context config not found");
         return null;
       }
       if (!this.contextResolver) {
@@ -8088,7 +8378,7 @@ var Agent = class {
         $now: (/* @__PURE__ */ new Date()).toISOString(),
         $env: process.env
       };
-      logger18.debug(
+      logger19.debug(
         {
           conversationId,
           contextConfigId: contextConfig.id,
@@ -8102,7 +8392,7 @@ var Agent = class {
       );
       return contextWithBuiltins;
     } catch (error) {
-      logger18.error(
+      logger19.error(
         {
           conversationId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -8126,7 +8416,7 @@ var Agent = class {
       });
       return agentDefinition?.prompt || void 0;
     } catch (error) {
-      logger18.warn(
+      logger19.warn(
         {
           agentId: this.config.agentId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -8155,7 +8445,7 @@ var Agent = class {
         (subAgent) => "artifactComponents" in subAgent && subAgent.artifactComponents && subAgent.artifactComponents.length > 0
       );
     } catch (error) {
-      logger18.warn(
+      logger19.warn(
         {
           agentId: this.config.agentId,
           tenantId: this.config.tenantId,
@@ -8184,7 +8474,7 @@ var Agent = class {
           preserveUnresolved: false
         });
       } catch (error) {
-        logger18.error(
+        logger19.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -8231,7 +8521,7 @@ var Agent = class {
           preserveUnresolved: false
         });
       } catch (error) {
-        logger18.error(
+        logger19.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -8246,7 +8536,7 @@ var Agent = class {
     const functionTools = await this.getFunctionTools(streamRequestId || "");
     const relationTools = this.getRelationTools(runtimeContext);
     const allTools = { ...mcpTools, ...functionTools, ...relationTools };
-    logger18.info(
+    logger19.info(
       {
         mcpTools: Object.keys(mcpTools),
         functionTools: Object.keys(functionTools),
@@ -8285,7 +8575,7 @@ var Agent = class {
           preserveUnresolved: false
         });
       } catch (error) {
-        logger18.error(
+        logger19.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -8318,7 +8608,7 @@ var Agent = class {
         toolCallId: z6.z.string().describe("The tool call ID associated with this artifact.")
       }),
       execute: async ({ artifactId, toolCallId }) => {
-        logger18.info({ artifactId, toolCallId }, "get_artifact_full executed");
+        logger19.info({ artifactId, toolCallId }, "get_artifact_full executed");
         const streamRequestId = this.getStreamRequestId();
         const artifactService = agentSessionManager.getArtifactService(streamRequestId);
         if (!artifactService) {
@@ -8389,7 +8679,7 @@ var Agent = class {
     if (typeof result === "string") {
       try {
         parsedForAnalysis = parseEmbeddedJson(result);
-      } catch (error) {
+      } catch (_error) {
         parsedForAnalysis = result;
       }
     }
@@ -8578,7 +8868,7 @@ var Agent = class {
       };
       return enhanced;
     } catch (error) {
-      logger18.warn({ error }, "Failed to enhance tool result with structure hints");
+      logger19.warn({ error }, "Failed to enhance tool result with structure hints");
       return result;
     }
   }
@@ -8593,7 +8883,7 @@ var Agent = class {
         }
       });
     } catch (error) {
-      logger18.error(
+      logger19.error(
         { error, agentId: this.config.agentId },
         "Failed to check agent artifact components"
       );
@@ -8694,7 +8984,7 @@ var Agent = class {
         const configuredTimeout = modelSettings.maxDuration ? Math.min(modelSettings.maxDuration * 1e3, MAX_ALLOWED_TIMEOUT_MS) : shouldStreamPhase1 ? CONSTANTS.PHASE_1_TIMEOUT_MS : CONSTANTS.NON_STREAMING_PHASE_1_TIMEOUT_MS;
         const timeoutMs = Math.min(configuredTimeout, MAX_ALLOWED_TIMEOUT_MS);
         if (modelSettings.maxDuration && modelSettings.maxDuration * 1e3 > MAX_ALLOWED_TIMEOUT_MS) {
-          logger18.warn(
+          logger19.warn(
             {
               requestedTimeout: modelSettings.maxDuration * 1e3,
               appliedTimeout: timeoutMs,
@@ -8736,7 +9026,7 @@ var Agent = class {
                     }
                   );
                 } catch (error) {
-                  logger18.debug({ error }, "Failed to track agent reasoning");
+                  logger19.debug({ error }, "Failed to track agent reasoning");
                 }
               }
               if (steps.length >= 2) {
@@ -8858,7 +9148,7 @@ var Agent = class {
                     }
                   );
                 } catch (error) {
-                  logger18.debug({ error }, "Failed to track agent reasoning");
+                  logger19.debug({ error }, "Failed to track agent reasoning");
                 }
               }
               if (steps.length >= 2) {
@@ -9156,7 +9446,7 @@ ${output}${structureHintsFormatted}`;
 };
 
 // src/agents/generateTaskHandler.ts
-var logger19 = agentsCore.getLogger("generateTaskHandler");
+var logger20 = agentsCore.getLogger("generateTaskHandler");
 var createTaskHandler = (config, credentialStoreRegistry) => {
   return async (task) => {
     try {
@@ -9209,7 +9499,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
           }
         })
       ]);
-      logger19.info({ toolsForAgent, internalRelations, externalRelations }, "agent stuff");
+      logger20.info({ toolsForAgent, internalRelations, externalRelations }, "agent stuff");
       const enhancedInternalRelations = await Promise.all(
         internalRelations.map(async (relation) => {
           try {
@@ -9238,7 +9528,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
               return { ...relation, description: enhancedDescription };
             }
           } catch (error) {
-            logger19.warn({ subAgentId: relation.id, error }, "Failed to enhance agent description");
+            logger20.warn({ subAgentId: relation.id, error }, "Failed to enhance agent description");
           }
           return relation;
         })
@@ -9327,7 +9617,8 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
           dataComponents,
           artifactComponents,
           contextConfigId: config.contextConfigId || void 0,
-          conversationHistoryConfig: config.conversationHistoryConfig
+          conversationHistoryConfig: config.conversationHistoryConfig,
+          sandboxConfig: config.sandboxConfig
         },
         credentialStoreRegistry
       );
@@ -9340,7 +9631,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
         const taskIdMatch = task.id.match(/^task_([^-]+-[^-]+-\d+)-/);
         if (taskIdMatch) {
           contextId = taskIdMatch[1];
-          logger19.info(
+          logger20.info(
             {
               taskId: task.id,
               extractedContextId: contextId,
@@ -9356,7 +9647,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
       const isDelegation = task.context?.metadata?.isDelegation === true;
       agent.setDelegationStatus(isDelegation);
       if (isDelegation) {
-        logger19.info(
+        logger20.info(
           { subAgentId: config.subAgentId, taskId: task.id },
           "Delegated agent - streaming disabled"
         );
@@ -9393,7 +9684,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
             const toolResult = allToolResults.find(
               (result) => result.toolCallId === toolCall.toolCallId
             );
-            logger19.info(
+            logger20.info(
               {
                 toolCallName: toolCall.toolName,
                 toolCallId: toolCall.toolCallId,
@@ -9410,7 +9701,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
             const transferReason = responseText || allThoughts[allThoughts.length - 1]?.text || "Agent requested transfer. No reason provided.";
             if (toolResult?.output && isValidTransferResult(toolResult.output)) {
               const transferResult = toolResult.output;
-              logger19.info(
+              logger20.info(
                 {
                   validationPassed: true,
                   transferResult,
@@ -9427,7 +9718,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
                 reason: transferReason,
                 original_message: userMessage
               };
-              logger19.info(
+              logger20.info(
                 {
                   artifactData,
                   artifactDataKeys: Object.keys(artifactData)
@@ -9452,7 +9743,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
                 ]
               };
             } else {
-              logger19.warn(
+              logger20.warn(
                 {
                   hasToolResult: !!toolResult,
                   hasOutput: !!toolResult?.output,
@@ -9533,7 +9824,8 @@ var createTaskHandlerConfig = async (params) => {
     name: subAgent.name,
     description: subAgent.description,
     conversationHistoryConfig: effectiveConversationHistoryConfig,
-    contextConfigId: agent?.contextConfigId || void 0
+    contextConfigId: agent?.contextConfigId || void 0,
+    sandboxConfig: params.sandboxConfig
   };
 };
 
@@ -9609,7 +9901,8 @@ async function hydrateAgent({
   agentId,
   baseUrl,
   apiKey,
-  credentialStoreRegistry
+  credentialStoreRegistry,
+  sandboxConfig
 }) {
   try {
     const taskHandlerConfig = await createTaskHandlerConfig({
@@ -9618,7 +9911,8 @@ async function hydrateAgent({
       agentId,
       subAgentId: dbAgent.id,
       baseUrl,
-      apiKey
+      apiKey,
+      sandboxConfig
     });
     const taskHandler = createTaskHandler(taskHandlerConfig, credentialStoreRegistry);
     const agentCard = createAgentCard({
@@ -9638,7 +9932,8 @@ async function hydrateAgent({
     throw error;
   }
 }
-async function getRegisteredAgent(executionContext, credentialStoreRegistry) {
+async function getRegisteredAgent(params) {
+  const { executionContext, credentialStoreRegistry, sandboxConfig } = params;
   const { tenantId, projectId, agentId, subAgentId, baseUrl, apiKey } = executionContext;
   if (!subAgentId) {
     throw new Error("Agent ID is required");
@@ -9656,7 +9951,8 @@ async function getRegisteredAgent(executionContext, credentialStoreRegistry) {
     agentId,
     baseUrl: agentFrameworkBaseUrl,
     credentialStoreRegistry,
-    apiKey
+    apiKey,
+    sandboxConfig
   });
 }
 
@@ -9664,7 +9960,7 @@ async function getRegisteredAgent(executionContext, credentialStoreRegistry) {
 init_dbClient();
 init_logger();
 var app = new zodOpenapi.OpenAPIHono();
-var logger20 = agentsCore.getLogger("agents");
+var logger21 = agentsCore.getLogger("agents");
 app.openapi(
   zodOpenapi.createRoute({
     method: "get",
@@ -9702,7 +9998,7 @@ app.openapi(
       tracestate: c.req.header("tracestate"),
       baggage: c.req.header("baggage")
     };
-    logger20.info(
+    logger21.info(
       {
         otelHeaders,
         path: c.req.path,
@@ -9714,7 +10010,7 @@ app.openapi(
     const { tenantId, projectId, agentId, subAgentId } = executionContext;
     console.dir("executionContext", executionContext);
     if (subAgentId) {
-      logger20.info(
+      logger21.info(
         {
           message: "getRegisteredAgent (agent-level)",
           tenantId,
@@ -9725,8 +10021,13 @@ app.openapi(
         "agent-level well-known agent.json"
       );
       const credentialStores = c.get("credentialStores");
-      const agent = await getRegisteredAgent(executionContext, credentialStores);
-      logger20.info({ agent }, "agent registered: well-known agent.json");
+      const sandboxConfig = c.get("sandboxConfig");
+      const agent = await getRegisteredAgent({
+        executionContext,
+        credentialStoreRegistry: credentialStores,
+        sandboxConfig
+      });
+      logger21.info({ agent }, "agent registered: well-known agent.json");
       if (!agent) {
         throw agentsCore.createApiError({
           code: "not_found",
@@ -9735,7 +10036,7 @@ app.openapi(
       }
       return c.json(agent.agentCard);
     } else {
-      logger20.info(
+      logger21.info(
         {
           message: "getRegisteredAgent (agent-level)",
           tenantId,
@@ -9744,7 +10045,11 @@ app.openapi(
         },
         "agent-level well-known agent.json"
       );
-      const agent = await getRegisteredAgent(executionContext);
+      const sandboxConfig = c.get("sandboxConfig");
+      const agent = await getRegisteredAgent({
+        executionContext,
+        sandboxConfig
+      });
       if (!agent) {
         throw agentsCore.createApiError({
           code: "not_found",
@@ -9761,7 +10066,7 @@ app.post("/a2a", async (c) => {
     tracestate: c.req.header("tracestate"),
     baggage: c.req.header("baggage")
   };
-  logger20.info(
+  logger21.info(
     {
       otelHeaders,
       path: c.req.path,
@@ -9772,7 +10077,7 @@ app.post("/a2a", async (c) => {
   const executionContext = agentsCore.getRequestExecutionContext(c);
   const { tenantId, projectId, agentId, subAgentId } = executionContext;
   if (subAgentId) {
-    logger20.info(
+    logger21.info(
       {
         message: "a2a (agent-level)",
         tenantId,
@@ -9783,7 +10088,12 @@ app.post("/a2a", async (c) => {
       "agent-level a2a endpoint"
     );
     const credentialStores = c.get("credentialStores");
-    const agent = await getRegisteredAgent(executionContext, credentialStores);
+    const sandboxConfig = c.get("sandboxConfig");
+    const agent = await getRegisteredAgent({
+      executionContext,
+      credentialStoreRegistry: credentialStores,
+      sandboxConfig
+    });
     if (!agent) {
       return c.json(
         {
@@ -9796,7 +10106,7 @@ app.post("/a2a", async (c) => {
     }
     return a2aHandler(c, agent);
   } else {
-    logger20.info(
+    logger21.info(
       {
         message: "a2a (agent-level)",
         tenantId,
@@ -9830,7 +10140,12 @@ app.post("/a2a", async (c) => {
     }
     executionContext.subAgentId = agent.defaultSubAgentId;
     const credentialStores = c.get("credentialStores");
-    const defaultSubAgent = await getRegisteredAgent(executionContext, credentialStores);
+    const sandboxConfig = c.get("sandboxConfig");
+    const defaultSubAgent = await getRegisteredAgent({
+      executionContext,
+      credentialStoreRegistry: credentialStores,
+      sandboxConfig
+    });
     if (!defaultSubAgent) {
       return c.json(
         {
@@ -9901,28 +10216,37 @@ function extractTransferData(task) {
 }
 
 // src/a2a/transfer.ts
-var logger21 = agentsCore.getLogger("Transfer");
+var logger22 = agentsCore.getLogger("Transfer");
 async function executeTransfer({
   tenantId,
   threadId,
   projectId,
   targetSubAgentId
 }) {
-  logger21.info({
-    targetAgent: targetSubAgentId,
-    threadId,
-    tenantId,
-    projectId
-  }, "Executing transfer - calling setActiveAgentForThread");
+  logger22.info(
+    {
+      targetAgent: targetSubAgentId,
+      threadId,
+      tenantId,
+      projectId
+    },
+    "Executing transfer - calling setActiveAgentForThread"
+  );
   try {
     await agentsCore.setActiveAgentForThread(dbClient_default)({
       scopes: { tenantId, projectId },
       threadId,
       subAgentId: targetSubAgentId
     });
-    logger21.info({ targetAgent: targetSubAgentId, threadId }, "Successfully updated active_sub_agent_id in database");
+    logger22.info(
+      { targetAgent: targetSubAgentId, threadId },
+      "Successfully updated active_sub_agent_id in database"
+    );
   } catch (error) {
-    logger21.error({ error, targetAgent: targetSubAgentId, threadId }, "Failed to update active_sub_agent_id");
+    logger22.error(
+      { error, targetAgent: targetSubAgentId, threadId },
+      "Failed to update active_sub_agent_id"
+    );
     throw error;
   }
   return { success: true, targetSubAgentId };
@@ -10338,7 +10662,7 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
           timestamp: Date.now()
         });
       }
-    } catch (e) {
+    } catch (_e) {
     }
   }
   /**
@@ -10494,7 +10818,7 @@ function createMCPStreamHelper() {
 }
 
 // src/handlers/executionHandler.ts
-var logger22 = agentsCore.getLogger("ExecutionHandler");
+var logger23 = agentsCore.getLogger("ExecutionHandler");
 var ExecutionHandler = class {
   constructor() {
     __publicField(this, "MAX_ERRORS", 3);
@@ -10529,7 +10853,7 @@ var ExecutionHandler = class {
     if (emitOperations) {
       agentSessionManager.enableEmitOperations(requestId2);
     }
-    logger22.info(
+    logger23.info(
       { sessionId: requestId2, agentId, conversationId, emitOperations },
       "Created AgentSession for message execution"
     );
@@ -10546,7 +10870,7 @@ var ExecutionHandler = class {
         );
       }
     } catch (error) {
-      logger22.error(
+      logger23.error(
         {
           error: error instanceof Error ? error.message : "Unknown error",
           stack: error instanceof Error ? error.stack : void 0
@@ -10562,7 +10886,7 @@ var ExecutionHandler = class {
     try {
       await sseHelper.writeOperation(agentInitializingOp(requestId2, agentId));
       const taskId = `task_${conversationId}-${requestId2}`;
-      logger22.info(
+      logger23.info(
         { taskId, currentAgentId, conversationId, requestId: requestId2 },
         "Attempting to create or reuse existing task"
       );
@@ -10586,7 +10910,7 @@ var ExecutionHandler = class {
             sub_agent_id: currentAgentId
           }
         });
-        logger22.info(
+        logger23.info(
           {
             taskId,
             createdTaskMetadata: Array.isArray(task) ? task[0]?.metadata : task?.metadata
@@ -10595,27 +10919,27 @@ var ExecutionHandler = class {
         );
       } catch (error) {
         if (error?.message?.includes("UNIQUE constraint failed") || error?.message?.includes("PRIMARY KEY constraint failed") || error?.code === "SQLITE_CONSTRAINT_PRIMARYKEY") {
-          logger22.info(
+          logger23.info(
             { taskId, error: error.message },
             "Task already exists, fetching existing task"
           );
           const existingTask = await agentsCore.getTask(dbClient_default)({ id: taskId });
           if (existingTask) {
             task = existingTask;
-            logger22.info(
+            logger23.info(
               { taskId, existingTask },
               "Successfully reused existing task from race condition"
             );
           } else {
-            logger22.error({ taskId, error }, "Task constraint failed but task not found");
+            logger23.error({ taskId, error }, "Task constraint failed but task not found");
             throw error;
           }
         } else {
-          logger22.error({ taskId, error }, "Failed to create task due to non-constraint error");
+          logger23.error({ taskId, error }, "Failed to create task due to non-constraint error");
           throw error;
         }
       }
-      logger22.debug(
+      logger23.debug(
         {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           executionType: "create_initial_task",
@@ -10634,7 +10958,7 @@ var ExecutionHandler = class {
       const maxTransfers = agentConfig?.stopWhen?.transferCountIs ?? 10;
       while (iterations < maxTransfers) {
         iterations++;
-        logger22.info(
+        logger23.info(
           { iterations, currentAgentId, agentId, conversationId, fromSubAgentId },
           `Execution loop iteration ${iterations} with agent ${currentAgentId}, transfer from: ${fromSubAgentId || "none"}`
         );
@@ -10642,10 +10966,10 @@ var ExecutionHandler = class {
           scopes: { tenantId, projectId },
           conversationId
         });
-        logger22.info({ activeAgent }, "activeAgent");
+        logger23.info({ activeAgent }, "activeAgent");
         if (activeAgent && activeAgent.activeSubAgentId !== currentAgentId) {
           currentAgentId = activeAgent.activeSubAgentId;
-          logger22.info({ currentAgentId }, `Updated current agent to: ${currentAgentId}`);
+          logger23.info({ currentAgentId }, `Updated current agent to: ${currentAgentId}`);
         }
         const agentBaseUrl = `${baseUrl}/agents`;
         const a2aClient = new A2AClient(agentBaseUrl, {
@@ -10686,13 +11010,13 @@ var ExecutionHandler = class {
         });
         if (!messageResponse?.result) {
           errorCount++;
-          logger22.error(
+          logger23.error(
             { currentAgentId, iterations, errorCount },
             `No response from agent ${currentAgentId} on iteration ${iterations} (error ${errorCount}/${this.MAX_ERRORS})`
           );
           if (errorCount >= this.MAX_ERRORS) {
             const errorMessage2 = `Maximum error limit (${this.MAX_ERRORS}) reached`;
-            logger22.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
+            logger23.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
             await sseHelper.writeOperation(errorOp(errorMessage2, currentAgentId || "system"));
             if (task) {
               await agentsCore.updateTask(dbClient_default)({
@@ -10716,7 +11040,7 @@ var ExecutionHandler = class {
         if (isTransferTask(messageResponse.result)) {
           const transferData = extractTransferData(messageResponse.result);
           if (!transferData) {
-            logger22.error(
+            logger23.error(
               { result: messageResponse.result },
               "Transfer detected but no transfer data found"
             );
@@ -10725,10 +11049,7 @@ var ExecutionHandler = class {
           const { targetSubAgentId, fromSubAgentId: transferFromAgent } = transferData;
           const firstArtifact = messageResponse.result.artifacts[0];
           const transferReason = firstArtifact?.parts[1]?.kind === "text" ? firstArtifact.parts[1].text : "Transfer initiated";
-          logger22.info(
-            { targetSubAgentId, transferReason, transferFromAgent },
-            "Transfer response"
-          );
+          logger23.info({ targetSubAgentId, transferReason, transferFromAgent }, "Transfer response");
           currentMessage = `<transfer_context> ${transferReason} </transfer_context>`;
           const { success, targetSubAgentId: newAgentId } = await executeTransfer({
             projectId,
@@ -10739,7 +11060,7 @@ var ExecutionHandler = class {
           if (success) {
             fromSubAgentId = currentAgentId;
             currentAgentId = newAgentId;
-            logger22.info(
+            logger23.info(
               {
                 transferFrom: fromSubAgentId,
                 transferTo: currentAgentId,
@@ -10753,7 +11074,7 @@ var ExecutionHandler = class {
         let responseParts = [];
         if (messageResponse.result.streamedContent?.parts) {
           responseParts = messageResponse.result.streamedContent.parts;
-          logger22.info(
+          logger23.info(
             { partsCount: responseParts.length },
             "Using streamed content for conversation history"
           );
@@ -10761,7 +11082,7 @@ var ExecutionHandler = class {
           responseParts = messageResponse.result.artifacts?.flatMap(
             (artifact) => artifact.parts || []
           ) || [];
-          logger22.info(
+          logger23.info(
             { partsCount: responseParts.length },
             "Using artifacts for conversation history (fallback)"
           );
@@ -10770,7 +11091,7 @@ var ExecutionHandler = class {
           const agentSessionData = agentSessionManager.getSession(requestId2);
           if (agentSessionData) {
             const sessionSummary = agentSessionData.getSummary();
-            logger22.info(sessionSummary, "AgentSession data after completion");
+            logger23.info(sessionSummary, "AgentSession data after completion");
           }
           let textContent = "";
           for (const part of responseParts) {
@@ -10823,22 +11144,22 @@ var ExecutionHandler = class {
                 }
               });
               const updateTaskEnd = Date.now();
-              logger22.info(
+              logger23.info(
                 { duration: updateTaskEnd - updateTaskStart },
                 "Completed updateTask operation"
               );
               await sseHelper.writeOperation(completionOp(currentAgentId, iterations));
               await sseHelper.complete();
-              logger22.info({}, "Ending AgentSession and cleaning up");
+              logger23.info({}, "Ending AgentSession and cleaning up");
               agentSessionManager.endSession(requestId2);
-              logger22.info({}, "Cleaning up streamHelper");
+              logger23.info({}, "Cleaning up streamHelper");
               unregisterStreamHelper(requestId2);
               let response;
               if (sseHelper instanceof MCPStreamHelper) {
                 const captured = sseHelper.getCapturedResponse();
                 response = captured.text || "No response content";
               }
-              logger22.info({}, "ExecutionHandler returning success");
+              logger23.info({}, "ExecutionHandler returning success");
               return { success: true, iterations, response };
             } catch (error) {
               agentsCore.setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
@@ -10849,13 +11170,13 @@ var ExecutionHandler = class {
           });
         }
         errorCount++;
-        logger22.warn(
+        logger23.warn(
           { iterations, errorCount },
           `No valid response or transfer on iteration ${iterations} (error ${errorCount}/${this.MAX_ERRORS})`
         );
         if (errorCount >= this.MAX_ERRORS) {
           const errorMessage2 = `Maximum error limit (${this.MAX_ERRORS}) reached`;
-          logger22.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
+          logger23.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
           await sseHelper.writeOperation(errorOp(errorMessage2, currentAgentId || "system"));
           if (task) {
             await agentsCore.updateTask(dbClient_default)({
@@ -10876,7 +11197,7 @@ var ExecutionHandler = class {
         }
       }
       const errorMessage = `Maximum transfer limit (${maxTransfers}) reached without completion`;
-      logger22.error({ maxTransfers, iterations }, errorMessage);
+      logger23.error({ maxTransfers, iterations }, errorMessage);
       await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || "system"));
       if (task) {
         await agentsCore.updateTask(dbClient_default)({
@@ -10895,7 +11216,7 @@ var ExecutionHandler = class {
       unregisterStreamHelper(requestId2);
       return { success: false, error: errorMessage, iterations };
     } catch (error) {
-      logger22.error({ error }, "Error in execution handler");
+      logger23.error({ error }, "Error in execution handler");
       const errorMessage = error instanceof Error ? error.message : "Unknown execution error";
       await sseHelper.writeOperation(
         errorOp(`Execution error: ${errorMessage}`, currentAgentId || "system")
@@ -10923,7 +11244,7 @@ var ExecutionHandler = class {
 // src/routes/chat.ts
 init_logger();
 var app2 = new zodOpenapi.OpenAPIHono();
-var logger23 = agentsCore.getLogger("completionsHandler");
+var logger24 = agentsCore.getLogger("completionsHandler");
 var chatCompletionsRoute = zodOpenapi.createRoute({
   method: "post",
   path: "/completions",
@@ -11041,7 +11362,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
     tracestate: c.req.header("tracestate"),
     baggage: c.req.header("baggage")
   };
-  logger23.info(
+  logger24.info(
     {
       otelHeaders,
       path: c.req.path,
@@ -11150,7 +11471,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
         dbClient: dbClient_default,
         credentialStores
       });
-      logger23.info(
+      logger24.info(
         {
           tenantId,
           projectId,
@@ -11198,7 +11519,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
         try {
           const sseHelper = createSSEStreamHelper(stream2, requestId2, timestamp);
           await sseHelper.writeRole();
-          logger23.info({ subAgentId }, "Starting execution");
+          logger24.info({ subAgentId }, "Starting execution");
           const emitOperationsHeader = c.req.header("x-emit-operations");
           const emitOperations = emitOperationsHeader === "true";
           const executionHandler = new ExecutionHandler();
@@ -11211,7 +11532,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
             sseHelper,
             emitOperations
           });
-          logger23.info(
+          logger24.info(
             { result },
             `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
           );
@@ -11225,7 +11546,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
           }
           await sseHelper.complete();
         } catch (error) {
-          logger23.error(
+          logger24.error(
             {
               error: error instanceof Error ? error.message : error,
               stack: error instanceof Error ? error.stack : void 0
@@ -11242,13 +11563,13 @@ app2.openapi(chatCompletionsRoute, async (c) => {
             );
             await sseHelper.complete();
           } catch (streamError) {
-            logger23.error({ streamError }, "Failed to write error to stream");
+            logger24.error({ streamError }, "Failed to write error to stream");
           }
         }
       });
     });
   } catch (error) {
-    logger23.error(
+    logger24.error(
       {
         error: error instanceof Error ? error.message : error,
         stack: error instanceof Error ? error.stack : void 0
@@ -11276,7 +11597,7 @@ var chat_default = app2;
 init_dbClient();
 init_logger();
 var app3 = new zodOpenapi.OpenAPIHono();
-var logger24 = agentsCore.getLogger("chatDataStream");
+var logger25 = agentsCore.getLogger("chatDataStream");
 var chatDataStreamRoute = zodOpenapi.createRoute({
   method: "post",
   path: "/chat",
@@ -11400,7 +11721,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
       });
       const lastUserMessage = body.messages.filter((m) => m.role === "user").slice(-1)[0];
       const userText = typeof lastUserMessage?.content === "string" ? lastUserMessage.content : lastUserMessage?.parts?.map((p) => p.text).join("") || "";
-      logger24.info({ userText, lastUserMessage }, "userText");
+      logger25.info({ userText, lastUserMessage }, "userText");
       const messageSpan = api.trace.getActiveSpan();
       if (messageSpan) {
         messageSpan.setAttributes({
@@ -11445,7 +11766,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
               await streamHelper.writeOperation(errorOp("Unable to process request", "system"));
             }
           } catch (err) {
-            logger24.error({ err }, "Streaming error");
+            logger25.error({ err }, "Streaming error");
             await streamHelper.writeOperation(errorOp("Internal server error", "system"));
           } finally {
             if ("cleanup" in streamHelper && typeof streamHelper.cleanup === "function") {
@@ -11467,7 +11788,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
       );
     });
   } catch (error) {
-    logger24.error({ error }, "chatDataStream error");
+    logger25.error({ error }, "chatDataStream error");
     throw agentsCore.createApiError({
       code: "internal_server_error",
       message: "Failed to process chat completion"
@@ -11482,7 +11803,7 @@ init_logger();
 function createMCPSchema(schema) {
   return schema;
 }
-var logger25 = agentsCore.getLogger("mcp");
+var logger26 = agentsCore.getLogger("mcp");
 var _MockResponseSingleton = class _MockResponseSingleton {
   constructor() {
     __publicField(this, "mockRes");
@@ -11537,21 +11858,21 @@ var createSpoofInitMessage = (mcpProtocolVersion) => ({
   id: 0
 });
 var spoofTransportInitialization = async (transport, req, sessionId, mcpProtocolVersion) => {
-  logger25.info({ sessionId }, "Spoofing initialization message to set transport state");
+  logger26.info({ sessionId }, "Spoofing initialization message to set transport state");
   const spoofInitMessage = createSpoofInitMessage(mcpProtocolVersion);
   const mockRes = MockResponseSingleton.getInstance().getMockResponse();
   try {
     await transport.handleRequest(req, mockRes, spoofInitMessage);
-    logger25.info({ sessionId }, "Successfully spoofed initialization");
+    logger26.info({ sessionId }, "Successfully spoofed initialization");
   } catch (spoofError) {
-    logger25.warn({ sessionId, error: spoofError }, "Spoof initialization failed, continuing anyway");
+    logger26.warn({ sessionId, error: spoofError }, "Spoof initialization failed, continuing anyway");
   }
 };
 var validateSession = async (req, res, body, tenantId, projectId, agentId) => {
   const sessionId = req.headers["mcp-session-id"];
-  logger25.info({ sessionId }, "Received MCP session ID");
+  logger26.info({ sessionId }, "Received MCP session ID");
   if (!sessionId) {
-    logger25.info({ body }, "Missing session ID");
+    logger26.info({ body }, "Missing session ID");
     res.writeHead(400).end(
       JSON.stringify({
         jsonrpc: "2.0",
@@ -11577,7 +11898,7 @@ var validateSession = async (req, res, body, tenantId, projectId, agentId) => {
     scopes: { tenantId, projectId },
     conversationId: sessionId
   });
-  logger25.info(
+  logger26.info(
     {
       sessionId,
       conversationFound: !!conversation,
@@ -11588,7 +11909,7 @@ var validateSession = async (req, res, body, tenantId, projectId, agentId) => {
     "Conversation lookup result"
   );
   if (!conversation || conversation.metadata?.sessionData?.sessionType !== "mcp" || conversation.metadata?.sessionData?.agentId !== agentId) {
-    logger25.info(
+    logger26.info(
       { sessionId, conversationId: conversation?.id },
       "MCP session not found or invalid"
     );
@@ -11649,7 +11970,7 @@ var executeAgentQuery = async (executionContext, conversationId, query, defaultS
     requestId: requestId2,
     sseHelper: mcpStreamHelper
   });
-  logger25.info(
+  logger26.info(
     { result },
     `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
   );
@@ -11733,7 +12054,7 @@ var getServer = async (headers, executionContext, conversationId, credentialStor
           dbClient: dbClient_default,
           credentialStores
         });
-        logger25.info(
+        logger26.info(
           {
             tenantId,
             projectId,
@@ -11795,7 +12116,7 @@ var validateRequestParameters = (c) => {
 };
 var handleInitializationRequest = async (body, executionContext, validatedContext, req, res, c, credentialStores) => {
   const { tenantId, projectId, agentId } = executionContext;
-  logger25.info({ body }, "Received initialization request");
+  logger26.info({ body }, "Received initialization request");
   const sessionId = agentsCore.getConversationId();
   const activeSpan = api.trace.getActiveSpan();
   if (activeSpan) {
@@ -11851,7 +12172,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
         }
       }
     });
-    logger25.info(
+    logger26.info(
       { sessionId, conversationId: conversation.id },
       "Created MCP session as conversation"
     );
@@ -11860,9 +12181,9 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
     });
     const server = await getServer(validatedContext, executionContext, sessionId, credentialStores);
     await server.connect(transport);
-    logger25.info({ sessionId }, "Server connected for initialization");
+    logger26.info({ sessionId }, "Server connected for initialization");
     res.setHeader("Mcp-Session-Id", sessionId);
-    logger25.info(
+    logger26.info(
       {
         sessionId,
         bodyMethod: body?.method,
@@ -11871,7 +12192,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
       "About to handle initialization request"
     );
     await transport.handleRequest(req, res, body);
-    logger25.info({ sessionId }, "Successfully handled initialization request");
+    logger26.info({ sessionId }, "Successfully handled initialization request");
     return fetchToNode.toFetchResponse(res);
   });
 };
@@ -11898,8 +12219,8 @@ var handleExistingSessionRequest = async (body, executionContext, validatedConte
     sessionId,
     conversation.metadata?.session_data?.mcpProtocolVersion
   );
-  logger25.info({ sessionId }, "Server connected and transport initialized");
-  logger25.info(
+  logger26.info({ sessionId }, "Server connected and transport initialized");
+  logger26.info(
     {
       sessionId,
       bodyKeys: Object.keys(body || {}),
@@ -11913,9 +12234,9 @@ var handleExistingSessionRequest = async (body, executionContext, validatedConte
   );
   try {
     await transport.handleRequest(req, res, body);
-    logger25.info({ sessionId }, "Successfully handled MCP request");
+    logger26.info({ sessionId }, "Successfully handled MCP request");
   } catch (transportError) {
-    logger25.error(
+    logger26.error(
       {
         sessionId,
         error: transportError,
@@ -11966,13 +12287,13 @@ app4.openapi(
       }
       const { executionContext } = paramValidation;
       const body = c.get("requestBody") || {};
-      logger25.info({ body, bodyKeys: Object.keys(body || {}) }, "Parsed request body");
+      logger26.info({ body, bodyKeys: Object.keys(body || {}) }, "Parsed request body");
       const isInitRequest = body.method === "initialize";
       const { req, res } = fetchToNode.toReqRes(c.req.raw);
       const validatedContext = c.get("validatedContext") || {};
       const credentialStores = c.get("credentialStores");
-      logger25.info({ validatedContext }, "Validated context");
-      logger25.info({ req }, "request");
+      logger26.info({ validatedContext }, "Validated context");
+      logger26.info({ req }, "request");
       if (isInitRequest) {
         return await handleInitializationRequest(
           body,
@@ -11994,7 +12315,7 @@ app4.openapi(
         );
       }
     } catch (e) {
-      logger25.error(
+      logger26.error(
         {
           error: e instanceof Error ? e.message : e,
           stack: e instanceof Error ? e.stack : void 0
@@ -12006,7 +12327,7 @@ app4.openapi(
   }
 );
 app4.get("/", async (c) => {
-  logger25.info({}, "Received GET MCP request");
+  logger26.info({}, "Received GET MCP request");
   return c.json(
     {
       jsonrpc: "2.0",
@@ -12020,7 +12341,7 @@ app4.get("/", async (c) => {
   );
 });
 app4.delete("/", async (c) => {
-  logger25.info({}, "Received DELETE MCP request");
+  logger26.info({}, "Received DELETE MCP request");
   return c.json(
     {
       jsonrpc: "2.0",
@@ -12033,14 +12354,17 @@ app4.delete("/", async (c) => {
 var mcp_default = app4;
 
 // src/app.ts
-var logger26 = agentsCore.getLogger("agents-run-api");
-function createExecutionHono(serverConfig, credentialStores) {
+var logger27 = agentsCore.getLogger("agents-run-api");
+function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
   const app6 = new zodOpenapi.OpenAPIHono();
   app6.use("*", otel.otel());
   app6.use("*", requestId.requestId());
   app6.use("*", async (c, next) => {
     c.set("serverConfig", serverConfig);
     c.set("credentialStores", credentialStores);
+    if (sandboxConfig) {
+      c.set("sandboxConfig", sandboxConfig);
+    }
     return next();
   });
   app6.use("*", async (c, next) => {
@@ -12049,7 +12373,7 @@ function createExecutionHono(serverConfig, credentialStores) {
         const body = await c.req.json();
         c.set("requestBody", body);
       } catch (error) {
-        logger26.debug({ error }, "Failed to parse JSON body, continuing without parsed body");
+        logger27.debug({ error }, "Failed to parse JSON body, continuing without parsed body");
       }
     }
     return next();
@@ -12100,8 +12424,8 @@ function createExecutionHono(serverConfig, credentialStores) {
       if (!isExpectedError) {
         const errorMessage = err instanceof Error ? err.message : String(err);
         const errorStack = err instanceof Error ? err.stack : void 0;
-        if (logger26) {
-          logger26.error(
+        if (logger27) {
+          logger27.error(
             {
               error: err,
               message: errorMessage,
@@ -12113,8 +12437,8 @@ function createExecutionHono(serverConfig, credentialStores) {
           );
         }
       } else {
-        if (logger26) {
-          logger26.error(
+        if (logger27) {
+          logger27.error(
             {
               error: err,
               path: c.req.path,
@@ -12131,8 +12455,8 @@ function createExecutionHono(serverConfig, credentialStores) {
         const response = err.getResponse();
         return response;
       } catch (responseError) {
-        if (logger26) {
-          logger26.error({ error: responseError }, "Error while handling HTTPException response");
+        if (logger27) {
+          logger27.error({ error: responseError }, "Error while handling HTTPException response");
         }
       }
     }
@@ -12166,7 +12490,7 @@ function createExecutionHono(serverConfig, credentialStores) {
   app6.use("*", async (c, next) => {
     const executionContext = c.get("executionContext");
     if (!executionContext) {
-      logger26.debug({}, "Empty execution context");
+      logger27.debug({}, "Empty execution context");
       return next();
     }
     const { tenantId, projectId, agentId } = executionContext;
@@ -12175,7 +12499,7 @@ function createExecutionHono(serverConfig, credentialStores) {
     if (requestBody) {
       conversationId = requestBody.conversationId;
       if (!conversationId) {
-        logger26.debug({ requestBody }, "No conversation ID found in request body");
+        logger27.debug({ requestBody }, "No conversation ID found in request body");
       }
     }
     const entries = Object.fromEntries(
@@ -12190,7 +12514,7 @@ function createExecutionHono(serverConfig, credentialStores) {
       })
     );
     if (!Object.keys(entries).length) {
-      logger26.debug({}, "Empty entries for baggage");
+      logger27.debug({}, "Empty entries for baggage");
       return next();
     }
     const bag = Object.entries(entries).reduce(
@@ -12261,7 +12585,7 @@ function createExecutionApp(config) {
   const serverConfig = config?.serverConfig ?? defaultConfig;
   const stores = config?.credentialStores ?? defaultStores;
   const registry = new agentsCore.CredentialStoreRegistry(stores);
-  return createExecutionHono(serverConfig, registry);
+  return createExecutionHono(serverConfig, registry, config?.sandboxConfig);
 }
 
 exports.createExecutionApp = createExecutionApp;