@inkeep/agents-run-api 0.0.0-dev-20251008200151 → 0.0.0-dev-20251009000750

package/dist/index.cjs

@@ -5,6 +5,11 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var agentsCore = require('@inkeep/agents-core');
 var z6 = require('zod');
 var nanoid = require('nanoid');
+var child_process = require('child_process');
+var crypto = require('crypto');
+var fs = require('fs');
+var os = require('os');
+var path = require('path');
 var otel = require('@hono/otel');
 var zodOpenapi = require('@hono/zod-openapi');
 var api = require('@opentelemetry/api');
@@ -347,8 +352,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,
@@ -360,8 +365,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
@@ -377,6 +382,326 @@ var init_conversations = __esm({
   }
 });
 
+// src/tools/LocalSandboxExecutor.ts
+var LocalSandboxExecutor_exports = {};
+__export(LocalSandboxExecutor_exports, {
+  LocalSandboxExecutor: () => LocalSandboxExecutor
+});
+var logger18, _LocalSandboxExecutor, LocalSandboxExecutor;
+var init_LocalSandboxExecutor = __esm({
+  "src/tools/LocalSandboxExecutor.ts"() {
+    logger18 = agentsCore.getLogger("local-sandbox-executor");
+    _LocalSandboxExecutor = class _LocalSandboxExecutor {
+      constructor() {
+        __publicField(this, "tempDir");
+        __publicField(this, "sandboxPool", {});
+        __publicField(this, "POOL_TTL", 5 * 60 * 1e3);
+        // 5 minutes
+        __publicField(this, "MAX_USE_COUNT", 50);
+        this.tempDir = path.join(os.tmpdir(), "inkeep-sandboxes");
+        this.ensureTempDir();
+        this.startPoolCleanup();
+      }
+      static getInstance() {
+        if (!_LocalSandboxExecutor.instance) {
+          _LocalSandboxExecutor.instance = new _LocalSandboxExecutor();
+        }
+        return _LocalSandboxExecutor.instance;
+      }
+      ensureTempDir() {
+        try {
+          fs.mkdirSync(this.tempDir, { recursive: true });
+        } catch {
+        }
+      }
+      generateDependencyHash(dependencies) {
+        const sortedDeps = Object.keys(dependencies).sort().map((key) => `${key}@${dependencies[key]}`).join(",");
+        return crypto.createHash("sha256").update(sortedDeps).digest("hex").substring(0, 16);
+      }
+      getCachedSandbox(dependencyHash) {
+        const poolKey = dependencyHash;
+        const sandbox = this.sandboxPool[poolKey];
+        if (sandbox && fs.existsSync(sandbox.sandboxDir)) {
+          const now = Date.now();
+          if (now - sandbox.lastUsed < this.POOL_TTL && sandbox.useCount < this.MAX_USE_COUNT) {
+            sandbox.lastUsed = now;
+            sandbox.useCount++;
+            logger18.debug(
+              {
+                poolKey,
+                useCount: sandbox.useCount,
+                sandboxDir: sandbox.sandboxDir,
+                lastUsed: new Date(sandbox.lastUsed).toISOString()
+              },
+              "Reusing cached sandbox"
+            );
+            return sandbox.sandboxDir;
+          } else {
+            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
+        };
+        logger18.debug({ poolKey, sandboxDir }, "Added sandbox to pool");
+      }
+      cleanupSandbox(sandboxDir) {
+        try {
+          fs.rmSync(sandboxDir, { recursive: true, force: true });
+          logger18.debug({ sandboxDir }, "Cleaned up sandbox");
+        } catch (error) {
+          logger18.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 > this.POOL_TTL || sandbox.useCount >= this.MAX_USE_COUNT) {
+              this.cleanupSandbox(sandbox.sandboxDir);
+              keysToDelete.push(key);
+            }
+          }
+          keysToDelete.forEach((key) => {
+            delete this.sandboxPool[key];
+          });
+          if (keysToDelete.length > 0) {
+            logger18.debug({ cleanedCount: keysToDelete.length }, "Cleaned up expired sandboxes");
+          }
+        }, 6e4);
+      }
+      detectModuleType(executeCode) {
+        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 (hasEsmSyntax && hasCjsSyntax) {
+          logger18.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 dependencies = config.dependencies || {};
+        const dependencyHash = this.generateDependencyHash(dependencies);
+        logger18.debug(
+          {
+            toolId,
+            dependencies,
+            dependencyHash,
+            poolSize: Object.keys(this.sandboxPool).length
+          },
+          "Executing function tool"
+        );
+        let sandboxDir = this.getCachedSandbox(dependencyHash);
+        let isNewSandbox = false;
+        if (!sandboxDir) {
+          sandboxDir = path.join(this.tempDir, `sandbox-${dependencyHash}-${Date.now()}`);
+          fs.mkdirSync(sandboxDir, { recursive: true });
+          isNewSandbox = true;
+          logger18.debug(
+            {
+              toolId,
+              dependencyHash,
+              sandboxDir,
+              dependencies
+            },
+            "Creating new sandbox"
+          );
+          const moduleType = this.detectModuleType(config.executeCode);
+          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"
+            }
+          };
+          fs.writeFileSync(path.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);
+          const executionCode = this.wrapFunctionCode(config.executeCode, args);
+          const fileExtension = moduleType === "esm" ? "mjs" : "js";
+          fs.writeFileSync(path.join(sandboxDir, `index.${fileExtension}`), executionCode, "utf8");
+          const result = await this.executeInSandbox(
+            sandboxDir,
+            config.sandboxConfig?.timeout || 3e4,
+            moduleType
+          );
+          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 npm = child_process.spawn("npm", ["install"], {
+            cwd: sandboxDir,
+            stdio: "pipe"
+          });
+          let stderr = "";
+          npm.stdout?.on("data", () => {
+          });
+          npm.stderr?.on("data", (data) => {
+            stderr += data.toString();
+          });
+          npm.on("close", (code) => {
+            if (code === 0) {
+              logger18.debug({ sandboxDir }, "Dependencies installed successfully");
+              resolve();
+            } else {
+              logger18.error({ sandboxDir, code, stderr }, "Failed to install dependencies");
+              reject(new Error(`npm install failed with code ${code}: ${stderr}`));
+            }
+          });
+          npm.on("error", (err) => {
+            logger18.error({ sandboxDir, error: err }, "Failed to spawn npm install");
+            reject(err);
+          });
+        });
+      }
+      async executeInSandbox(sandboxDir, timeout, moduleType) {
+        return new Promise((resolve, reject) => {
+          const fileExtension = moduleType === "esm" ? "mjs" : "js";
+          const spawnOptions = {
+            cwd: sandboxDir,
+            stdio: "pipe",
+            // Security: drop privileges and limit resources
+            uid: process.getuid ? process.getuid() : void 0,
+            gid: process.getgid ? process.getgid() : void 0
+          };
+          const node = child_process.spawn("node", [`index.${fileExtension}`], spawnOptions);
+          let stdout = "";
+          let stderr = "";
+          let outputSize = 0;
+          const MAX_OUTPUT_SIZE = 1024 * 1024;
+          node.stdout?.on("data", (data) => {
+            const dataStr = data.toString();
+            outputSize += dataStr.length;
+            if (outputSize > MAX_OUTPUT_SIZE) {
+              node.kill("SIGTERM");
+              reject(new Error(`Output size exceeded limit of ${MAX_OUTPUT_SIZE} bytes`));
+              return;
+            }
+            stdout += dataStr;
+          });
+          node.stderr?.on("data", (data) => {
+            const dataStr = data.toString();
+            outputSize += dataStr.length;
+            if (outputSize > MAX_OUTPUT_SIZE) {
+              node.kill("SIGTERM");
+              reject(new Error(`Output size exceeded limit of ${MAX_OUTPUT_SIZE} bytes`));
+              return;
+            }
+            stderr += dataStr;
+          });
+          const timeoutId = setTimeout(() => {
+            logger18.warn({ sandboxDir, timeout }, "Function execution timed out, killing process");
+            node.kill("SIGTERM");
+            setTimeout(() => {
+              try {
+                node.kill("SIGKILL");
+              } catch {
+              }
+            }, 5e3);
+            reject(new Error(`Function execution timed out after ${timeout}ms`));
+          }, timeout);
+          node.on("close", (code, signal) => {
+            clearTimeout(timeoutId);
+            if (code === 0) {
+              try {
+                const result = JSON.parse(stdout);
+                if (result.success) {
+                  resolve(result.result);
+                } else {
+                  reject(new Error(result.error || "Function execution failed"));
+                }
+              } catch (parseError) {
+                logger18.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}`;
+              logger18.error({ code, signal, stderr }, "Function execution failed");
+              reject(new Error(errorMsg));
+            }
+          });
+          node.on("error", (error) => {
+            clearTimeout(timeoutId);
+            logger18.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)};
+
+execute(args)
+  .then(result => {
+    console.log(JSON.stringify({ success: true, result }));
+  })
+  .catch(error => {
+    console.log(JSON.stringify({ success: false, error: error.message }));
+  });
+`;
+      }
+    };
+    __publicField(_LocalSandboxExecutor, "instance", null);
+    LocalSandboxExecutor = _LocalSandboxExecutor;
+  }
+});
+
 // src/utils/json-postprocessor.ts
 var json_postprocessor_exports = {};
 __export(json_postprocessor_exports, {
@@ -7053,7 +7378,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,
@@ -7334,7 +7659,10 @@ var Agent = class {
     ]);
   }
   async getMcpTools(sessionId, streamRequestId) {
-    const tools = await Promise.all(this.config.tools?.map((tool3) => this.getMcpTool(tool3)) || []) || [];
+    const mcpTools = this.config.tools?.filter((tool3) => {
+      return tool3.config?.type === "mcp";
+    }) || [];
+    const tools = await Promise.all(mcpTools.map((tool3) => this.getMcpTool(tool3)) || []) || [];
     if (!sessionId) {
       const combinedTools = tools.reduce((acc, tool3) => {
         return Object.assign(acc, tool3);
@@ -7354,14 +7682,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);
@@ -7375,7 +7703,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;
             }
           }
@@ -7394,6 +7722,9 @@ var Agent = class {
    * Convert database McpTool to builder MCPToolConfig format
    */
   convertToMCPToolConfig(tool3, agentToolRelationHeaders) {
+    if (tool3.config.type !== "mcp") {
+      throw new Error(`Cannot convert non-MCP tool to MCP config: ${tool3.id}`);
+    }
     return {
       id: tool3.id,
       name: tool3.name,
@@ -7462,6 +7793,9 @@ var Agent = class {
         selectedTools
       );
     } else {
+      if (tool3.config.type !== "mcp") {
+        throw new Error(`Cannot build server config for non-MCP tool: ${tool3.id}`);
+      }
       serverConfig = {
         type: tool3.config.mcp.transport?.type || agentsCore.MCPTransportType.streamableHttp,
         url: tool3.config.mcp.server.url,
@@ -7470,7 +7804,7 @@ var Agent = class {
         headers: agentToolRelationHeaders
       };
     }
-    logger18.info(
+    logger19.info(
       {
         toolName: tool3.name,
         credentialReferenceId,
@@ -7495,7 +7829,7 @@ var Agent = class {
         this.mcpClientCache.set(cacheKey, client);
       } catch (error) {
         this.mcpConnectionLocks.delete(cacheKey);
-        logger18.error(
+        logger19.error(
           {
             toolName: tool3.name,
             agentId: this.config.id,
@@ -7519,7 +7853,7 @@ var Agent = class {
       await client.connect();
       return client;
     } catch (error) {
-      logger18.error(
+      logger19.error(
         {
           toolName: tool3.name,
           agentId: this.config.id,
@@ -7530,21 +7864,88 @@ var Agent = class {
       throw error;
     }
   }
-  getFunctionTools(streamRequestId) {
-    if (!this.config.functionTools) return {};
+  async getFunctionTools(sessionId, streamRequestId) {
     const functionTools = {};
-    for (const funcTool of this.config.functionTools) {
-      const aiTool = ai.tool({
-        description: funcTool.description,
-        inputSchema: funcTool.schema || z6.z.object({}),
-        execute: funcTool.execute
+    try {
+      const toolsForAgent = await agentsCore.getToolsForAgent(dbClient_default)({
+        scopes: {
+          tenantId: this.config.tenantId || "default",
+          projectId: this.config.projectId || "default",
+          graphId: this.config.graphId,
+          agentId: this.config.id
+        }
       });
-      functionTools[funcTool.name] = this.wrapToolWithStreaming(
-        funcTool.name,
-        aiTool,
-        streamRequestId,
-        "tool"
-      );
+      const toolsData = toolsForAgent.data || [];
+      const functionToolDefs = toolsData.filter((tool3) => tool3.tool.config.type === "function");
+      if (functionToolDefs.length === 0) {
+        return functionTools;
+      }
+      const { LocalSandboxExecutor: LocalSandboxExecutor2 } = await Promise.resolve().then(() => (init_LocalSandboxExecutor(), LocalSandboxExecutor_exports));
+      const sandboxExecutor = LocalSandboxExecutor2.getInstance();
+      for (const toolDef of functionToolDefs) {
+        if (toolDef.tool.config?.type === "function") {
+          const functionId = toolDef.tool.functionId;
+          if (!functionId) {
+            logger19.warn({ toolId: toolDef.tool.id }, "Function tool missing functionId reference");
+            continue;
+          }
+          const functionData = await agentsCore.getFunction(dbClient_default)({
+            functionId,
+            scopes: {
+              tenantId: this.config.tenantId || "default",
+              projectId: this.config.projectId || "default"
+            }
+          });
+          if (!functionData) {
+            logger19.warn(
+              { functionId, toolId: toolDef.tool.id },
+              "Function not found in functions table"
+            );
+            continue;
+          }
+          const zodSchema = jsonSchemaToZod(functionData.inputSchema);
+          const aiTool = ai.tool({
+            description: toolDef.tool.description || toolDef.tool.name,
+            inputSchema: zodSchema,
+            execute: async (args, { toolCallId }) => {
+              logger19.debug(
+                { toolName: toolDef.tool.name, toolCallId, args },
+                "Function Tool Called"
+              );
+              try {
+                const result = await sandboxExecutor.executeFunctionTool(toolDef.tool.id, args, {
+                  description: toolDef.tool.description || toolDef.tool.name,
+                  inputSchema: functionData.inputSchema || {},
+                  executeCode: functionData.executeCode,
+                  dependencies: functionData.dependencies || {}
+                });
+                toolSessionManager.recordToolResult(sessionId || "", {
+                  toolCallId,
+                  toolName: toolDef.tool.name,
+                  args,
+                  result,
+                  timestamp: Date.now()
+                });
+                return { result, toolCallId };
+              } catch (error) {
+                logger19.error(
+                  { toolName: toolDef.tool.name, toolCallId, error },
+                  "Function tool execution failed"
+                );
+                throw error;
+              }
+            }
+          });
+          functionTools[toolDef.tool.name] = this.wrapToolWithStreaming(
+            toolDef.tool.name,
+            aiTool,
+            streamRequestId || "",
+            "tool"
+          );
+        }
+      }
+    } catch (error) {
+      logger19.error({ error }, "Failed to load function tools from database");
     }
     return functionTools;
   }
@@ -7554,7 +7955,7 @@ var Agent = class {
   async getResolvedContext(conversationId, requestContext) {
     try {
       if (!this.config.contextConfigId) {
-        logger18.debug({ graphId: this.config.graphId }, "No context config found for graph");
+        logger19.debug({ graphId: this.config.graphId }, "No context config found for graph");
         return null;
       }
       const contextConfig = await agentsCore.getContextConfigById(dbClient_default)({
@@ -7566,7 +7967,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) {
@@ -7583,7 +7984,7 @@ var Agent = class {
         $now: (/* @__PURE__ */ new Date()).toISOString(),
         $env: process.env
       };
-      logger18.debug(
+      logger19.debug(
         {
           conversationId,
           contextConfigId: contextConfig.id,
@@ -7597,7 +7998,7 @@ var Agent = class {
       );
       return contextWithBuiltins;
     } catch (error) {
-      logger18.error(
+      logger19.error(
         {
           conversationId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -7621,7 +8022,7 @@ var Agent = class {
       });
       return graphDefinition?.graphPrompt || void 0;
     } catch (error) {
-      logger18.warn(
+      logger19.warn(
         {
           graphId: this.config.graphId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -7650,7 +8051,7 @@ var Agent = class {
         (agent) => "artifactComponents" in agent && agent.artifactComponents && agent.artifactComponents.length > 0
       );
     } catch (error) {
-      logger18.warn(
+      logger19.warn(
         {
           graphId: this.config.graphId,
           tenantId: this.config.tenantId,
@@ -7679,7 +8080,7 @@ var Agent = class {
           preserveUnresolved: false
         });
       } catch (error) {
-        logger18.error(
+        logger19.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -7726,7 +8127,7 @@ var Agent = class {
           preserveUnresolved: false
         });
       } catch (error) {
-        logger18.error(
+        logger19.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -7738,9 +8139,24 @@ var Agent = class {
     }
     const streamRequestId = runtimeContext?.metadata?.streamRequestId;
     const mcpTools = await this.getMcpTools(void 0, streamRequestId);
-    const functionTools = this.getFunctionTools(streamRequestId);
+    const functionTools = await this.getFunctionTools(streamRequestId || "");
     const relationTools = this.getRelationTools(runtimeContext);
     const allTools = { ...mcpTools, ...functionTools, ...relationTools };
+    logger19.info(
+      {
+        mcpTools: Object.keys(mcpTools),
+        functionTools: Object.keys(functionTools),
+        relationTools: Object.keys(relationTools),
+        allTools: Object.keys(allTools),
+        functionToolsDetails: Object.entries(functionTools).map(([name, tool3]) => ({
+          name,
+          hasExecute: typeof tool3.execute === "function",
+          hasDescription: !!tool3.description,
+          hasInputSchema: !!tool3.inputSchema
+        }))
+      },
+      "Tools loaded for agent"
+    );
     const toolDefinitions = Object.entries(allTools).map(([name, tool3]) => ({
       name,
       description: tool3.description || "",
@@ -7765,7 +8181,7 @@ var Agent = class {
           preserveUnresolved: false
         });
       } catch (error) {
-        logger18.error(
+        logger19.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -7798,7 +8214,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 = graphSessionManager.getArtifactService(streamRequestId);
         if (!artifactService) {
@@ -7832,7 +8248,7 @@ var Agent = class {
     });
   }
   // Provide a default tool set that is always available to the agent.
-  async getDefaultTools(sessionId, streamRequestId) {
+  async getDefaultTools(_sessionId, streamRequestId) {
     const defaultTools = {};
     if (await this.graphHasArtifactComponents()) {
       defaultTools.get_reference_artifact = this.getArtifactTools();
@@ -7920,13 +8336,19 @@ var Agent = class {
       if (Array.isArray(obj)) {
         obj.slice(0, 3).forEach((item) => {
           if (item && typeof item === "object") {
-            Object.keys(item).forEach((key) => fields.add(key));
+            Object.keys(item).forEach((key) => {
+              fields.add(key);
+            });
           }
         });
       } else if (obj && typeof obj === "object") {
-        Object.keys(obj).forEach((key) => fields.add(key));
+        Object.keys(obj).forEach((key) => {
+          fields.add(key);
+        });
         Object.values(obj).forEach((value) => {
-          findCommonFields(value, depth + 1).forEach((field) => fields.add(field));
+          findCommonFields(value, depth + 1).forEach((field) => {
+            fields.add(field);
+          });
         });
       }
       return fields;
@@ -8052,7 +8474,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;
     }
   }
@@ -8067,7 +8489,7 @@ var Agent = class {
         }
       });
     } catch (error) {
-      logger18.error(
+      logger19.error(
         { error, graphId: this.config.graphId },
         "Failed to check graph artifact components"
       );
@@ -8110,7 +8532,7 @@ var Agent = class {
                 // Normal prompt with data components
                 this.buildSystemPrompt(runtimeContext, true),
                 // Thinking prompt without data components
-                Promise.resolve(this.getFunctionTools(streamRequestId)),
+                this.getFunctionTools(sessionId, streamRequestId),
                 Promise.resolve(this.getRelationTools(runtimeContext, sessionId)),
                 this.getDefaultTools(sessionId, streamRequestId)
               ]);
@@ -8168,7 +8590,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,
@@ -8210,7 +8632,7 @@ var Agent = class {
                     }
                   );
                 } catch (error) {
-                  logger18.debug({ error }, "Failed to track agent reasoning");
+                  logger19.debug({ error }, "Failed to track agent reasoning");
                 }
               }
               if (last && "toolCalls" in last && last.toolCalls) {
@@ -8314,7 +8736,7 @@ var Agent = class {
                     }
                   );
                 } catch (error) {
-                  logger18.debug({ error }, "Failed to track agent reasoning");
+                  logger19.debug({ error }, "Failed to track agent reasoning");
                 }
               }
               if (last && "toolCalls" in last && last.toolCalls) {
@@ -8606,7 +9028,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 {
@@ -8659,7 +9081,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 {
@@ -8688,7 +9110,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
               return { ...relation, description: enhancedDescription };
             }
           } catch (error) {
-            logger19.warn({ agentId: relation.id, error }, "Failed to enhance agent description");
+            logger20.warn({ agentId: relation.id, error }, "Failed to enhance agent description");
           }
           return relation;
         })
@@ -8792,7 +9214,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,
@@ -8808,7 +9230,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
       const isDelegation = task.context?.metadata?.isDelegation === true;
       agent.setDelegationStatus(isDelegation);
       if (isDelegation) {
-        logger19.info(
+        logger20.info(
           { agentId: config.agentId, taskId: task.id },
           "Delegated agent - streaming disabled"
         );
@@ -9033,7 +9455,7 @@ async function getRegisteredGraph(executionContext) {
 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",
@@ -9071,7 +9493,7 @@ app.openapi(
       tracestate: c.req.header("tracestate"),
       baggage: c.req.header("baggage")
     };
-    logger20.info(
+    logger21.info(
       {
         otelHeaders,
         path: c.req.path,
@@ -9083,7 +9505,7 @@ app.openapi(
     const { tenantId, projectId, graphId, agentId } = executionContext;
     console.dir("executionContext", executionContext);
     if (agentId) {
-      logger20.info(
+      logger21.info(
         {
           message: "getRegisteredAgent (agent-level)",
           tenantId,
@@ -9095,7 +9517,7 @@ app.openapi(
       );
       const credentialStores = c.get("credentialStores");
       const agent = await getRegisteredAgent(executionContext, credentialStores);
-      logger20.info({ agent }, "agent registered: well-known agent.json");
+      logger21.info({ agent }, "agent registered: well-known agent.json");
       if (!agent) {
         throw agentsCore.createApiError({
           code: "not_found",
@@ -9104,7 +9526,7 @@ app.openapi(
       }
       return c.json(agent.agentCard);
     } else {
-      logger20.info(
+      logger21.info(
         {
           message: "getRegisteredGraph (graph-level)",
           tenantId,
@@ -9130,7 +9552,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,
@@ -9141,7 +9563,7 @@ app.post("/a2a", async (c) => {
   const executionContext = agentsCore.getRequestExecutionContext(c);
   const { tenantId, projectId, graphId, agentId } = executionContext;
   if (agentId) {
-    logger20.info(
+    logger21.info(
       {
         message: "a2a (agent-level)",
         tenantId,
@@ -9165,7 +9587,7 @@ app.post("/a2a", async (c) => {
     }
     return a2aHandler(c, agent);
   } else {
-    logger20.info(
+    logger21.info(
       {
         message: "a2a (graph-level)",
         tenantId,
@@ -9221,14 +9643,14 @@ init_dbClient();
 // src/a2a/transfer.ts
 init_dbClient();
 init_logger();
-var logger21 = agentsCore.getLogger("Transfer");
+var logger22 = agentsCore.getLogger("Transfer");
 async function executeTransfer({
   tenantId,
   threadId,
   projectId,
   targetAgentId
 }) {
-  logger21.info({ targetAgent: targetAgentId }, "Executing transfer to agent");
+  logger22.info({ targetAgent: targetAgentId }, "Executing transfer to agent");
   await agentsCore.setActiveAgentForThread(dbClient_default)({
     scopes: { tenantId, projectId },
     threadId,
@@ -9814,7 +10236,7 @@ function createMCPStreamHelper() {
 }
 
 // src/handlers/executionHandler.ts
-var logger22 = agentsCore.getLogger("ExecutionHandler");
+var logger23 = agentsCore.getLogger("ExecutionHandler");
 var ExecutionHandler = class {
   constructor() {
     // Hardcoded error limit - separate from configurable stopWhen
@@ -9850,7 +10272,7 @@ var ExecutionHandler = class {
     if (emitOperations) {
       graphSessionManager.enableEmitOperations(requestId2);
     }
-    logger22.info(
+    logger23.info(
       { sessionId: requestId2, graphId, conversationId, emitOperations },
       "Created GraphSession for message execution"
     );
@@ -9865,7 +10287,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
@@ -9881,7 +10303,7 @@ var ExecutionHandler = class {
     try {
       await sseHelper.writeOperation(agentInitializingOp(requestId2, graphId));
       const taskId = `task_${conversationId}-${requestId2}`;
-      logger22.info(
+      logger23.info(
         { taskId, currentAgentId, conversationId, requestId: requestId2 },
         "Attempting to create or reuse existing task"
       );
@@ -9905,7 +10327,7 @@ var ExecutionHandler = class {
             agent_id: currentAgentId
           }
         });
-        logger22.info(
+        logger23.info(
           {
             taskId,
             createdTaskMetadata: Array.isArray(task) ? task[0]?.metadata : task?.metadata
@@ -9914,27 +10336,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",
@@ -9952,7 +10374,7 @@ var ExecutionHandler = class {
       const maxTransfers = graphConfig?.stopWhen?.transferCountIs ?? 10;
       while (iterations < maxTransfers) {
         iterations++;
-        logger22.info(
+        logger23.info(
           { iterations, currentAgentId, graphId, conversationId, fromAgentId },
           `Execution loop iteration ${iterations} with agent ${currentAgentId}, transfer from: ${fromAgentId || "none"}`
         );
@@ -9960,10 +10382,10 @@ var ExecutionHandler = class {
           scopes: { tenantId, projectId },
           conversationId
         });
-        logger22.info({ activeAgent }, "activeAgent");
+        logger23.info({ activeAgent }, "activeAgent");
         if (activeAgent && activeAgent.activeAgentId !== currentAgentId) {
           currentAgentId = activeAgent.activeAgentId;
-          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, {
@@ -10004,13 +10426,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)({
@@ -10035,7 +10457,7 @@ var ExecutionHandler = class {
           const transferResponse = messageResponse.result;
           const targetAgentId = transferResponse.artifacts?.[0]?.parts?.[0]?.data?.targetAgentId;
           const transferReason = transferResponse.artifacts?.[0]?.parts?.[1]?.text;
-          logger22.info({ targetAgentId, transferReason }, "transfer response");
+          logger23.info({ targetAgentId, transferReason }, "transfer response");
           currentMessage = `<transfer_context> ${transferReason} </transfer_context>`;
           const { success, targetAgentId: newAgentId } = await executeTransfer({
             projectId,
@@ -10046,7 +10468,7 @@ var ExecutionHandler = class {
           if (success) {
             fromAgentId = currentAgentId;
             currentAgentId = newAgentId;
-            logger22.info(
+            logger23.info(
               {
                 transferFrom: fromAgentId,
                 transferTo: currentAgentId,
@@ -10064,7 +10486,7 @@ var ExecutionHandler = class {
           const graphSessionData = graphSessionManager.getSession(requestId2);
           if (graphSessionData) {
             const sessionSummary = graphSessionData.getSummary();
-            logger22.info(sessionSummary, "GraphSession data after completion");
+            logger23.info(sessionSummary, "GraphSession data after completion");
           }
           let textContent = "";
           for (const part of responseParts) {
@@ -10118,22 +10540,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 GraphSession and cleaning up");
+              logger23.info({}, "Ending GraphSession and cleaning up");
               graphSessionManager.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)));
@@ -10144,13 +10566,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)({
@@ -10171,7 +10593,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)({
@@ -10190,7 +10612,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")
@@ -10218,7 +10640,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",
@@ -10336,7 +10758,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,
@@ -10429,7 +10851,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
       dbClient: dbClient_default,
       credentialStores
     });
-    logger23.info(
+    logger24.info(
       {
         tenantId,
         projectId,
@@ -10477,7 +10899,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
       try {
         const sseHelper = createSSEStreamHelper(stream2, requestId2, timestamp);
         await sseHelper.writeRole();
-        logger23.info({ agentId }, "Starting execution");
+        logger24.info({ agentId }, "Starting execution");
         const emitOperationsHeader = c.req.header("x-emit-operations");
         const emitOperations = emitOperationsHeader === "true";
         const executionHandler = new ExecutionHandler();
@@ -10490,7 +10912,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
           sseHelper,
           emitOperations
         });
-        logger23.info(
+        logger24.info(
           { result },
           `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
         );
@@ -10504,7 +10926,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
@@ -10521,12 +10943,12 @@ 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
@@ -10554,7 +10976,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",
@@ -10671,7 +11093,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({
@@ -10716,7 +11138,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") {
@@ -10737,7 +11159,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"
@@ -10752,7 +11174,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");
@@ -10807,21 +11229,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, graphId) => {
   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",
@@ -10847,7 +11269,7 @@ var validateSession = async (req, res, body, tenantId, projectId, graphId) => {
     scopes: { tenantId, projectId },
     conversationId: sessionId
   });
-  logger25.info(
+  logger26.info(
     {
       sessionId,
       conversationFound: !!conversation,
@@ -10858,7 +11280,7 @@ var validateSession = async (req, res, body, tenantId, projectId, graphId) => {
     "Conversation lookup result"
   );
   if (!conversation || conversation.metadata?.sessionData?.sessionType !== "mcp" || conversation.metadata?.sessionData?.graphId !== graphId) {
-    logger25.info(
+    logger26.info(
       { sessionId, conversationId: conversation?.id },
       "MCP session not found or invalid"
     );
@@ -10919,7 +11341,7 @@ var executeAgentQuery = async (executionContext, conversationId, query, defaultA
     requestId: requestId2,
     sseHelper: mcpStreamHelper
   });
-  logger25.info(
+  logger26.info(
     { result },
     `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
   );
@@ -11003,7 +11425,7 @@ var getServer = async (requestContext, executionContext, conversationId, credent
           dbClient: dbClient_default,
           credentialStores
         });
-        logger25.info(
+        logger26.info(
           {
             tenantId,
             projectId,
@@ -11065,7 +11487,7 @@ var validateRequestParameters = (c) => {
 };
 var handleInitializationRequest = async (body, executionContext, validatedContext, req, res, c, credentialStores) => {
   const { tenantId, projectId, graphId } = executionContext;
-  logger25.info({ body }, "Received initialization request");
+  logger26.info({ body }, "Received initialization request");
   const sessionId = agentsCore.getConversationId();
   const agentGraph = await agentsCore.getAgentGraphWithDefaultAgent(dbClient_default)({
     scopes: { tenantId, projectId, graphId }
@@ -11105,7 +11527,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
       }
     }
   });
-  logger25.info(
+  logger26.info(
     { sessionId, conversationId: conversation.id },
     "Created MCP session as conversation"
   );
@@ -11114,9 +11536,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,
@@ -11125,7 +11547,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);
 };
 var handleExistingSessionRequest = async (body, executionContext, validatedContext, req, res, credentialStores) => {
@@ -11153,8 +11575,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 || {}),
@@ -11168,9 +11590,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,
@@ -11221,13 +11643,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,
@@ -11249,7 +11671,7 @@ app4.openapi(
         );
       }
     } catch (e) {
-      logger25.error(
+      logger26.error(
         {
           error: e instanceof Error ? e.message : e,
           stack: e instanceof Error ? e.stack : void 0
@@ -11261,7 +11683,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",
@@ -11275,7 +11697,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",
@@ -11288,7 +11710,7 @@ app4.delete("/", async (c) => {
 var mcp_default = app4;
 
 // src/app.ts
-var logger26 = agentsCore.getLogger("agents-run-api");
+var logger27 = agentsCore.getLogger("agents-run-api");
 function createExecutionHono(serverConfig, credentialStores) {
   const app6 = new zodOpenapi.OpenAPIHono();
   app6.use("*", otel.otel());
@@ -11304,7 +11726,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();
@@ -11355,8 +11777,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,
@@ -11368,8 +11790,8 @@ function createExecutionHono(serverConfig, credentialStores) {
           );
         }
       } else {
-        if (logger26) {
-          logger26.error(
+        if (logger27) {
+          logger27.error(
             {
               error: err,
               path: c.req.path,
@@ -11386,8 +11808,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");
         }
       }
     }
@@ -11421,7 +11843,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, graphId } = executionContext;
@@ -11430,7 +11852,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(
@@ -11445,7 +11867,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(