@inkeep/agents-run-api 0.17.0 → 0.18.1

package/dist/index.cjs

@@ -198,8 +198,8 @@ async function saveA2AMessageResponse(response, params) {
     },
     visibility: params.visibility,
     messageType: params.messageType,
-    fromAgentId: params.fromAgentId,
-    toAgentId: params.toAgentId,
+    fromSubAgentId: params.fromSubAgentId,
+    toSubAgentId: params.toSubAgentId,
     fromExternalAgentId: params.fromExternalAgentId,
     toExternalAgentId: params.toExternalAgentId,
     a2aTaskId: params.a2aTaskId,
@@ -220,23 +220,23 @@ async function getScopedHistory({
       conversationId,
       options
     });
-    if (!filters || !filters.agentId && !filters.taskId) {
+    if (!filters || !filters.subAgentId && !filters.taskId) {
       return messages;
     }
     const relevantMessages = messages.filter((msg) => {
       if (msg.role === "user") return true;
       let matchesAgent = true;
       let matchesTask = true;
-      if (filters.agentId) {
-        matchesAgent = msg.role === "agent" && msg.visibility === "user-facing" || msg.toAgentId === filters.agentId || msg.fromAgentId === filters.agentId;
+      if (filters.subAgentId) {
+        matchesAgent = msg.role === "agent" && msg.visibility === "user-facing" || msg.toAgentId === filters.subAgentId || msg.fromAgentId === filters.subAgentId;
       }
       if (filters.taskId) {
         matchesTask = msg.taskId === filters.taskId || msg.a2aTaskId === filters.taskId;
       }
-      if (filters.agentId && filters.taskId) {
+      if (filters.subAgentId && filters.taskId) {
         return matchesAgent && matchesTask;
       }
-      if (filters.agentId) {
+      if (filters.subAgentId) {
         return matchesAgent;
       }
       if (filters.taskId) {
@@ -337,7 +337,9 @@ async function getConversationScopedArtifacts(params) {
     if (visibleMessages.length === 0) {
       return [];
     }
-    const visibleMessageIds = visibleMessages.filter((msg) => !(msg.messageType === "system" && msg.content?.text?.includes("Previous conversation history truncated"))).map((msg) => msg.id);
+    const visibleMessageIds = visibleMessages.filter(
+      (msg) => !(msg.messageType === "system" && msg.content?.text?.includes("Previous conversation history truncated"))
+    ).map((msg) => msg.id);
     if (visibleMessageIds.length === 0) {
       return [];
     }
@@ -352,8 +354,8 @@ async function getConversationScopedArtifacts(params) {
       });
       referenceArtifacts.push(...artifacts);
     }
-    const logger28 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
-    logger28.debug(
+    const logger27 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
+    logger27.debug(
       {
         conversationId,
         visibleMessages: visibleMessages.length,
@@ -365,8 +367,8 @@ async function getConversationScopedArtifacts(params) {
     );
     return referenceArtifacts;
   } catch (error) {
-    const logger28 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
-    logger28.error(
+    const logger27 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
+    logger27.error(
       {
         error: error instanceof Error ? error.message : "Unknown error",
         conversationId
@@ -387,10 +389,62 @@ var LocalSandboxExecutor_exports = {};
 __export(LocalSandboxExecutor_exports, {
   LocalSandboxExecutor: () => LocalSandboxExecutor
 });
-var logger18, _LocalSandboxExecutor, LocalSandboxExecutor;
+var logger17, ExecutionSemaphore, _LocalSandboxExecutor, LocalSandboxExecutor;
 var init_LocalSandboxExecutor = __esm({
   "src/tools/LocalSandboxExecutor.ts"() {
-    logger18 = agentsCore.getLogger("local-sandbox-executor");
+    logger17 = agentsCore.getLogger("local-sandbox-executor");
+    ExecutionSemaphore = class {
+      constructor(permits, maxWaitTimeMs = 3e4) {
+        __publicField(this, "permits");
+        __publicField(this, "waitQueue", []);
+        __publicField(this, "maxWaitTime");
+        this.permits = Math.max(1, permits);
+        this.maxWaitTime = maxWaitTimeMs;
+      }
+      async acquire(fn) {
+        await new Promise((resolve, reject) => {
+          if (this.permits > 0) {
+            this.permits--;
+            resolve();
+            return;
+          }
+          const timeoutId = setTimeout(() => {
+            const index = this.waitQueue.findIndex((item) => item.resolve === resolve);
+            if (index !== -1) {
+              this.waitQueue.splice(index, 1);
+              reject(
+                new Error(
+                  `Function execution queue timeout after ${this.maxWaitTime}ms. Too many concurrent executions.`
+                )
+              );
+            }
+          }, this.maxWaitTime);
+          this.waitQueue.push({
+            resolve: () => {
+              clearTimeout(timeoutId);
+              this.permits--;
+              resolve();
+            },
+            reject
+          });
+        });
+        try {
+          return await fn();
+        } finally {
+          this.permits++;
+          const next = this.waitQueue.shift();
+          if (next) {
+            next.resolve();
+          }
+        }
+      }
+      getAvailablePermits() {
+        return this.permits;
+      }
+      getQueueLength() {
+        return this.waitQueue.length;
+      }
+    };
     _LocalSandboxExecutor = class _LocalSandboxExecutor {
       constructor() {
         __publicField(this, "tempDir");
@@ -398,6 +452,7 @@ var init_LocalSandboxExecutor = __esm({
         __publicField(this, "POOL_TTL", 5 * 60 * 1e3);
         // 5 minutes
         __publicField(this, "MAX_USE_COUNT", 50);
+        __publicField(this, "executionSemaphores", /* @__PURE__ */ new Map());
         this.tempDir = path.join(os.tmpdir(), "inkeep-sandboxes");
         this.ensureTempDir();
         this.startPoolCleanup();
@@ -408,6 +463,34 @@ var init_LocalSandboxExecutor = __esm({
         }
         return _LocalSandboxExecutor.instance;
       }
+      /**
+       * Get or create a semaphore for the specified vCPU limit
+       */
+      getSemaphore(vcpus) {
+        const effectiveVcpus = Math.max(1, vcpus || 1);
+        if (!this.executionSemaphores.has(effectiveVcpus)) {
+          logger17.debug({ vcpus: effectiveVcpus }, "Creating new execution semaphore");
+          this.executionSemaphores.set(effectiveVcpus, new ExecutionSemaphore(effectiveVcpus));
+        }
+        const semaphore = this.executionSemaphores.get(effectiveVcpus);
+        if (!semaphore) {
+          throw new Error(`Failed to create semaphore for ${effectiveVcpus} vCPUs`);
+        }
+        return semaphore;
+      }
+      /**
+       * Get execution statistics for monitoring and debugging
+       */
+      getExecutionStats() {
+        const stats = {};
+        for (const [vcpus, semaphore] of this.executionSemaphores.entries()) {
+          stats[`vcpu_${vcpus}`] = {
+            availablePermits: semaphore.getAvailablePermits(),
+            queueLength: semaphore.getQueueLength()
+          };
+        }
+        return stats;
+      }
       ensureTempDir() {
         try {
           fs.mkdirSync(this.tempDir, { recursive: true });
@@ -426,7 +509,7 @@ var init_LocalSandboxExecutor = __esm({
           if (now - sandbox.lastUsed < this.POOL_TTL && sandbox.useCount < this.MAX_USE_COUNT) {
             sandbox.lastUsed = now;
             sandbox.useCount++;
-            logger18.debug(
+            logger17.debug(
               {
                 poolKey,
                 useCount: sandbox.useCount,
@@ -454,14 +537,14 @@ var init_LocalSandboxExecutor = __esm({
           useCount: 1,
           dependencies
         };
-        logger18.debug({ poolKey, sandboxDir }, "Added sandbox to pool");
+        logger17.debug({ poolKey, sandboxDir }, "Added sandbox to pool");
       }
       cleanupSandbox(sandboxDir) {
         try {
           fs.rmSync(sandboxDir, { recursive: true, force: true });
-          logger18.debug({ sandboxDir }, "Cleaned up sandbox");
+          logger17.debug({ sandboxDir }, "Cleaned up sandbox");
         } catch (error) {
-          logger18.warn({ sandboxDir, error }, "Failed to clean up sandbox");
+          logger17.warn({ sandboxDir, error }, "Failed to clean up sandbox");
         }
       }
       startPoolCleanup() {
@@ -478,11 +561,11 @@ var init_LocalSandboxExecutor = __esm({
             delete this.sandboxPool[key];
           });
           if (keysToDelete.length > 0) {
-            logger18.debug({ cleanedCount: keysToDelete.length }, "Cleaned up expired sandboxes");
+            logger17.debug({ cleanedCount: keysToDelete.length }, "Cleaned up expired sandboxes");
           }
         }, 6e4);
       }
-      detectModuleType(executeCode) {
+      detectModuleType(executeCode, configuredRuntime) {
         const esmPatterns = [
           /import\s+.*\s+from\s+['"]/g,
           // import ... from '...'
@@ -503,8 +586,11 @@ var init_LocalSandboxExecutor = __esm({
         ];
         const hasEsmSyntax = esmPatterns.some((pattern) => pattern.test(executeCode));
         const hasCjsSyntax = cjsPatterns.some((pattern) => pattern.test(executeCode));
+        if (configuredRuntime === "typescript") {
+          return hasCjsSyntax ? "cjs" : "esm";
+        }
         if (hasEsmSyntax && hasCjsSyntax) {
-          logger18.warn(
+          logger17.warn(
             { executeCode: `${executeCode.substring(0, 100)}...` },
             "Both ESM and CommonJS syntax detected, defaulting to ESM"
           );
@@ -519,13 +605,32 @@ var init_LocalSandboxExecutor = __esm({
         return "cjs";
       }
       async executeFunctionTool(toolId, args, config) {
+        const vcpus = config.sandboxConfig?.vcpus || 1;
+        const semaphore = this.getSemaphore(vcpus);
+        logger17.debug(
+          {
+            toolId,
+            vcpus,
+            availablePermits: semaphore.getAvailablePermits(),
+            queueLength: semaphore.getQueueLength(),
+            sandboxConfig: config.sandboxConfig,
+            poolSize: Object.keys(this.sandboxPool).length
+          },
+          "Acquiring execution slot for function tool"
+        );
+        return semaphore.acquire(async () => {
+          return this.executeInSandbox_Internal(toolId, args, config);
+        });
+      }
+      async executeInSandbox_Internal(toolId, args, config) {
         const dependencies = config.dependencies || {};
         const dependencyHash = this.generateDependencyHash(dependencies);
-        logger18.debug(
+        logger17.debug(
           {
             toolId,
             dependencies,
             dependencyHash,
+            sandboxConfig: config.sandboxConfig,
             poolSize: Object.keys(this.sandboxPool).length
           },
           "Executing function tool"
@@ -536,7 +641,7 @@ var init_LocalSandboxExecutor = __esm({
           sandboxDir = path.join(this.tempDir, `sandbox-${dependencyHash}-${Date.now()}`);
           fs.mkdirSync(sandboxDir, { recursive: true });
           isNewSandbox = true;
-          logger18.debug(
+          logger17.debug(
             {
               toolId,
               dependencyHash,
@@ -545,7 +650,7 @@ var init_LocalSandboxExecutor = __esm({
             },
             "Creating new sandbox"
           );
-          const moduleType = this.detectModuleType(config.executeCode);
+          const moduleType = this.detectModuleType(config.executeCode, config.sandboxConfig?.runtime);
           const packageJson = {
             name: `function-tool-${toolId}`,
             version: "1.0.0",
@@ -562,14 +667,15 @@ var init_LocalSandboxExecutor = __esm({
           this.addToPool(dependencyHash, sandboxDir, dependencies);
         }
         try {
-          const moduleType = this.detectModuleType(config.executeCode);
+          const moduleType = this.detectModuleType(config.executeCode, config.sandboxConfig?.runtime);
           const executionCode = this.wrapFunctionCode(config.executeCode, args);
           const fileExtension = moduleType === "esm" ? "mjs" : "js";
           fs.writeFileSync(path.join(sandboxDir, `index.${fileExtension}`), executionCode, "utf8");
           const result = await this.executeInSandbox(
             sandboxDir,
             config.sandboxConfig?.timeout || 3e4,
-            moduleType
+            moduleType,
+            config.sandboxConfig
           );
           return result;
         } catch (error) {
@@ -595,20 +701,20 @@ var init_LocalSandboxExecutor = __esm({
           });
           npm.on("close", (code) => {
             if (code === 0) {
-              logger18.debug({ sandboxDir }, "Dependencies installed successfully");
+              logger17.debug({ sandboxDir }, "Dependencies installed successfully");
               resolve();
             } else {
-              logger18.error({ sandboxDir, code, stderr }, "Failed to install dependencies");
+              logger17.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");
+            logger17.error({ sandboxDir, error: err }, "Failed to spawn npm install");
             reject(err);
           });
         });
       }
-      async executeInSandbox(sandboxDir, timeout, moduleType) {
+      async executeInSandbox(sandboxDir, timeout, moduleType, _sandboxConfig) {
         return new Promise((resolve, reject) => {
           const fileExtension = moduleType === "esm" ? "mjs" : "js";
           const spawnOptions = {
@@ -644,14 +750,15 @@ var init_LocalSandboxExecutor = __esm({
             stderr += dataStr;
           });
           const timeoutId = setTimeout(() => {
-            logger18.warn({ sandboxDir, timeout }, "Function execution timed out, killing process");
+            logger17.warn({ sandboxDir, timeout }, "Function execution timed out, killing process");
             node.kill("SIGTERM");
+            const forceKillTimeout = Math.min(Math.max(timeout / 10, 2e3), 5e3);
             setTimeout(() => {
               try {
                 node.kill("SIGKILL");
               } catch {
               }
-            }, 5e3);
+            }, forceKillTimeout);
             reject(new Error(`Function execution timed out after ${timeout}ms`));
           }, timeout);
           node.on("close", (code, signal) => {
@@ -665,18 +772,18 @@ var init_LocalSandboxExecutor = __esm({
                   reject(new Error(result.error || "Function execution failed"));
                 }
               } catch (parseError) {
-                logger18.error({ stdout, stderr, parseError }, "Failed to parse function result");
+                logger17.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");
+              logger17.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");
+            logger17.error({ sandboxDir, error }, "Failed to spawn node process");
             reject(error);
           });
         });
@@ -687,13 +794,26 @@ var init_LocalSandboxExecutor = __esm({
 const execute = ${executeCode};
 const args = ${JSON.stringify(args)};
 
-execute(args)
-  .then(result => {
+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 }));
-  })
-  .catch(error => {
-    console.log(JSON.stringify({ success: false, error: error.message }));
-  });
+  }
+} catch (error) {
+  console.log(JSON.stringify({ success: false, error: error.message }));
+}
 `;
       }
     };
@@ -807,7 +927,7 @@ function createExecutionContext(params) {
     graphId: params.graphId,
     baseUrl: params.baseUrl || process.env.API_URL || "http://localhost:3003",
     apiKeyId: params.apiKeyId,
-    agentId: params.agentId
+    subAgentId: params.subAgentId
   };
 }
 
@@ -822,7 +942,7 @@ var apiKeyAuth = () => factory.createMiddleware(async (c, next) => {
   const tenantId = c.req.header("x-inkeep-tenant-id");
   const projectId = c.req.header("x-inkeep-project-id");
   const graphId = c.req.header("x-inkeep-graph-id");
-  const agentId = c.req.header("x-inkeep-agent-id");
+  const subAgentId = c.req.header("x-inkeep-agent-id");
   const proto = c.req.header("x-forwarded-proto")?.split(",")[0].trim();
   const fwdHost = c.req.header("x-forwarded-host")?.split(",")[0].trim();
   const host = fwdHost ?? c.req.header("host");
@@ -833,7 +953,7 @@ var apiKeyAuth = () => factory.createMiddleware(async (c, next) => {
     if (authHeader?.startsWith("Bearer ")) {
       try {
         executionContext = await extractContextFromApiKey(authHeader.substring(7), baseUrl);
-        executionContext.agentId = agentId;
+        executionContext.subAgentId = subAgentId;
         logger2.info({}, "Development/test environment - API key authenticated successfully");
       } catch {
         executionContext = createExecutionContext({
@@ -843,7 +963,7 @@ var apiKeyAuth = () => factory.createMiddleware(async (c, next) => {
           graphId: graphId || "test-graph",
           apiKeyId: "test-key",
           baseUrl,
-          agentId
+          subAgentId
         });
         logger2.info(
           {},
@@ -858,7 +978,7 @@ var apiKeyAuth = () => factory.createMiddleware(async (c, next) => {
         graphId: graphId || "test-graph",
         apiKeyId: "test-key",
         baseUrl,
-        agentId
+        subAgentId
       });
       logger2.info(
         {},
@@ -889,7 +1009,7 @@ var apiKeyAuth = () => factory.createMiddleware(async (c, next) => {
         graphId,
         apiKeyId: "bypass",
         baseUrl,
-        agentId
+        subAgentId
       });
       c.set("executionContext", executionContext);
       logger2.info({}, "Bypass secret authenticated successfully");
@@ -897,7 +1017,7 @@ var apiKeyAuth = () => factory.createMiddleware(async (c, next) => {
       return;
     } else if (apiKey) {
       const executionContext = await extractContextFromApiKey(apiKey, baseUrl);
-      executionContext.agentId = agentId;
+      executionContext.subAgentId = subAgentId;
       c.set("executionContext", executionContext);
       logger2.info({}, "API key authenticated successfully");
       await next();
@@ -915,14 +1035,14 @@ var apiKeyAuth = () => factory.createMiddleware(async (c, next) => {
   }
   try {
     const executionContext = await extractContextFromApiKey(apiKey, baseUrl);
-    executionContext.agentId = agentId;
+    executionContext.subAgentId = subAgentId;
     c.set("executionContext", executionContext);
     logger2.debug(
       {
         tenantId: executionContext.tenantId,
         projectId: executionContext.projectId,
         graphId: executionContext.graphId,
-        agentId: executionContext.agentId
+        subAgentId: executionContext.subAgentId
       },
       "API key authenticated successfully"
     );
@@ -1097,7 +1217,7 @@ async function handleMessageSend(c, agent, request) {
         logger3.warn(
           {
             taskId: task.id,
-            agentId: agent.agentId,
+            subAgentId: agent.subAgentId,
             originalMessage: params.message
           },
           "Created fallback message content for empty delegation message"
@@ -1118,7 +1238,7 @@ async function handleMessageSend(c, agent, request) {
         taskContextId: task.context?.conversationId,
         metadataContextId: params.message.metadata?.conversationId,
         finalContextId: effectiveContextId,
-        agentId: agent.agentId
+        subAgentId: agent.subAgentId
       },
       "A2A contextId resolution for delegation"
     );
@@ -1134,11 +1254,11 @@ async function handleMessageSend(c, agent, request) {
         message_id: params.message.messageId || "",
         created_at: (/* @__PURE__ */ new Date()).toISOString(),
         updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-        agent_id: agent.agentId,
+        agent_id: agent.subAgentId,
         graph_id: graphId || "",
         stream_request_id: params.message.metadata?.stream_request_id
       },
-      agentId: agent.agentId,
+      subAgentId: agent.subAgentId,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
@@ -1161,17 +1281,17 @@ async function handleMessageSend(c, agent, request) {
         };
         if (params.message.metadata?.fromAgentId) {
           messageData.fromAgentId = params.message.metadata.fromAgentId;
-          messageData.toAgentId = agent.agentId;
+          messageData.toAgentId = agent.subAgentId;
         } else if (params.message.metadata?.fromExternalAgentId) {
           messageData.fromExternalAgentId = params.message.metadata.fromExternalAgentId;
-          messageData.toAgentId = agent.agentId;
+          messageData.toAgentId = agent.subAgentId;
         }
         await agentsCore.createMessage(dbClient_default)(messageData);
         logger3.info(
           {
             fromAgentId: params.message.metadata.fromAgentId,
             fromExternalAgentId: params.message.metadata.fromExternalAgentId,
-            toAgentId: agent.agentId,
+            toAgentId: agent.subAgentId,
             conversationId: effectiveContextId,
             messageType: "a2a-request",
             taskId: task.id
@@ -1184,7 +1304,7 @@ async function handleMessageSend(c, agent, request) {
             error,
             fromAgentId: params.message.metadata.fromAgentId,
             fromExternalAgentId: params.message.metadata.fromExternalAgentId,
-            toAgentId: agent.agentId,
+            toAgentId: agent.subAgentId,
             conversationId: effectiveContextId
           },
           "Failed to store A2A message in database"
@@ -1201,7 +1321,7 @@ async function handleMessageSend(c, agent, request) {
           message_id: params.message.messageId || "",
           created_at: (/* @__PURE__ */ new Date()).toISOString(),
           updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-          agent_id: agent.agentId,
+          agent_id: agent.subAgentId,
           graph_id: graphId || ""
         }
       }
@@ -1235,7 +1355,7 @@ async function handleMessageSend(c, agent, request) {
                     kind: "data",
                     data: {
                       type: "transfer",
-                      targetAgentId: transferPart.data.target
+                      targetSubAgentId: transferPart.data.target
                     }
                   },
                   {
@@ -1535,7 +1655,7 @@ async function handleGetCapabilities(c, agent, request) {
 async function handleGetStatus(c, agent, request) {
   return c.json({
     jsonrpc: "2.0",
-    result: { status: "ready", agentId: agent.agentId },
+    result: { status: "ready", subAgentId: agent.subAgentId },
     id: request.id
   });
 }
@@ -1599,7 +1719,6 @@ async function handleTasksResubscribe(c, agent, request) {
   }
 }
 init_dbClient();
-agentsCore.getLogger("agents");
 function createAgentCard({
   dbAgent,
   baseUrl
@@ -1677,7 +1796,7 @@ async function hydrateAgent({
       tenantId: dbAgent.tenantId,
       projectId: dbAgent.projectId,
       graphId,
-      agentId: dbAgent.id,
+      subAgentId: dbAgent.id,
       baseUrl,
       apiKey
     });
@@ -1687,7 +1806,7 @@ async function hydrateAgent({
       baseUrl
     });
     return {
-      agentId: dbAgent.id,
+      subAgentId: dbAgent.id,
       tenantId: dbAgent.tenantId,
       projectId: dbAgent.projectId,
       graphId,
@@ -1700,13 +1819,13 @@ async function hydrateAgent({
   }
 }
 async function getRegisteredAgent(executionContext, credentialStoreRegistry) {
-  const { tenantId, projectId, graphId, agentId, baseUrl, apiKey } = executionContext;
-  if (!agentId) {
+  const { tenantId, projectId, graphId, subAgentId, baseUrl, apiKey } = executionContext;
+  if (!subAgentId) {
     throw new Error("Agent ID is required");
   }
-  const dbAgent = await agentsCore.getAgentById(dbClient_default)({
+  const dbAgent = await agentsCore.getSubAgentById(dbClient_default)({
     scopes: { tenantId, projectId, graphId },
-    agentId
+    subAgentId
   });
   if (!dbAgent) {
     return null;
@@ -1727,7 +1846,7 @@ init_logger();
 
 // src/agents/ModelFactory.ts
 init_logger();
-var logger5 = agentsCore.getLogger("ModelFactory");
+var logger4 = agentsCore.getLogger("ModelFactory");
 var _ModelFactory = class _ModelFactory {
   /**
    * Create a provider instance with custom configuration
@@ -1789,7 +1908,7 @@ var _ModelFactory = class _ModelFactory {
     }
     const modelString = modelSettings.model.trim();
     const { provider, modelName } = _ModelFactory.parseModelString(modelString);
-    logger5.debug(
+    logger4.debug(
       {
         provider,
         model: modelName,
@@ -1800,7 +1919,7 @@ var _ModelFactory = class _ModelFactory {
     );
     const providerConfig = _ModelFactory.extractProviderConfig(modelSettings.providerOptions);
     if (Object.keys(providerConfig).length > 0) {
-      logger5.info({ config: providerConfig }, `Applying custom ${provider} provider configuration`);
+      logger4.info({ config: providerConfig }, `Applying custom ${provider} provider configuration`);
       const customProvider = _ModelFactory.createProvider(provider, providerConfig);
       return customProvider.languageModel(modelName);
     }
@@ -1919,7 +2038,7 @@ var ModelFactory = _ModelFactory;
 
 // src/agents/ToolSessionManager.ts
 init_logger();
-var logger6 = agentsCore.getLogger("ToolSessionManager");
+var logger5 = agentsCore.getLogger("ToolSessionManager");
 var _ToolSessionManager = class _ToolSessionManager {
   // 5 minutes
   constructor() {
@@ -1954,7 +2073,7 @@ var _ToolSessionManager = class _ToolSessionManager {
       createdAt: Date.now()
     };
     this.sessions.set(sessionId, session);
-    logger6.debug(
+    logger5.debug(
       {
         sessionId,
         tenantId,
@@ -1972,10 +2091,10 @@ var _ToolSessionManager = class _ToolSessionManager {
    */
   ensureGraphSession(sessionId, tenantId, projectId, contextId, taskId) {
     if (this.sessions.has(sessionId)) {
-      logger6.debug({ sessionId }, "Graph session already exists, reusing");
+      logger5.debug({ sessionId }, "Graph session already exists, reusing");
       return sessionId;
     }
-    logger6.debug(
+    logger5.debug(
       { sessionId, tenantId, contextId, taskId },
       "Creating new graph-scoped tool session"
     );
@@ -1987,7 +2106,7 @@ var _ToolSessionManager = class _ToolSessionManager {
   recordToolResult(sessionId, toolResult) {
     const session = this.sessions.get(sessionId);
     if (!session) {
-      logger6.warn(
+      logger5.warn(
         {
           sessionId,
           toolCallId: toolResult.toolCallId,
@@ -1999,7 +2118,7 @@ var _ToolSessionManager = class _ToolSessionManager {
       return;
     }
     session.toolResults.set(toolResult.toolCallId, toolResult);
-    logger6.debug(
+    logger5.debug(
       {
         sessionId,
         toolCallId: toolResult.toolCallId,
@@ -2014,7 +2133,7 @@ var _ToolSessionManager = class _ToolSessionManager {
   getToolResult(sessionId, toolCallId) {
     const session = this.sessions.get(sessionId);
     if (!session) {
-      logger6.warn(
+      logger5.warn(
         {
           sessionId,
           toolCallId,
@@ -2027,7 +2146,7 @@ var _ToolSessionManager = class _ToolSessionManager {
     }
     const result = session.toolResults.get(toolCallId);
     if (!result) {
-      logger6.warn(
+      logger5.warn(
         {
           sessionId,
           toolCallId,
@@ -2037,7 +2156,7 @@ var _ToolSessionManager = class _ToolSessionManager {
         "Tool result not found"
       );
     } else {
-      logger6.debug(
+      logger5.debug(
         {
           sessionId,
           toolCallId,
@@ -2076,10 +2195,10 @@ var _ToolSessionManager = class _ToolSessionManager {
     }
     for (const sessionId of expiredSessions) {
       this.sessions.delete(sessionId);
-      logger6.debug({ sessionId }, "Cleaned up expired tool session");
+      logger5.debug({ sessionId }, "Cleaned up expired tool session");
     }
     if (expiredSessions.length > 0) {
-      logger6.info({ expiredCount: expiredSessions.length }, "Cleaned up expired tool sessions");
+      logger5.info({ expiredCount: expiredSessions.length }, "Cleaned up expired tool sessions");
     }
   }
 };
@@ -2162,7 +2281,7 @@ function extractFullFields(schema) {
 }
 
 // src/services/ArtifactService.ts
-var logger8 = agentsCore.getLogger("ArtifactService");
+var logger7 = agentsCore.getLogger("ArtifactService");
 var _ArtifactService = class _ArtifactService {
   constructor(context) {
     this.context = context;
@@ -2194,7 +2313,7 @@ var _ArtifactService = class _ArtifactService {
           id: taskId
         });
         if (!task) {
-          logger8.warn({ taskId }, "Task not found when fetching artifacts");
+          logger7.warn({ taskId }, "Task not found when fetching artifacts");
           continue;
         }
         const taskArtifacts = await agentsCore.getLedgerArtifacts(dbClient_default)({
@@ -2212,21 +2331,21 @@ var _ArtifactService = class _ArtifactService {
         }
       }
     } catch (error) {
-      logger8.error({ error, contextId }, "Error loading context artifacts");
+      logger7.error({ error, contextId }, "Error loading context artifacts");
     }
     return artifacts;
   }
   /**
    * Create artifact from tool result and request data
    */
-  async createArtifact(request, agentId) {
+  async createArtifact(request, subAgentId) {
     if (!this.context.sessionId) {
-      logger8.warn({ request }, "No session ID available for artifact creation");
+      logger7.warn({ request }, "No session ID available for artifact creation");
       return null;
     }
     const toolResult = toolSessionManager.getToolResult(this.context.sessionId, request.toolCallId);
     if (!toolResult) {
-      logger8.warn(
+      logger7.warn(
         { request, sessionId: this.context.sessionId },
         "Tool result not found for artifact"
       );
@@ -2242,7 +2361,7 @@ var _ArtifactService = class _ArtifactService {
         selectedData = selectedData.length > 0 ? selectedData[0] : {};
       }
       if (!selectedData) {
-        logger8.warn(
+        logger7.warn(
           {
             request,
             baseSelector: request.baseSelector
@@ -2287,7 +2406,7 @@ var _ArtifactService = class _ArtifactService {
         type: request.type,
         data: cleanedSummaryData
       };
-      await this.persistArtifact(request, cleanedSummaryData, cleanedFullData, agentId);
+      await this.persistArtifact(request, cleanedSummaryData, cleanedFullData, subAgentId);
       await this.cacheArtifact(
         request.artifactId,
         request.toolCallId,
@@ -2296,7 +2415,7 @@ var _ArtifactService = class _ArtifactService {
       );
       return artifactData;
     } catch (error) {
-      logger8.error({ error, request }, "Failed to create artifact");
+      logger7.error({ error, request }, "Failed to create artifact");
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
       throw new Error(`Artifact creation failed for ${request.artifactId}: ${errorMessage}`);
     }
@@ -2325,7 +2444,7 @@ var _ArtifactService = class _ArtifactService {
     }
     try {
       if (!this.context.projectId || !this.context.taskId) {
-        logger8.warn(
+        logger7.warn(
           { artifactId, toolCallId },
           "No projectId or taskId available for artifact lookup"
         );
@@ -2340,7 +2459,7 @@ var _ArtifactService = class _ArtifactService {
         return this.formatArtifactSummaryData(artifacts[0], artifactId, toolCallId);
       }
     } catch (error) {
-      logger8.warn(
+      logger7.warn(
         { artifactId, toolCallId, taskId: this.context.taskId, error },
         "Failed to fetch artifact"
       );
@@ -2371,7 +2490,7 @@ var _ArtifactService = class _ArtifactService {
     }
     try {
       if (!this.context.projectId || !this.context.taskId) {
-        logger8.warn(
+        logger7.warn(
           { artifactId, toolCallId },
           "No projectId or taskId available for artifact lookup"
         );
@@ -2386,7 +2505,7 @@ var _ArtifactService = class _ArtifactService {
         return this.formatArtifactFullData(artifacts[0], artifactId, toolCallId);
       }
     } catch (error) {
-      logger8.warn(
+      logger7.warn(
         { artifactId, toolCallId, taskId: this.context.taskId, error },
         "Failed to fetch artifact"
       );
@@ -2422,8 +2541,8 @@ var _ArtifactService = class _ArtifactService {
   /**
    * Persist artifact to database via graph session
    */
-  async persistArtifact(request, summaryData, fullData, agentId) {
-    const effectiveAgentId = agentId || this.context.agentId;
+  async persistArtifact(request, summaryData, fullData, subAgentId) {
+    const effectiveAgentId = subAgentId || this.context.subAgentId;
     if (this.context.streamRequestId && effectiveAgentId && this.context.taskId) {
       await graphSessionManager.recordEvent(
         this.context.streamRequestId,
@@ -2436,7 +2555,7 @@ var _ArtifactService = class _ArtifactService {
           artifactType: request.type,
           summaryData,
           data: fullData,
-          agentId: effectiveAgentId,
+          subAgentId: effectiveAgentId,
           metadata: {
             toolCallId: request.toolCallId,
             baseSelector: request.baseSelector,
@@ -2451,14 +2570,14 @@ var _ArtifactService = class _ArtifactService {
         }
       );
     } else {
-      logger8.warn(
+      logger7.warn(
         {
           artifactId: request.artifactId,
           hasStreamRequestId: !!this.context.streamRequestId,
           hasAgentId: !!effectiveAgentId,
           hasTaskId: !!this.context.taskId,
-          passedAgentId: agentId,
-          contextAgentId: this.context.agentId
+          passedAgentId: subAgentId,
+          contextAgentId: this.context.subAgentId
         },
         "Skipping artifact_saved event - missing required context"
       );
@@ -2526,7 +2645,7 @@ var _ArtifactService = class _ArtifactService {
           summaryData = this.filterBySchema(artifact.data, previewSchema);
           fullData = this.filterBySchema(artifact.data, fullSchema);
         } catch (error) {
-          logger8.warn(
+          logger7.warn(
             {
               artifactType: artifact.type,
               error: error instanceof Error ? error.message : "Unknown error"
@@ -2564,7 +2683,7 @@ var _ArtifactService = class _ArtifactService {
       artifact: artifactToSave
     });
     if (!result.created && result.existing) {
-      logger8.debug(
+      logger7.debug(
         {
           artifactId: artifact.artifactId,
           taskId: this.context.taskId
@@ -2617,7 +2736,7 @@ var _ArtifactService = class _ArtifactService {
           extracted[propName] = this.cleanEscapedContent(rawValue);
         }
       } catch (error) {
-        logger8.warn(
+        logger7.warn(
           { propName, selector, error: error instanceof Error ? error.message : "Unknown error" },
           "Failed to extract property"
         );
@@ -2649,7 +2768,7 @@ var _ArtifactService = class _ArtifactService {
             extracted[fieldName] = this.cleanEscapedContent(rawValue);
           }
         } catch (error) {
-          logger8.warn(
+          logger7.warn(
             { fieldName, error: error instanceof Error ? error.message : "Unknown error" },
             "Failed to extract schema field"
           );
@@ -2680,7 +2799,7 @@ __publicField(_ArtifactService, "selectorCache", /* @__PURE__ */ new Map());
 var ArtifactService = _ArtifactService;
 
 // src/services/ArtifactParser.ts
-var logger9 = agentsCore.getLogger("ArtifactParser");
+var logger8 = agentsCore.getLogger("ArtifactParser");
 var _ArtifactParser = class _ArtifactParser {
   constructor(tenantId, options) {
     __publicField(this, "artifactService");
@@ -2768,7 +2887,7 @@ var _ArtifactParser = class _ArtifactParser {
       attrs[key] = value;
     }
     if (!attrs.id || !attrs.tool || !attrs.type || !attrs.base) {
-      logger9.warn({ attrs, attrString }, "Missing required attributes in artifact annotation");
+      logger8.warn({ attrs, attrString }, "Missing required attributes in artifact annotation");
       return null;
     }
     return {
@@ -2799,7 +2918,7 @@ var _ArtifactParser = class _ArtifactParser {
   /**
    * Extract artifact data from a create annotation - delegates to service
    */
-  async extractFromCreateAnnotation(annotation, agentId) {
+  async extractFromCreateAnnotation(annotation, subAgentId) {
     const request = {
       artifactId: annotation.artifactId,
       toolCallId: annotation.toolCallId,
@@ -2807,21 +2926,21 @@ var _ArtifactParser = class _ArtifactParser {
       baseSelector: annotation.baseSelector,
       detailsSelector: annotation.detailsSelector
     };
-    return this.artifactService.createArtifact(request, agentId);
+    return this.artifactService.createArtifact(request, subAgentId);
   }
   /**
    * Parse text with artifact markers into parts array
    * Handles both artifact:ref and artifact:create tags
    * Can work with or without pre-fetched artifact map
    */
-  async parseText(text, artifactMap, agentId) {
+  async parseText(text, artifactMap, subAgentId) {
     let processedText = text;
     const createAnnotations = this.parseCreateAnnotations(text);
     const createdArtifactData = /* @__PURE__ */ new Map();
     const failedAnnotations = [];
     for (const annotation of createAnnotations) {
       try {
-        const artifactData = await this.extractFromCreateAnnotation(annotation, agentId);
+        const artifactData = await this.extractFromCreateAnnotation(annotation, subAgentId);
         if (artifactData && annotation.raw) {
           createdArtifactData.set(annotation.raw, artifactData);
         } else if (annotation.raw) {
@@ -2829,7 +2948,7 @@ var _ArtifactParser = class _ArtifactParser {
             `Failed to create artifact "${annotation.artifactId}": Missing or invalid data`
           );
           processedText = processedText.replace(annotation.raw, "");
-          logger9.warn(
+          logger8.warn(
             { annotation, artifactData },
             "Removed failed artifact:create annotation from output"
           );
@@ -2840,11 +2959,11 @@ var _ArtifactParser = class _ArtifactParser {
         if (annotation.raw) {
           processedText = processedText.replace(annotation.raw, "");
         }
-        logger9.error({ annotation, error }, "Failed to extract artifact from create annotation");
+        logger8.error({ annotation, error }, "Failed to extract artifact from create annotation");
       }
     }
     if (failedAnnotations.length > 0) {
-      logger9.warn(
+      logger8.warn(
         {
           failedCount: failedAnnotations.length,
           failures: failedAnnotations
@@ -2908,7 +3027,7 @@ var _ArtifactParser = class _ArtifactParser {
   /**
    * Process object/dataComponents for artifact components
    */
-  async parseObject(obj, artifactMap, agentId) {
+  async parseObject(obj, artifactMap, subAgentId) {
     if (obj?.dataComponents && Array.isArray(obj.dataComponents)) {
       const parts = [];
       for (const component of obj.dataComponents) {
@@ -2932,7 +3051,7 @@ var _ArtifactParser = class _ArtifactParser {
             });
           }
         } else if (this.isArtifactCreateComponent(component)) {
-          const createData = await this.extractFromArtifactCreateComponent(component, agentId);
+          const createData = await this.extractFromArtifactCreateComponent(component, subAgentId);
           if (createData) {
             parts.push({
               kind: "data",
@@ -2973,7 +3092,7 @@ var _ArtifactParser = class _ArtifactParser {
       ] : [];
     }
     if (this.isArtifactCreateComponent(obj)) {
-      const createData = await this.extractFromArtifactCreateComponent(obj, agentId);
+      const createData = await this.extractFromArtifactCreateComponent(obj, subAgentId);
       return createData ? [
         {
           kind: "data",
@@ -3005,7 +3124,7 @@ var _ArtifactParser = class _ArtifactParser {
   /**
    * Extract artifact from ArtifactCreate component
    */
-  async extractFromArtifactCreateComponent(component, agentId) {
+  async extractFromArtifactCreateComponent(component, subAgentId) {
     const props = component.props;
     if (!props) {
       return null;
@@ -3017,7 +3136,7 @@ var _ArtifactParser = class _ArtifactParser {
       baseSelector: props.base_selector,
       detailsSelector: props.details_selector || {}
     };
-    return await this.extractFromCreateAnnotation(annotation, agentId);
+    return await this.extractFromCreateAnnotation(annotation, subAgentId);
   }
   /**
    * Get artifact data - delegates to service
@@ -3057,7 +3176,7 @@ __publicField(_ArtifactParser, "INCOMPLETE_CREATE_REGEX", /<artifact:create(?![^
 var ArtifactParser = _ArtifactParser;
 
 // src/services/GraphSession.ts
-var logger10 = agentsCore.getLogger("GraphSession");
+var logger9 = agentsCore.getLogger("GraphSession");
 var GraphSession = class {
   // Whether to send data operations
   constructor(sessionId, messageId, graphId, tenantId, projectId, contextId) {
@@ -3090,7 +3209,7 @@ var GraphSession = class {
     __publicField(this, "artifactParser");
     // Session-scoped ArtifactParser instance
     __publicField(this, "isEmitOperations", false);
-    logger10.debug({ sessionId, messageId, graphId }, "GraphSession created");
+    logger9.debug({ sessionId, messageId, graphId }, "GraphSession created");
     if (tenantId && projectId) {
       toolSessionManager.createSessionWithId(
         sessionId,
@@ -3104,7 +3223,6 @@ var GraphSession = class {
         tenantId,
         projectId,
         sessionId,
-        // Same ID as ToolSession
         contextId,
         taskId: `task_${contextId}-${messageId}`,
         streamRequestId: sessionId
@@ -3125,7 +3243,7 @@ var GraphSession = class {
    */
   enableEmitOperations() {
     this.isEmitOperations = true;
-    logger10.info(
+    logger9.info(
       { sessionId: this.sessionId },
       "\u{1F50D} DEBUG: Emit operations enabled for GraphSession"
     );
@@ -3142,14 +3260,14 @@ var GraphSession = class {
           label: this.generateEventLabel(event),
           details: {
             timestamp: event.timestamp,
-            agentId: event.agentId,
+            subAgentId: event.subAgentId,
             data: event.data
           }
         };
         await streamHelper.writeOperation(formattedOperation);
       }
     } catch (error) {
-      logger10.error(
+      logger9.error(
         {
           sessionId: this.sessionId,
           eventType: event.eventType,
@@ -3165,29 +3283,19 @@ var GraphSession = class {
   generateEventLabel(event) {
     switch (event.eventType) {
       case "agent_generate":
-        return `Agent ${event.agentId} generating response`;
+        return `Agent ${event.subAgentId} generating response`;
       case "agent_reasoning":
-        return `Agent ${event.agentId} reasoning through request`;
-      case "tool_execution": {
-        const toolData = event.data;
-        return `Tool execution: ${toolData.toolName || "unknown"}`;
-      }
-      case "transfer": {
-        const transferData = event.data;
-        return `Agent transfer: ${transferData.fromAgent} \u2192 ${transferData.targetAgent}`;
-      }
-      case "delegation_sent": {
-        const delegationData = event.data;
-        return `Task delegated: ${delegationData.fromAgent} \u2192 ${delegationData.targetAgent}`;
-      }
-      case "delegation_returned": {
-        const returnData = event.data;
-        return `Task completed: ${returnData.targetAgent} \u2192 ${returnData.fromAgent}`;
-      }
-      case "artifact_saved": {
-        const artifactData = event.data;
-        return `Artifact saved: ${artifactData.artifactType || "unknown type"}`;
-      }
+        return `Agent ${event.subAgentId} reasoning through request`;
+      case "tool_execution":
+        return `Tool execution: ${event.data.toolName || "unknown"}`;
+      case "transfer":
+        return `Agent transfer: ${event.data.fromSubAgent} \u2192 ${event.data.targetSubAgent}`;
+      case "delegation_sent":
+        return `Task delegated: ${event.data.fromSubAgent} \u2192 ${event.data.targetSubAgent}`;
+      case "delegation_returned":
+        return `Task completed: ${event.data.targetSubAgent} \u2192 ${event.data.fromSubAgent}`;
+      case "artifact_saved":
+        return `Artifact saved: ${event.data.artifactType || "unknown type"}`;
       default:
         return `${event.eventType} event`;
     }
@@ -3212,7 +3320,7 @@ var GraphSession = class {
     if (this.statusUpdateState.config.timeInSeconds) {
       this.statusUpdateTimer = setInterval(async () => {
         if (!this.statusUpdateState || this.isEnded) {
-          logger10.debug(
+          logger9.debug(
             { sessionId: this.sessionId },
             "Timer triggered but session already cleaned up or ended"
           );
@@ -3224,7 +3332,7 @@ var GraphSession = class {
         }
         await this.checkAndSendTimeBasedUpdate();
       }, this.statusUpdateState.config.timeInSeconds * 1e3);
-      logger10.info(
+      logger9.info(
         {
           sessionId: this.sessionId,
           intervalMs: this.statusUpdateState.config.timeInSeconds * 1e3
@@ -3235,22 +3343,24 @@ var GraphSession = class {
   }
   /**
    * Record an event in the session and trigger status updates if configured
+   * Generic type parameter T ensures eventType and data are correctly paired
    */
-  recordEvent(eventType, agentId, data) {
+  recordEvent(eventType, subAgentId, data) {
     if (this.isEmitOperations) {
-      this.sendDataOperation({
+      const dataOpEvent = {
         timestamp: Date.now(),
         eventType,
-        agentId,
+        subAgentId,
         data
-      });
+      };
+      this.sendDataOperation(dataOpEvent);
     }
     if (this.isEnded) {
-      logger10.debug(
+      logger9.debug(
         {
           sessionId: this.sessionId,
           eventType,
-          agentId
+          subAgentId
         },
         "Event received after session ended - ignoring"
       );
@@ -3259,59 +3369,62 @@ var GraphSession = class {
     const event = {
       timestamp: Date.now(),
       eventType,
-      agentId,
+      subAgentId,
       data
     };
     this.events.push(event);
-    if (eventType === "artifact_saved" && data.pendingGeneration) {
-      const artifactId = data.artifactId;
-      if (this.pendingArtifacts.size >= this.MAX_PENDING_ARTIFACTS) {
-        logger10.warn(
-          {
-            sessionId: this.sessionId,
-            artifactId,
-            pendingCount: this.pendingArtifacts.size,
-            maxAllowed: this.MAX_PENDING_ARTIFACTS
-          },
-          "Too many pending artifacts, skipping processing"
-        );
-        return;
-      }
-      this.pendingArtifacts.add(artifactId);
-      setImmediate(() => {
-        const artifactDataWithAgent = { ...data, agentId };
-        this.processArtifact(artifactDataWithAgent).then(() => {
-          this.pendingArtifacts.delete(artifactId);
-          this.artifactProcessingErrors.delete(artifactId);
-        }).catch((error) => {
-          const errorCount = (this.artifactProcessingErrors.get(artifactId) || 0) + 1;
-          this.artifactProcessingErrors.set(artifactId, errorCount);
-          if (errorCount >= this.MAX_ARTIFACT_RETRIES) {
+    if (eventType === "artifact_saved") {
+      const artifactData = data;
+      if (artifactData.pendingGeneration) {
+        const artifactId = artifactData.artifactId;
+        if (this.pendingArtifacts.size >= this.MAX_PENDING_ARTIFACTS) {
+          logger9.warn(
+            {
+              sessionId: this.sessionId,
+              artifactId,
+              pendingCount: this.pendingArtifacts.size,
+              maxAllowed: this.MAX_PENDING_ARTIFACTS
+            },
+            "Too many pending artifacts, skipping processing"
+          );
+          return;
+        }
+        this.pendingArtifacts.add(artifactId);
+        setImmediate(() => {
+          const artifactDataWithAgent = { ...artifactData, subAgentId };
+          this.processArtifact(artifactDataWithAgent).then(() => {
             this.pendingArtifacts.delete(artifactId);
-            logger10.error(
-              {
-                sessionId: this.sessionId,
-                artifactId,
-                errorCount,
-                maxRetries: this.MAX_ARTIFACT_RETRIES,
-                error: error instanceof Error ? error.message : "Unknown error",
-                stack: error instanceof Error ? error.stack : void 0
-              },
-              "Artifact processing failed after max retries, giving up"
-            );
-          } else {
-            logger10.warn(
-              {
-                sessionId: this.sessionId,
-                artifactId,
-                errorCount,
-                error: error instanceof Error ? error.message : "Unknown error"
-              },
-              "Artifact processing failed, may retry"
-            );
-          }
+            this.artifactProcessingErrors.delete(artifactId);
+          }).catch((error) => {
+            const errorCount = (this.artifactProcessingErrors.get(artifactId) || 0) + 1;
+            this.artifactProcessingErrors.set(artifactId, errorCount);
+            if (errorCount >= this.MAX_ARTIFACT_RETRIES) {
+              this.pendingArtifacts.delete(artifactId);
+              logger9.error(
+                {
+                  sessionId: this.sessionId,
+                  artifactId,
+                  errorCount,
+                  maxRetries: this.MAX_ARTIFACT_RETRIES,
+                  error: error instanceof Error ? error.message : "Unknown error",
+                  stack: error instanceof Error ? error.stack : void 0
+                },
+                "Artifact processing failed after max retries, giving up"
+              );
+            } else {
+              logger9.warn(
+                {
+                  sessionId: this.sessionId,
+                  artifactId,
+                  errorCount,
+                  error: error instanceof Error ? error.message : "Unknown error"
+                },
+                "Artifact processing failed, may retry"
+              );
+            }
+          });
         });
-      });
+      }
     }
     if (!this.isEnded) {
       this.checkStatusUpdates();
@@ -3322,14 +3435,14 @@ var GraphSession = class {
    */
   checkStatusUpdates() {
     if (this.isEnded) {
-      logger10.debug(
+      logger9.debug(
         { sessionId: this.sessionId },
         "Session has ended - skipping status update check"
       );
       return;
     }
     if (!this.statusUpdateState) {
-      logger10.debug({ sessionId: this.sessionId }, "No status update state - skipping check");
+      logger9.debug({ sessionId: this.sessionId }, "No status update state - skipping check");
       return;
     }
     const statusUpdateState = this.statusUpdateState;
@@ -3340,11 +3453,11 @@ var GraphSession = class {
    */
   async checkAndSendTimeBasedUpdate() {
     if (this.isEnded) {
-      logger10.debug({ sessionId: this.sessionId }, "Session has ended - skipping time-based update");
+      logger9.debug({ sessionId: this.sessionId }, "Session has ended - skipping time-based update");
       return;
     }
     if (!this.statusUpdateState) {
-      logger10.debug(
+      logger9.debug(
         { sessionId: this.sessionId },
         "No status updates configured for time-based check"
       );
@@ -3357,7 +3470,7 @@ var GraphSession = class {
     try {
       await this.generateAndSendUpdate();
     } catch (error) {
-      logger10.error(
+      logger9.error(
         {
           sessionId: this.sessionId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -3381,8 +3494,8 @@ var GraphSession = class {
   /**
    * Get events filtered by agent
    */
-  getEventsByAgent(agentId) {
-    return this.events.filter((event) => event.agentId === agentId);
+  getEventsByAgent(subAgentId) {
+    return this.events.filter((event) => event.subAgentId === subAgentId);
   }
   /**
    * Get summary of session activity
@@ -3397,7 +3510,7 @@ var GraphSession = class {
     );
     const agentCounts = this.events.reduce(
       (counts, event) => {
-        counts[event.agentId] = (counts[event.agentId] || 0) + 1;
+        counts[event.subAgentId] = (counts[event.subAgentId] || 0) + 1;
         return counts;
       },
       {}
@@ -3460,29 +3573,29 @@ var GraphSession = class {
    */
   async generateAndSendUpdate() {
     if (this.isEnded) {
-      logger10.debug({ sessionId: this.sessionId }, "Session has ended - not generating update");
+      logger9.debug({ sessionId: this.sessionId }, "Session has ended - not generating update");
       return;
     }
     if (this.isTextStreaming) {
-      logger10.debug(
+      logger9.debug(
         { sessionId: this.sessionId },
         "Text is currently streaming - skipping status update"
       );
       return;
     }
     if (this.isGeneratingUpdate) {
-      logger10.debug(
+      logger9.debug(
         { sessionId: this.sessionId },
         "Update already in progress - skipping duplicate generation"
       );
       return;
     }
     if (!this.statusUpdateState) {
-      logger10.warn({ sessionId: this.sessionId }, "No status update state - cannot generate update");
+      logger9.warn({ sessionId: this.sessionId }, "No status update state - cannot generate update");
       return;
     }
     if (!this.graphId) {
-      logger10.warn({ sessionId: this.sessionId }, "No graph ID - cannot generate update");
+      logger9.warn({ sessionId: this.sessionId }, "No graph ID - cannot generate update");
       return;
     }
     const newEventCount = this.events.length - this.statusUpdateState.lastEventCount;
@@ -3494,7 +3607,7 @@ var GraphSession = class {
     try {
       const streamHelper = getStreamHelper(this.sessionId);
       if (!streamHelper) {
-        logger10.warn(
+        logger9.warn(
           { sessionId: this.sessionId },
           "No stream helper found - cannot send status update"
         );
@@ -3514,7 +3627,7 @@ var GraphSession = class {
       if (result.summaries && result.summaries.length > 0) {
         for (const summary of result.summaries) {
           if (!summary || !summary.type || !summary.data || !summary.data.label || Object.keys(summary.data).length === 0) {
-            logger10.warn(
+            logger9.warn(
               {
                 sessionId: this.sessionId,
                 summary
@@ -3551,7 +3664,7 @@ var GraphSession = class {
         this.statusUpdateState.lastEventCount = this.events.length;
       }
     } catch (error) {
-      logger10.error(
+      logger9.error(
         {
           sessionId: this.sessionId,
           error: error instanceof Error ? error.message : "Unknown error",
@@ -3589,7 +3702,7 @@ var GraphSession = class {
           this.releaseUpdateLock();
         }
       } catch (error) {
-        logger10.error(
+        logger9.error(
           {
             sessionId: this.sessionId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -3667,7 +3780,7 @@ User's Question/Context:
 ${conversationHistory}
 ` : "";
             } catch (error) {
-              logger10.warn(
+              logger9.warn(
                 { sessionId: this.sessionId, error },
                 "Failed to fetch conversation history for structured status update"
               );
@@ -3801,7 +3914,7 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
           return { summaries };
         } catch (error) {
           agentsCore.setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
-          logger10.error({ error }, "Failed to generate structured update, using fallback");
+          logger9.error({ error }, "Failed to generate structured update, using fallback");
           return { summaries: [] };
         } finally {
           span.end();
@@ -3827,7 +3940,7 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
    */
   buildZodSchemaFromJson(jsonSchema) {
     const properties = {};
-    properties["label"] = z6.z.string().describe(
+    properties.label = z6.z.string().describe(
       'A short 3-5 word phrase, that is a descriptive label for the update component. This Label must be EXTREMELY unique to represent the UNIQUE update we are providing. The SPECIFIC finding, result, or insight discovered (e.g., "Slack bot needs workspace admin role", "Found ingestion requires 3 steps", "Channel history limited to 10k messages"). State the ACTUAL information found, not that you searched. What did you LEARN or DISCOVER? What specific detail is now known? CRITICAL: Only use facts explicitly found in the activities - NEVER invent names, people, organizations, or details that are not present in the actual tool results.'
     );
     for (const [key, value] of Object.entries(jsonSchema.properties)) {
@@ -3896,11 +4009,10 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
     for (const event of events) {
       switch (event.eventType) {
         case "tool_execution": {
-          const data = event.data;
-          const resultStr = JSON.stringify(data.result);
+          const resultStr = JSON.stringify(event.data.result);
           activities.push(
-            `\u{1F527} **${data.toolName}** ${data.duration ? `(${data.duration}ms)` : ""}
-   \u{1F4E5} Input: ${JSON.stringify(data.args)}
+            `\u{1F527} **${event.data.toolName}** ${event.data.duration ? `(${event.data.duration}ms)` : ""}
+   \u{1F4E5} Input: ${JSON.stringify(event.data.args)}
    \u{1F4E4} Output: ${resultStr}`
           );
           break;
@@ -3912,23 +4024,24 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
         case "artifact_saved":
           break;
         case "agent_reasoning": {
-          const data = event.data;
           activities.push(
             `\u2699\uFE0F **Analyzing request**
-   Details: ${JSON.stringify(data.parts, null, 2)}`
+   Details: ${JSON.stringify(event.data.parts, null, 2)}`
           );
           break;
         }
         case "agent_generate": {
-          const data = event.data;
           activities.push(
             `\u2699\uFE0F **Preparing response**
-   Details: ${JSON.stringify(data.parts, null, 2)}`
+   Details: ${JSON.stringify(event.data.parts, null, 2)}`
           );
           break;
         }
         default: {
-          activities.push(`\u{1F4CB} **${event.eventType}**: ${JSON.stringify(event.data, null, 2)}`);
+          const safeEvent = event;
+          activities.push(
+            `\u{1F4CB} **${safeEvent.eventType}**: ${JSON.stringify(safeEvent.data, null, 2)}`
+          );
           break;
         }
       }
@@ -3946,7 +4059,7 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
           "graph_session.id": this.sessionId,
           "artifact.id": artifactData.artifactId,
           "artifact.type": artifactData.artifactType || "unknown",
-          "artifact.agent_id": artifactData.agentId || "unknown",
+          "artifact.agent_id": artifactData.subAgentId || "unknown",
           "artifact.tool_call_id": artifactData.metadata?.toolCallId || "unknown",
           "artifact.data": JSON.stringify(artifactData.data, null, 2),
           "tenant.id": artifactData.tenantId || "unknown",
@@ -4005,34 +4118,34 @@ Make it specific and relevant.`;
           let modelToUse = this.statusUpdateState?.summarizerModel;
           if (!modelToUse?.model?.trim()) {
             if (!this.statusUpdateState?.baseModel?.model?.trim()) {
-              if (artifactData.agentId && artifactData.tenantId && artifactData.projectId) {
+              if (artifactData.subAgentId && artifactData.tenantId && artifactData.projectId) {
                 try {
-                  const agentData = await agentsCore.getAgentById(dbClient_default)({
+                  const agentData = await agentsCore.getSubAgentById(dbClient_default)({
                     scopes: {
                       tenantId: artifactData.tenantId,
                       projectId: artifactData.projectId,
                       graphId: this.graphId || ""
                     },
-                    agentId: artifactData.agentId
+                    subAgentId: artifactData.subAgentId
                   });
                   if (agentData && "models" in agentData && agentData.models?.base?.model) {
                     modelToUse = agentData.models.base;
-                    logger10.info(
+                    logger9.info(
                       {
                         sessionId: this.sessionId,
                         artifactId: artifactData.artifactId,
-                        agentId: artifactData.agentId,
+                        subAgentId: artifactData.subAgentId,
                         model: modelToUse.model
                       },
                       "Using agent model configuration for artifact name generation"
                     );
                   }
                 } catch (error) {
-                  logger10.warn(
+                  logger9.warn(
                     {
                       sessionId: this.sessionId,
                       artifactId: artifactData.artifactId,
-                      agentId: artifactData.agentId,
+                      subAgentId: artifactData.subAgentId,
                       error: error instanceof Error ? error.message : "Unknown error"
                     },
                     "Failed to get agent model configuration"
@@ -4040,7 +4153,7 @@ Make it specific and relevant.`;
                 }
               }
               if (!modelToUse?.model?.trim()) {
-                logger10.warn(
+                logger9.warn(
                   {
                     sessionId: this.sessionId,
                     artifactId: artifactData.artifactId
@@ -4122,7 +4235,7 @@ Make it specific and relevant.`;
                     return result2;
                   } catch (error) {
                     lastError = error instanceof Error ? error : new Error(String(error));
-                    logger10.warn(
+                    logger9.warn(
                       {
                         sessionId: this.sessionId,
                         artifactId: artifactData.artifactId,
@@ -4174,7 +4287,7 @@ Make it specific and relevant.`;
             });
             span.setStatus({ code: api.SpanStatusCode.OK });
           } catch (saveError) {
-            logger10.error(
+            logger9.error(
               {
                 sessionId: this.sessionId,
                 artifactId: artifactData.artifactId,
@@ -4202,7 +4315,7 @@ Make it specific and relevant.`;
                   metadata: artifactData.metadata || {},
                   toolCallId: artifactData.toolCallId
                 });
-                logger10.info(
+                logger9.info(
                   {
                     sessionId: this.sessionId,
                     artifactId: artifactData.artifactId
@@ -4213,7 +4326,7 @@ Make it specific and relevant.`;
             } catch (fallbackError) {
               const isDuplicateError = fallbackError instanceof Error && (fallbackError.message?.includes("UNIQUE") || fallbackError.message?.includes("duplicate"));
               if (isDuplicateError) ; else {
-                logger10.error(
+                logger9.error(
                   {
                     sessionId: this.sessionId,
                     artifactId: artifactData.artifactId,
@@ -4226,7 +4339,7 @@ Make it specific and relevant.`;
           }
         } catch (error) {
           agentsCore.setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
-          logger10.error(
+          logger9.error(
             {
               sessionId: this.sessionId,
               artifactId: artifactData.artifactId,
@@ -4245,7 +4358,7 @@ Make it specific and relevant.`;
    */
   setArtifactCache(key, artifact) {
     this.artifactCache.set(key, artifact);
-    logger10.debug({ sessionId: this.sessionId, key }, "Artifact cached in session");
+    logger9.debug({ sessionId: this.sessionId, key }, "Artifact cached in session");
   }
   /**
    * Get session-scoped ArtifactService instance
@@ -4264,7 +4377,7 @@ Make it specific and relevant.`;
    */
   getArtifactCache(key) {
     const artifact = this.artifactCache.get(key);
-    logger10.debug({ sessionId: this.sessionId, key, found: !!artifact }, "Artifact cache lookup");
+    logger9.debug({ sessionId: this.sessionId, key, found: !!artifact }, "Artifact cache lookup");
     return artifact || null;
   }
   /**
@@ -4287,7 +4400,7 @@ var GraphSessionManager = class {
     const sessionId = messageId;
     const session = new GraphSession(sessionId, messageId, graphId, tenantId, projectId, contextId);
     this.sessions.set(sessionId, session);
-    logger10.info(
+    logger9.info(
       { sessionId, messageId, graphId, tenantId, projectId, contextId },
       "GraphSession created"
     );
@@ -4301,7 +4414,7 @@ var GraphSessionManager = class {
     if (session) {
       session.initializeStatusUpdates(config, summarizerModel);
     } else {
-      logger10.error(
+      logger9.error(
         {
           sessionId,
           availableSessions: Array.from(this.sessions.keys())
@@ -4318,7 +4431,7 @@ var GraphSessionManager = class {
     if (session) {
       session.enableEmitOperations();
     } else {
-      logger10.error(
+      logger9.error(
         {
           sessionId,
           availableSessions: Array.from(this.sessions.keys())
@@ -4335,14 +4448,15 @@ var GraphSessionManager = class {
   }
   /**
    * Record an event in a session
+   * Generic type parameter T ensures eventType and data are correctly paired
    */
-  recordEvent(sessionId, eventType, agentId, data) {
+  recordEvent(sessionId, eventType, subAgentId, data) {
     const session = this.sessions.get(sessionId);
     if (!session) {
-      logger10.warn({ sessionId }, "Attempted to record event in non-existent session");
+      logger9.warn({ sessionId }, "Attempted to record event in non-existent session");
       return;
     }
-    session.recordEvent(eventType, agentId, data);
+    session.recordEvent(eventType, subAgentId, data);
   }
   /**
    * End a session and return the final event data
@@ -4350,12 +4464,12 @@ var GraphSessionManager = class {
   endSession(sessionId) {
     const session = this.sessions.get(sessionId);
     if (!session) {
-      logger10.warn({ sessionId }, "Attempted to end non-existent session");
+      logger9.warn({ sessionId }, "Attempted to end non-existent session");
       return [];
     }
     const events = session.getEvents();
     const summary = session.getSummary();
-    logger10.info({ sessionId, summary }, "GraphSession ended");
+    logger9.info({ sessionId, summary }, "GraphSession ended");
     session.cleanup();
     this.sessions.delete(sessionId);
     return events;
@@ -4463,7 +4577,7 @@ init_logger();
 
 // src/services/IncrementalStreamParser.ts
 init_logger();
-var logger11 = agentsCore.getLogger("IncrementalStreamParser");
+var logger10 = agentsCore.getLogger("IncrementalStreamParser");
 var _IncrementalStreamParser = class _IncrementalStreamParser {
   // Max number of collected parts to prevent unbounded growth
   constructor(streamHelper, tenantId, contextId, artifactParserOptions) {
@@ -4479,10 +4593,11 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
     __publicField(this, "lastStreamedComponents", /* @__PURE__ */ new Map());
     __publicField(this, "componentSnapshots", /* @__PURE__ */ new Map());
     __publicField(this, "artifactMap");
-    __publicField(this, "agentId");
+    __publicField(this, "subAgentId");
+    __publicField(this, "allStreamedContent", []);
     this.streamHelper = streamHelper;
     this.contextId = contextId;
-    this.agentId = artifactParserOptions?.agentId;
+    this.subAgentId = artifactParserOptions?.subAgentId;
     if (artifactParserOptions?.streamRequestId) {
       const sessionParser = graphSessionManager.getArtifactParser(
         artifactParserOptions.streamRequestId
@@ -4515,7 +4630,7 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
   async initializeArtifactMap() {
     try {
       this.artifactMap = await this.artifactParser.getContextArtifacts(this.contextId);
-      logger11.debug(
+      logger10.debug(
         {
           contextId: this.contextId,
           artifactMapSize: this.artifactMap.size
@@ -4523,7 +4638,7 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
         "Initialized artifact map for streaming"
       );
     } catch (error) {
-      logger11.warn({ error, contextId: this.contextId }, "Failed to initialize artifact map");
+      logger10.warn({ error, contextId: this.contextId }, "Failed to initialize artifact map");
       this.artifactMap = /* @__PURE__ */ new Map();
     }
   }
@@ -4598,10 +4713,12 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
               this.hasStartedRole = true;
             }
             await this.streamHelper.streamText(newText, 50);
-            this.collectedParts.push({
+            const textPart = {
               kind: "text",
               text: newText
-            });
+            };
+            this.collectedParts.push(textPart);
+            this.allStreamedContent.push(textPart);
           }
           continue;
         }
@@ -4625,7 +4742,7 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
         dataComponents: [component]
       },
       this.artifactMap,
-      this.agentId
+      this.subAgentId
     );
     if (!Array.isArray(parts)) {
       console.warn("parseObject returned non-array:", parts);
@@ -4701,7 +4818,7 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
               dataComponents: [component]
             },
             this.artifactMap,
-            this.agentId
+            this.subAgentId
           );
           for (const part of parts) {
             await this.streamPart(part);
@@ -4727,10 +4844,12 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
     if (this.pendingTextBuffer) {
       const cleanedText = this.pendingTextBuffer.replace(/<\/?artifact:ref(?:\s[^>]*)?>\/?>/g, "").replace(/<\/?artifact(?:\s[^>]*)?>\/?>/g, "").replace(/<\/artifact:ref>/g, "").replace(/<\/(?:\w+:)?artifact>/g, "");
       if (cleanedText) {
-        this.collectedParts.push({
+        const textPart = {
           kind: "text",
           text: cleanedText
-        });
+        };
+        this.collectedParts.push(textPart);
+        this.allStreamedContent.push(textPart);
         await this.streamHelper.streamText(cleanedText, 50);
       }
       this.pendingTextBuffer = "";
@@ -4745,6 +4864,12 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
   getCollectedParts() {
     return [...this.collectedParts];
   }
+  /**
+   * Get all streamed content that was actually sent to the user
+   */
+  getAllStreamedContent() {
+    return [...this.allStreamedContent];
+  }
   /**
    * Parse buffer for complete artifacts and text parts (for text streaming)
    */
@@ -4755,7 +4880,11 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
       const safeEnd = this.artifactParser.findSafeTextBoundary(workingBuffer);
       if (safeEnd > 0) {
         const safeText = workingBuffer.slice(0, safeEnd);
-        const parts2 = await this.artifactParser.parseText(safeText, this.artifactMap, this.agentId);
+        const parts2 = await this.artifactParser.parseText(
+          safeText,
+          this.artifactMap,
+          this.subAgentId
+        );
         completeParts.push(...parts2);
         return {
           completeParts,
@@ -4770,7 +4899,7 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
     const parts = await this.artifactParser.parseText(
       workingBuffer,
       this.artifactMap,
-      this.agentId
+      this.subAgentId
     );
     if (parts.length > 0 && parts[parts.length - 1].kind === "text") {
       const lastPart = parts[parts.length - 1];
@@ -4800,10 +4929,15 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
    */
   async streamPart(part) {
     this.collectedParts.push({ ...part });
+    this.allStreamedContent.push({ ...part });
     if (this.collectedParts.length > _IncrementalStreamParser.MAX_COLLECTED_PARTS) {
       const excess = this.collectedParts.length - _IncrementalStreamParser.MAX_COLLECTED_PARTS;
       this.collectedParts.splice(0, excess);
     }
+    if (this.allStreamedContent.length > _IncrementalStreamParser.MAX_COLLECTED_PARTS) {
+      const excess = this.allStreamedContent.length - _IncrementalStreamParser.MAX_COLLECTED_PARTS;
+      this.allStreamedContent.splice(0, excess);
+    }
     if (!this.hasStartedRole) {
       await this.streamHelper.writeRole("assistant");
       this.hasStartedRole = true;
@@ -4844,12 +4978,12 @@ var IncrementalStreamParser = _IncrementalStreamParser;
 
 // src/services/ResponseFormatter.ts
 init_logger();
-var logger12 = agentsCore.getLogger("ResponseFormatter");
+var logger11 = agentsCore.getLogger("ResponseFormatter");
 var ResponseFormatter = class {
   constructor(tenantId, artifactParserOptions) {
     __publicField(this, "artifactParser");
-    __publicField(this, "agentId");
-    this.agentId = artifactParserOptions?.agentId;
+    __publicField(this, "subAgentId");
+    this.subAgentId = artifactParserOptions?.subAgentId;
     if (artifactParserOptions?.streamRequestId) {
       const sessionParser = graphSessionManager.getArtifactParser(
         artifactParserOptions.streamRequestId
@@ -4888,7 +5022,7 @@ var ResponseFormatter = class {
         const parts = await this.artifactParser.parseObject(
           responseObject,
           artifactMap,
-          this.agentId
+          this.subAgentId
         );
         const uniqueArtifacts = this.countUniqueArtifacts(parts);
         span.setAttributes({
@@ -4903,7 +5037,7 @@ var ResponseFormatter = class {
         return { parts };
       } catch (error) {
         agentsCore.setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
-        logger12.error({ error, responseObject }, "Error formatting object response");
+        logger11.error({ error, responseObject }, "Error formatting object response");
         return {
           parts: [{ kind: "data", data: responseObject }]
         };
@@ -4935,7 +5069,11 @@ var ResponseFormatter = class {
           "response.type": "text",
           "response.availableArtifacts": artifactMap.size
         });
-        const parts = await this.artifactParser.parseText(responseText, artifactMap, this.agentId);
+        const parts = await this.artifactParser.parseText(
+          responseText,
+          artifactMap,
+          this.subAgentId
+        );
         if (parts.length === 1 && parts[0].kind === "text") {
           return { text: parts[0].text };
         }
@@ -4955,7 +5093,7 @@ var ResponseFormatter = class {
         return { parts };
       } catch (error) {
         agentsCore.setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
-        logger12.error({ error, responseText }, "Error formatting response");
+        logger11.error({ error, responseText }, "Error formatting response");
         return { text: responseText };
       } finally {
         span.end();
@@ -5009,20 +5147,20 @@ function agentInitializingOp(sessionId, graphId) {
     }
   };
 }
-function completionOp(agentId, iterations) {
+function completionOp(subAgentId, iterations) {
   return {
     type: "completion",
     details: {
-      agent: agentId,
+      agent: subAgentId,
       iteration: iterations
     }
   };
 }
-function errorOp(message, agentId, severity = "error", code) {
+function errorOp(message, subAgentId, severity = "error", code) {
   return {
     type: "error",
     message,
-    agent: agentId,
+    agent: subAgentId,
     severity,
     code,
     timestamp: Date.now()
@@ -5037,10 +5175,10 @@ init_logger();
 
 // src/utils/data-component-schema.ts
 init_logger();
-var logger13 = agentsCore.getLogger("DataComponentSchema");
+var logger12 = agentsCore.getLogger("DataComponentSchema");
 function jsonSchemaToZod(jsonSchema) {
   if (!jsonSchema || typeof jsonSchema !== "object") {
-    logger13.warn({ jsonSchema }, "Invalid JSON schema provided, using string fallback");
+    logger12.warn({ jsonSchema }, "Invalid JSON schema provided, using string fallback");
     return z6.z.string();
   }
   switch (jsonSchema.type) {
@@ -5067,7 +5205,7 @@ function jsonSchemaToZod(jsonSchema) {
     case "null":
       return z6.z.null();
     default:
-      logger13.warn(
+      logger12.warn(
         {
           unsupportedType: jsonSchema.type,
           schema: jsonSchema
@@ -5434,7 +5572,7 @@ function parseEmbeddedJson(data) {
 
 // src/a2a/client.ts
 init_logger();
-var logger14 = agentsCore.getLogger("a2aClient");
+var logger13 = agentsCore.getLogger("a2aClient");
 var DEFAULT_BACKOFF = {
   initialInterval: 500,
   maxInterval: 6e4,
@@ -5640,7 +5778,7 @@ var A2AClient = class {
       try {
         const res = await fn();
         if (attempt > 0) {
-          logger14.info(
+          logger13.info(
             {
               attempts: attempt + 1,
               elapsedTime: Date.now() - start
@@ -5655,7 +5793,7 @@ var A2AClient = class {
         }
         const elapsed = Date.now() - start;
         if (elapsed > maxElapsedTime) {
-          logger14.warn(
+          logger13.warn(
             {
               attempts: attempt + 1,
               elapsedTime: elapsed,
@@ -5676,7 +5814,7 @@ var A2AClient = class {
           retryInterval = initialInterval * attempt ** exponent + Math.random() * 1e3;
         }
         const delayMs = Math.min(retryInterval, maxInterval);
-        logger14.info(
+        logger13.info(
           {
             attempt: attempt + 1,
             delayMs,
@@ -5761,7 +5899,7 @@ var A2AClient = class {
     }
     const rpcResponse = await httpResponse.json();
     if (rpcResponse.id !== requestId2) {
-      logger14.warn(
+      logger13.warn(
         {
           method,
           expectedId: requestId2,
@@ -5960,7 +6098,7 @@ var A2AClient = class {
     try {
       while (true) {
         const { done, value } = await reader.read();
-        logger14.info({ done, value }, "parseA2ASseStream");
+        logger13.info({ done, value }, "parseA2ASseStream");
         if (done) {
           if (eventDataBuffer.trim()) {
             const result = this._processSseEventData(
@@ -6050,7 +6188,7 @@ var A2AClient = class {
 init_conversations();
 init_dbClient();
 init_logger();
-var logger15 = agentsCore.getLogger("relationships Tools");
+var logger14 = agentsCore.getLogger("relationships Tools");
 var generateTransferToolDescription = (config) => {
   return `Hand off the conversation to agent ${config.id}.
 
@@ -6074,7 +6212,7 @@ Delegate a specific task to agent ${config.id} when it seems like the agent can
 var createTransferToAgentTool = ({
   transferConfig,
   callingAgentId,
-  agent,
+  subAgent,
   streamRequestId
 }) => {
   return ai.tool({
@@ -6084,11 +6222,11 @@ var createTransferToAgentTool = ({
       const activeSpan = api.trace.getActiveSpan();
       if (activeSpan) {
         activeSpan.setAttributes({
-          "transfer.from_agent_id": callingAgentId,
-          "transfer.to_agent_id": transferConfig.id ?? "unknown"
+          [agentsCore.SPAN_KEYS.TRANSFER_FROM_SUB_AGENT_ID]: callingAgentId,
+          [agentsCore.SPAN_KEYS.TRANSFER_TO_SUB_AGENT_ID]: transferConfig.id ?? "unknown"
         });
       }
-      logger15.info(
+      logger14.info(
         {
           transferTo: transferConfig.id ?? "unknown",
           fromAgent: callingAgentId
@@ -6097,8 +6235,8 @@ var createTransferToAgentTool = ({
       );
       if (streamRequestId) {
         graphSessionManager.recordEvent(streamRequestId, "transfer", callingAgentId, {
-          fromAgent: callingAgentId,
-          targetAgent: transferConfig.id ?? "unknown",
+          fromSubAgent: callingAgentId,
+          targetSubAgent: transferConfig.id ?? "unknown",
           reason: `Transfer to ${transferConfig.name || transferConfig.id}`
         });
       }
@@ -6120,7 +6258,7 @@ function createDelegateToAgentTool({
   contextId,
   metadata,
   sessionId,
-  agent,
+  subAgent,
   credentialStoreRegistry
 }) {
   return ai.tool({
@@ -6131,9 +6269,9 @@ function createDelegateToAgentTool({
       const activeSpan = api.trace.getActiveSpan();
       if (activeSpan) {
         activeSpan.setAttributes({
-          "delegation.from_agent_id": callingAgentId,
-          "delegation.to_agent_id": delegateConfig.config.id ?? "unknown",
-          "delegation.id": delegationId
+          [agentsCore.SPAN_KEYS.DELEGATION_FROM_SUB_AGENT_ID]: callingAgentId,
+          [agentsCore.SPAN_KEYS.DELEGATION_TO_SUB_AGENT_ID]: delegateConfig.config.id ?? "unknown",
+          [agentsCore.SPAN_KEYS.DELEGATION_ID]: delegationId
         });
       }
       if (metadata.streamRequestId) {
@@ -6143,8 +6281,8 @@ function createDelegateToAgentTool({
           callingAgentId,
           {
             delegationId,
-            fromAgent: callingAgentId,
-            targetAgent: delegateConfig.config.id,
+            fromSubAgent: callingAgentId,
+            targetSubAgent: delegateConfig.config.id,
             taskDescription: input.message
           }
         );
@@ -6158,7 +6296,7 @@ function createDelegateToAgentTool({
             projectId,
             graphId
           },
-          agentId: delegateConfig.config.id
+          subAgentId: delegateConfig.config.id
         });
         if (externalAgent && (externalAgent.credentialReferenceId || externalAgent.headers) && credentialStoreRegistry) {
           const contextResolver = new agentsCore.ContextResolver(
@@ -6237,7 +6375,7 @@ function createDelegateToAgentTool({
           ...isInternal ? { fromAgentId: callingAgentId } : { fromExternalAgentId: callingAgentId }
         }
       };
-      logger15.info({ messageToSend }, "messageToSend");
+      logger14.info({ messageToSend }, "messageToSend");
       await agentsCore.createMessage(dbClient_default)({
         id: nanoid.nanoid(),
         tenantId,
@@ -6249,7 +6387,7 @@ function createDelegateToAgentTool({
         },
         visibility: isInternal ? "internal" : "external",
         messageType: "a2a-request",
-        fromAgentId: callingAgentId,
+        fromSubAgentId: callingAgentId,
         ...isInternal ? { toAgentId: delegateConfig.config.id } : { toExternalAgentId: delegateConfig.config.id }
       });
       const response = await a2aClient.sendMessage({
@@ -6264,8 +6402,8 @@ function createDelegateToAgentTool({
         conversationId: contextId,
         messageType: "a2a-response",
         visibility: isInternal ? "internal" : "external",
-        toAgentId: callingAgentId,
-        ...isInternal ? { fromAgentId: delegateConfig.config.id } : { fromExternalAgentId: delegateConfig.config.id }
+        toSubAgentId: callingAgentId,
+        ...isInternal ? { fromSubAgentId: delegateConfig.config.id } : { fromExternalAgentId: delegateConfig.config.id }
       });
       if (sessionId && context?.toolCallId) {
         const toolResult = {
@@ -6284,8 +6422,8 @@ function createDelegateToAgentTool({
           callingAgentId,
           {
             delegationId,
-            fromAgent: delegateConfig.config.id,
-            targetAgent: callingAgentId,
+            fromSubAgent: delegateConfig.config.id,
+            targetSubAgent: callingAgentId,
             result: response.result
           }
         );
@@ -6300,7 +6438,7 @@ function createDelegateToAgentTool({
 
 // src/agents/SystemPromptBuilder.ts
 init_logger();
-var logger16 = agentsCore.getLogger("SystemPromptBuilder");
+var logger15 = agentsCore.getLogger("SystemPromptBuilder");
 var SystemPromptBuilder = class {
   constructor(version, versionConfig) {
     this.version = version;
@@ -6316,12 +6454,12 @@ var SystemPromptBuilder = class {
         this.templates.set(name, content);
       }
       this.loaded = true;
-      logger16.debug(
+      logger15.debug(
         { templateCount: this.templates.size, version: this.version },
         `Loaded ${this.templates.size} templates for version ${this.version}`
       );
     } catch (error) {
-      logger16.error({ error }, `Failed to load templates for version ${this.version}`);
+      logger15.error({ error }, `Failed to load templates for version ${this.version}`);
       throw new Error(`Template loading failed: ${error}`);
     }
   }
@@ -7382,7 +7520,7 @@ function hasToolCallWithPrefix(prefix) {
     return false;
   };
 }
-var logger19 = agentsCore.getLogger("Agent");
+var logger18 = agentsCore.getLogger("Agent");
 var CONSTANTS = {
   MAX_GENERATION_STEPS: 12,
   PHASE_1_TIMEOUT_MS: 27e4,
@@ -7612,7 +7750,7 @@ var Agent = class {
   }
   getRelationTools(runtimeContext, sessionId) {
     const { transferRelations = [], delegateRelations = [] } = this.config;
-    const createToolName = (prefix, agentId) => `${prefix}_to_${agentId.toLowerCase().replace(/\s+/g, "_")}`;
+    const createToolName = (prefix, subAgentId) => `${prefix}_to_${subAgentId.toLowerCase().replace(/\s+/g, "_")}`;
     return Object.fromEntries([
       ...transferRelations.map((agentConfig) => {
         const toolName = createToolName("transfer", agentConfig.id);
@@ -7623,7 +7761,7 @@ var Agent = class {
             createTransferToAgentTool({
               transferConfig: agentConfig,
               callingAgentId: this.config.id,
-              agent: this,
+              subAgent: this,
               streamRequestId: runtimeContext?.metadata?.streamRequestId
             }),
             runtimeContext?.metadata?.streamRequestId,
@@ -7652,7 +7790,7 @@ var Agent = class {
                 apiKey: runtimeContext?.metadata?.apiKey
               },
               sessionId,
-              agent: this,
+              subAgent: this,
               credentialStoreRegistry: this.credentialStoreRegistry
             }),
             runtimeContext?.metadata?.streamRequestId,
@@ -7686,14 +7824,14 @@ var Agent = class {
     for (const toolSet of tools) {
       for (const [toolName, originalTool] of Object.entries(toolSet)) {
         if (!isValidTool(originalTool)) {
-          logger19.error({ toolName }, "Invalid MCP tool structure - missing required properties");
+          logger18.error({ toolName }, "Invalid MCP tool structure - missing required properties");
           continue;
         }
         const sessionWrappedTool = ai.tool({
           description: originalTool.description,
           inputSchema: originalTool.inputSchema,
           execute: async (args, { toolCallId }) => {
-            logger19.debug({ toolName, toolCallId }, "MCP Tool Called");
+            logger18.debug({ toolName, toolCallId }, "MCP Tool Called");
             try {
               const rawResult = await originalTool.execute(args, { toolCallId });
               const parsedResult = parseEmbeddedJson(rawResult);
@@ -7707,7 +7845,7 @@ var Agent = class {
               });
               return { result: enhancedResult, toolCallId };
             } catch (error) {
-              logger19.error({ toolName, toolCallId, error }, "MCP tool execution failed");
+              logger18.error({ toolName, toolCallId, error }, "MCP tool execution failed");
               throw error;
             }
           }
@@ -7752,7 +7890,7 @@ var Agent = class {
         tenantId: this.config.tenantId,
         projectId: this.config.projectId,
         graphId: this.config.graphId,
-        agentId: this.config.id
+        subAgentId: this.config.id
       }
     });
     const agentToolRelationHeaders = toolsForAgent.data.find((t) => t.toolId === tool3.id)?.headers || void 0;
@@ -7808,7 +7946,7 @@ var Agent = class {
         headers: agentToolRelationHeaders
       };
     }
-    logger19.info(
+    logger18.info(
       {
         toolName: tool3.name,
         credentialReferenceId,
@@ -7833,10 +7971,10 @@ var Agent = class {
         this.mcpClientCache.set(cacheKey, client);
       } catch (error) {
         this.mcpConnectionLocks.delete(cacheKey);
-        logger19.error(
+        logger18.error(
           {
             toolName: tool3.name,
-            agentId: this.config.id,
+            subAgentId: this.config.id,
             cacheKey,
             error: error instanceof Error ? error.message : String(error)
           },
@@ -7846,6 +7984,45 @@ var Agent = class {
       }
     }
     const tools = await client.tools();
+    if (!tools || Object.keys(tools).length === 0) {
+      const streamRequestId = this.getStreamRequestId();
+      if (streamRequestId) {
+        tracer.startActiveSpan(
+          "ai.toolCall",
+          {
+            attributes: {
+              "ai.toolCall.name": tool3.name,
+              "ai.toolCall.args": JSON.stringify({ operation: "mcp_tool_discovery" }),
+              "ai.toolCall.result": JSON.stringify({
+                status: "no_tools_available",
+                message: `MCP server has 0 effective tools. Double check the selected tools in your graph and the active tools in the MCP server configuration.`,
+                serverUrl: tool3.config.type === "mcp" ? tool3.config.mcp.server.url : "unknown",
+                originalToolName: tool3.name
+              }),
+              "ai.toolType": "mcp",
+              "ai.agentName": this.config.name || "unknown",
+              "conversation.id": this.conversationId || "unknown",
+              "graph.id": this.config.graphId || "unknown",
+              "tenant.id": this.config.tenantId || "unknown",
+              "project.id": this.config.projectId || "unknown"
+            }
+          },
+          (span) => {
+            agentsCore.setSpanWithError(span, new Error(`0 effective tools available for ${tool3.name}`));
+            graphSessionManager.recordEvent(streamRequestId, "tool_execution", this.config.id, {
+              toolName: tool3.name,
+              args: { operation: "mcp_tool_discovery" },
+              result: {
+                status: "no_tools_available",
+                message: `MCP server has 0 effective tools. Double check the selected tools in your graph and the active tools in the MCP server configuration.`,
+                serverUrl: tool3.config.type === "mcp" ? tool3.config.mcp.server.url : "unknown"
+              }
+            });
+            span.end();
+          }
+        );
+      }
+    }
     return tools;
   }
   async createMcpConnection(tool3, serverConfig) {
@@ -7857,99 +8034,120 @@ var Agent = class {
       await client.connect();
       return client;
     } catch (error) {
-      logger19.error(
+      logger18.error(
         {
           toolName: tool3.name,
-          agentId: this.config.id,
+          subAgentId: this.config.id,
           error: error instanceof Error ? error.message : String(error)
         },
         "Agent failed to connect to MCP server"
       );
+      if (error instanceof Error) {
+        if (error?.cause && JSON.stringify(error.cause).includes("ECONNREFUSED")) {
+          const errorMessage = "Connection refused. Please check if the MCP server is running.";
+          throw new Error(errorMessage);
+        } else if (error.message.includes("404")) {
+          const errorMessage = "Error accessing endpoint (HTTP 404)";
+          throw new Error(errorMessage);
+        } else {
+          throw new Error(`MCP server connection failed: ${error.message}`);
+        }
+      }
       throw error;
     }
   }
   async getFunctionTools(sessionId, streamRequestId) {
     const functionTools = {};
     try {
-      const toolsForAgent = await agentsCore.getToolsForAgent(dbClient_default)({
+      const functionToolsForAgent = await agentsCore.getFunctionToolsForSubAgent(dbClient_default)({
         scopes: {
-          tenantId: this.config.tenantId || "default",
-          projectId: this.config.projectId || "default",
-          graphId: this.config.graphId,
-          agentId: this.config.id
-        }
+          tenantId: this.config.tenantId,
+          projectId: this.config.projectId,
+          graphId: this.config.graphId
+        },
+        subAgentId: this.config.id
       });
-      const toolsData = toolsForAgent.data || [];
-      const functionToolDefs = toolsData.filter((tool3) => tool3.tool.config.type === "function");
-      if (functionToolDefs.length === 0) {
+      const functionToolsData = functionToolsForAgent.data || [];
+      if (functionToolsData.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;
+      for (const functionToolDef of functionToolsData) {
+        const functionId = functionToolDef.functionId;
+        if (!functionId) {
+          logger18.warn(
+            { functionToolId: functionToolDef.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"
           }
-          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"
+        });
+        if (!functionData) {
+          logger18.warn(
+            { functionId, functionToolId: functionToolDef.id },
+            "Function not found in functions table"
+          );
+          continue;
+        }
+        const zodSchema = jsonSchemaToZod(functionData.inputSchema);
+        const aiTool = ai.tool({
+          description: functionToolDef.description || functionToolDef.name,
+          inputSchema: zodSchema,
+          execute: async (args, { toolCallId }) => {
+            logger18.debug(
+              { toolName: functionToolDef.name, toolCallId, args },
+              "Function Tool Called"
             );
-            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 project = await agentsCore.getProject(dbClient_default)({
+                scopes: { tenantId: this.config.tenantId, projectId: this.config.projectId }
+              });
+              const defaultSandboxConfig = {
+                provider: "local",
+                runtime: "node22",
+                timeout: 3e4,
+                vcpus: 1
+              };
+              const result = await sandboxExecutor.executeFunctionTool(functionToolDef.id, args, {
+                description: functionToolDef.description || functionToolDef.name,
+                inputSchema: functionData.inputSchema || {},
+                executeCode: functionData.executeCode,
+                dependencies: functionData.dependencies || {},
+                sandboxConfig: project?.sandboxConfig || defaultSandboxConfig
+              });
+              toolSessionManager.recordToolResult(sessionId || "", {
+                toolCallId,
+                toolName: functionToolDef.name,
+                args,
+                result,
+                timestamp: Date.now()
+              });
+              return { result, toolCallId };
+            } catch (error) {
+              logger18.error(
+                { toolName: functionToolDef.name, toolCallId, error },
+                "Function tool execution failed"
               );
-              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;
-              }
+              throw error;
             }
-          });
-          functionTools[toolDef.tool.name] = this.wrapToolWithStreaming(
-            toolDef.tool.name,
-            aiTool,
-            streamRequestId || "",
-            "tool"
-          );
-        }
+          }
+        });
+        functionTools[functionToolDef.name] = this.wrapToolWithStreaming(
+          functionToolDef.name,
+          aiTool,
+          streamRequestId || "",
+          "tool"
+        );
       }
     } catch (error) {
-      logger19.error({ error }, "Failed to load function tools from database");
+      logger18.error({ error }, "Failed to load function tools from database");
     }
     return functionTools;
   }
@@ -7959,7 +8157,7 @@ var Agent = class {
   async getResolvedContext(conversationId, headers) {
     try {
       if (!this.config.contextConfigId) {
-        logger19.debug({ graphId: this.config.graphId }, "No context config found for graph");
+        logger18.debug({ graphId: this.config.graphId }, "No context config found for graph");
         return null;
       }
       const contextConfig = await agentsCore.getContextConfigById(dbClient_default)({
@@ -7971,7 +8169,7 @@ var Agent = class {
         id: this.config.contextConfigId
       });
       if (!contextConfig) {
-        logger19.warn({ contextConfigId: this.config.contextConfigId }, "Context config not found");
+        logger18.warn({ contextConfigId: this.config.contextConfigId }, "Context config not found");
         return null;
       }
       if (!this.contextResolver) {
@@ -7988,7 +8186,7 @@ var Agent = class {
         $now: (/* @__PURE__ */ new Date()).toISOString(),
         $env: process.env
       };
-      logger19.debug(
+      logger18.debug(
         {
           conversationId,
           contextConfigId: contextConfig.id,
@@ -8002,7 +8200,7 @@ var Agent = class {
       );
       return contextWithBuiltins;
     } catch (error) {
-      logger19.error(
+      logger18.error(
         {
           conversationId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -8026,7 +8224,7 @@ var Agent = class {
       });
       return graphDefinition?.graphPrompt || void 0;
     } catch (error) {
-      logger19.warn(
+      logger18.warn(
         {
           graphId: this.config.graphId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -8051,11 +8249,11 @@ var Agent = class {
       if (!graphDefinition) {
         return false;
       }
-      return Object.values(graphDefinition.agents).some(
-        (agent) => "artifactComponents" in agent && agent.artifactComponents && agent.artifactComponents.length > 0
+      return Object.values(graphDefinition.subAgents).some(
+        (subAgent) => "artifactComponents" in subAgent && subAgent.artifactComponents && subAgent.artifactComponents.length > 0
       );
     } catch (error) {
-      logger19.warn(
+      logger18.warn(
         {
           graphId: this.config.graphId,
           tenantId: this.config.tenantId,
@@ -8084,7 +8282,7 @@ var Agent = class {
           preserveUnresolved: false
         });
       } catch (error) {
-        logger19.error(
+        logger18.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -8131,7 +8329,7 @@ var Agent = class {
           preserveUnresolved: false
         });
       } catch (error) {
-        logger19.error(
+        logger18.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -8146,7 +8344,7 @@ var Agent = class {
     const functionTools = await this.getFunctionTools(streamRequestId || "");
     const relationTools = this.getRelationTools(runtimeContext);
     const allTools = { ...mcpTools, ...functionTools, ...relationTools };
-    logger19.info(
+    logger18.info(
       {
         mcpTools: Object.keys(mcpTools),
         functionTools: Object.keys(functionTools),
@@ -8185,7 +8383,7 @@ var Agent = class {
           preserveUnresolved: false
         });
       } catch (error) {
-        logger19.error(
+        logger18.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -8218,7 +8416,7 @@ var Agent = class {
         toolCallId: z6.z.string().describe("The tool call ID associated with this artifact.")
       }),
       execute: async ({ artifactId, toolCallId }) => {
-        logger19.info({ artifactId, toolCallId }, "get_artifact_full executed");
+        logger18.info({ artifactId, toolCallId }, "get_artifact_full executed");
         const streamRequestId = this.getStreamRequestId();
         const artifactService = graphSessionManager.getArtifactService(streamRequestId);
         if (!artifactService) {
@@ -8252,7 +8450,7 @@ var Agent = class {
     });
   }
   // Provide a default tool set that is always available to the agent.
-  async getDefaultTools(_sessionId, streamRequestId) {
+  async getDefaultTools(streamRequestId) {
     const defaultTools = {};
     if (await this.graphHasArtifactComponents()) {
       defaultTools.get_reference_artifact = this.getArtifactTools();
@@ -8478,7 +8676,7 @@ var Agent = class {
       };
       return enhanced;
     } catch (error) {
-      logger19.warn({ error }, "Failed to enhance tool result with structure hints");
+      logger18.warn({ error }, "Failed to enhance tool result with structure hints");
       return result;
     }
   }
@@ -8493,7 +8691,7 @@ var Agent = class {
         }
       });
     } catch (error) {
-      logger19.error(
+      logger18.error(
         { error, graphId: this.config.graphId },
         "Failed to check graph artifact components"
       );
@@ -8538,7 +8736,7 @@ var Agent = class {
                 // Thinking prompt without data components
                 this.getFunctionTools(sessionId, streamRequestId),
                 Promise.resolve(this.getRelationTools(runtimeContext, sessionId)),
-                this.getDefaultTools(sessionId, streamRequestId)
+                this.getDefaultTools(streamRequestId)
               ]);
               childSpan.setStatus({ code: api.SpanStatusCode.OK });
               return result;
@@ -8578,7 +8776,7 @@ var Agent = class {
               currentMessage: userMessage,
               options: historyConfig,
               filters: {
-                agentId: this.config.id,
+                subAgentId: this.config.id,
                 taskId
               }
             });
@@ -8594,7 +8792,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) {
-          logger19.warn(
+          logger18.warn(
             {
               requestedTimeout: modelSettings.maxDuration * 1e3,
               appliedTimeout: timeoutMs,
@@ -8636,7 +8834,7 @@ var Agent = class {
                     }
                   );
                 } catch (error) {
-                  logger19.debug({ error }, "Failed to track agent reasoning");
+                  logger18.debug({ error }, "Failed to track agent reasoning");
                 }
               }
               if (last && "toolCalls" in last && last.toolCalls) {
@@ -8663,7 +8861,7 @@ var Agent = class {
             projectId: session?.projectId,
             artifactComponents: this.artifactComponents,
             streamRequestId: this.getStreamRequestId(),
-            agentId: this.config.id
+            subAgentId: this.config.id
           };
           const parser = new IncrementalStreamParser(
             streamHelper,
@@ -8708,6 +8906,16 @@ var Agent = class {
               }))
             };
           }
+          const streamedContent = parser.getAllStreamedContent();
+          if (streamedContent.length > 0) {
+            response.streamedContent = {
+              parts: streamedContent.map((part) => ({
+                kind: part.kind,
+                ...part.kind === "text" && { text: part.text },
+                ...part.kind === "data" && { data: part.data }
+              }))
+            };
+          }
         } else {
           let genConfig;
           if (hasStructuredOutput) {
@@ -8740,7 +8948,7 @@ var Agent = class {
                     }
                   );
                 } catch (error) {
-                  logger19.debug({ error }, "Failed to track agent reasoning");
+                  logger18.debug({ error }, "Failed to track agent reasoning");
                 }
               }
               if (last && "toolCalls" in last && last.toolCalls) {
@@ -8912,7 +9120,7 @@ ${output}${structureHintsFormatted}`;
                 projectId: session?.projectId,
                 artifactComponents: this.artifactComponents,
                 streamRequestId: this.getStreamRequestId(),
-                agentId: this.config.id
+                subAgentId: this.config.id
               };
               const parser = new IncrementalStreamParser(
                 streamHelper,
@@ -8995,7 +9203,7 @@ ${output}${structureHintsFormatted}`;
             contextId,
             artifactComponents: this.artifactComponents,
             streamRequestId: this.getStreamRequestId(),
-            agentId: this.config.id
+            subAgentId: this.config.id
           });
           if (response.object) {
             formattedContent = await responseFormatter.formatObjectResponse(
@@ -9032,7 +9240,7 @@ ${output}${structureHintsFormatted}`;
 };
 
 // src/agents/generateTaskHandler.ts
-var logger20 = agentsCore.getLogger("generateTaskHandler");
+var logger19 = agentsCore.getLogger("generateTaskHandler");
 var createTaskHandler = (config, credentialStoreRegistry) => {
   return async (task) => {
     try {
@@ -9058,14 +9266,14 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
             projectId: config.projectId,
             graphId: config.graphId
           },
-          agentId: config.agentId
+          subAgentId: config.subAgentId
         }),
         agentsCore.getToolsForAgent(dbClient_default)({
           scopes: {
             tenantId: config.tenantId,
             projectId: config.projectId,
             graphId: config.graphId,
-            agentId: config.agentId
+            subAgentId: config.subAgentId
           }
         }),
         agentsCore.getDataComponentsForAgent(dbClient_default)({
@@ -9073,7 +9281,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
             tenantId: config.tenantId,
             projectId: config.projectId,
             graphId: config.graphId,
-            agentId: config.agentId
+            subAgentId: config.subAgentId
           }
         }),
         agentsCore.getArtifactComponentsForAgent(dbClient_default)({
@@ -9081,21 +9289,21 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
             tenantId: config.tenantId,
             projectId: config.projectId,
             graphId: config.graphId,
-            agentId: config.agentId
+            subAgentId: config.subAgentId
           }
         })
       ]);
-      logger20.info({ toolsForAgent, internalRelations, externalRelations }, "agent stuff");
+      logger19.info({ toolsForAgent, internalRelations, externalRelations }, "agent stuff");
       const enhancedInternalRelations = await Promise.all(
         internalRelations.map(async (relation) => {
           try {
-            const relatedAgent = await agentsCore.getAgentById(dbClient_default)({
+            const relatedAgent = await agentsCore.getSubAgentById(dbClient_default)({
               scopes: {
                 tenantId: config.tenantId,
                 projectId: config.projectId,
                 graphId: config.graphId
               },
-              agentId: relation.id
+              subAgentId: relation.id
             });
             if (relatedAgent) {
               const relatedAgentRelations = await agentsCore.getRelatedAgentsForGraph(dbClient_default)({
@@ -9104,7 +9312,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
                   projectId: config.projectId,
                   graphId: config.graphId
                 },
-                agentId: relation.id
+                subAgentId: relation.id
               });
               const enhancedDescription = generateDescriptionWithTransfers(
                 relation.description || "",
@@ -9114,7 +9322,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
               return { ...relation, description: enhancedDescription };
             }
           } catch (error) {
-            logger20.warn({ agentId: relation.id, error }, "Failed to enhance agent description");
+            logger19.warn({ subAgentId: relation.id, error }, "Failed to enhance agent description");
           }
           return relation;
         })
@@ -9129,7 +9337,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
       ) ?? [];
       const agent = new Agent(
         {
-          id: config.agentId,
+          id: config.subAgentId,
           tenantId: config.tenantId,
           projectId: config.projectId,
           graphId: config.graphId,
@@ -9140,7 +9348,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
           agentPrompt,
           models: models || void 0,
           stopWhen: stopWhen || void 0,
-          agentRelations: enhancedInternalRelations.map((relation) => ({
+          subAgentRelations: enhancedInternalRelations.map((relation) => ({
             id: relation.id,
             tenantId: config.tenantId,
             projectId: config.projectId,
@@ -9151,7 +9359,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
             description: relation.description,
             agentPrompt: "",
             delegateRelations: [],
-            agentRelations: [],
+            subAgentRelations: [],
             transferRelations: []
           })),
           transferRelations: enhancedInternalRelations.filter((relation) => relation.relationType === "transfer").map((relation) => ({
@@ -9165,7 +9373,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
             description: relation.description,
             agentPrompt: "",
             delegateRelations: [],
-            agentRelations: [],
+            subAgentRelations: [],
             transferRelations: []
           })),
           delegateRelations: [
@@ -9183,7 +9391,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
                 description: relation.description,
                 agentPrompt: "",
                 delegateRelations: [],
-                agentRelations: [],
+                subAgentRelations: [],
                 transferRelations: []
               }
             })),
@@ -9218,11 +9426,11 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
         const taskIdMatch = task.id.match(/^task_([^-]+-[^-]+-\d+)-/);
         if (taskIdMatch) {
           contextId = taskIdMatch[1];
-          logger20.info(
+          logger19.info(
             {
               taskId: task.id,
               extractedContextId: contextId,
-              agentId: config.agentId
+              subAgentId: config.subAgentId
             },
             "Extracted contextId from task ID for delegation"
           );
@@ -9234,8 +9442,8 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
       const isDelegation = task.context?.metadata?.isDelegation === true;
       agent.setDelegationStatus(isDelegation);
       if (isDelegation) {
-        logger20.info(
-          { agentId: config.agentId, taskId: task.id },
+        logger19.info(
+          { subAgentId: config.subAgentId, taskId: task.id },
           "Delegated agent - streaming disabled"
         );
         if (streamRequestId && config.tenantId && config.projectId) {
@@ -9332,13 +9540,13 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
   };
 };
 var createTaskHandlerConfig = async (params) => {
-  const agent = await agentsCore.getAgentById(dbClient_default)({
+  const agent = await agentsCore.getSubAgentById(dbClient_default)({
     scopes: {
       tenantId: params.tenantId,
       projectId: params.projectId,
       graphId: params.graphId
     },
-    agentId: params.agentId
+    subAgentId: params.subAgentId
   });
   const agentGraph = await agentsCore.getAgentGraphById(dbClient_default)({
     scopes: {
@@ -9348,7 +9556,7 @@ var createTaskHandlerConfig = async (params) => {
     }
   });
   if (!agent) {
-    throw new Error(`Agent not found: ${params.agentId}`);
+    throw new Error(`Agent not found: ${params.subAgentId}`);
   }
   const effectiveModels = await resolveModelConfig(params.graphId, agent);
   const effectiveConversationHistoryConfig = agent.conversationHistoryConfig || { mode: "full" };
@@ -9356,7 +9564,7 @@ var createTaskHandlerConfig = async (params) => {
     tenantId: params.tenantId,
     projectId: params.projectId,
     graphId: params.graphId,
-    agentId: params.agentId,
+    subAgentId: params.subAgentId,
     agentSchema: {
       id: agent.id,
       name: agent.name,
@@ -9385,25 +9593,27 @@ async function hydrateGraph({
   apiKey
 }) {
   try {
-    if (!dbGraph.defaultAgentId) {
+    if (!dbGraph.defaultSubAgentId) {
       throw new Error(`Graph ${dbGraph.id} does not have a default agent configured`);
     }
-    const defaultAgent = await agentsCore.getAgentById(dbClient_default)({
+    const defaultSubAgent = await agentsCore.getSubAgentById(dbClient_default)({
       scopes: {
         tenantId: dbGraph.tenantId,
         projectId: dbGraph.projectId,
         graphId: dbGraph.id
       },
-      agentId: dbGraph.defaultAgentId
+      subAgentId: dbGraph.defaultSubAgentId
     });
-    if (!defaultAgent) {
-      throw new Error(`Default agent ${dbGraph.defaultAgentId} not found for graph ${dbGraph.id}`);
+    if (!defaultSubAgent) {
+      throw new Error(
+        `Default agent ${dbGraph.defaultSubAgentId} not found for graph ${dbGraph.id}`
+      );
     }
     const taskHandlerConfig = await createTaskHandlerConfig({
       tenantId: dbGraph.tenantId,
       projectId: dbGraph.projectId,
       graphId: dbGraph.id,
-      agentId: dbGraph.defaultAgentId,
+      subAgentId: dbGraph.defaultSubAgentId,
       baseUrl,
       apiKey
     });
@@ -9432,7 +9642,7 @@ async function hydrateGraph({
       }
     };
     return {
-      agentId: dbGraph.id,
+      subAgentId: dbGraph.id,
       // Use graph ID as agent ID for A2A purposes
       tenantId: dbGraph.tenantId,
       projectId: dbGraph.projectId,
@@ -9459,7 +9669,7 @@ async function getRegisteredGraph(executionContext) {
 init_dbClient();
 init_logger();
 var app = new zodOpenapi.OpenAPIHono();
-var logger21 = agentsCore.getLogger("agents");
+var logger20 = agentsCore.getLogger("agents");
 app.openapi(
   zodOpenapi.createRoute({
     method: "get",
@@ -9497,7 +9707,7 @@ app.openapi(
       tracestate: c.req.header("tracestate"),
       baggage: c.req.header("baggage")
     };
-    logger21.info(
+    logger20.info(
       {
         otelHeaders,
         path: c.req.path,
@@ -9506,22 +9716,22 @@ app.openapi(
       "OpenTelemetry headers: well-known agent.json"
     );
     const executionContext = agentsCore.getRequestExecutionContext(c);
-    const { tenantId, projectId, graphId, agentId } = executionContext;
+    const { tenantId, projectId, graphId, subAgentId } = executionContext;
     console.dir("executionContext", executionContext);
-    if (agentId) {
-      logger21.info(
+    if (subAgentId) {
+      logger20.info(
         {
           message: "getRegisteredAgent (agent-level)",
           tenantId,
           projectId,
           graphId,
-          agentId
+          subAgentId
         },
         "agent-level well-known agent.json"
       );
       const credentialStores = c.get("credentialStores");
       const agent = await getRegisteredAgent(executionContext, credentialStores);
-      logger21.info({ agent }, "agent registered: well-known agent.json");
+      logger20.info({ agent }, "agent registered: well-known agent.json");
       if (!agent) {
         throw agentsCore.createApiError({
           code: "not_found",
@@ -9530,7 +9740,7 @@ app.openapi(
       }
       return c.json(agent.agentCard);
     } else {
-      logger21.info(
+      logger20.info(
         {
           message: "getRegisteredGraph (graph-level)",
           tenantId,
@@ -9556,7 +9766,7 @@ app.post("/a2a", async (c) => {
     tracestate: c.req.header("tracestate"),
     baggage: c.req.header("baggage")
   };
-  logger21.info(
+  logger20.info(
     {
       otelHeaders,
       path: c.req.path,
@@ -9565,15 +9775,15 @@ app.post("/a2a", async (c) => {
     "OpenTelemetry headers: a2a"
   );
   const executionContext = agentsCore.getRequestExecutionContext(c);
-  const { tenantId, projectId, graphId, agentId } = executionContext;
-  if (agentId) {
-    logger21.info(
+  const { tenantId, projectId, graphId, subAgentId } = executionContext;
+  if (subAgentId) {
+    logger20.info(
       {
         message: "a2a (agent-level)",
         tenantId,
         projectId,
         graphId,
-        agentId
+        subAgentId
       },
       "agent-level a2a endpoint"
     );
@@ -9591,7 +9801,7 @@ app.post("/a2a", async (c) => {
     }
     return a2aHandler(c, agent);
   } else {
-    logger21.info(
+    logger20.info(
       {
         message: "a2a (graph-level)",
         tenantId,
@@ -9600,7 +9810,7 @@ app.post("/a2a", async (c) => {
       },
       "graph-level a2a endpoint"
     );
-    const graph = await agentsCore.getAgentGraphWithDefaultAgent(dbClient_default)({
+    const graph = await agentsCore.getAgentGraphWithDefaultSubAgent(dbClient_default)({
       scopes: { tenantId, projectId, graphId }
     });
     if (!graph) {
@@ -9613,7 +9823,7 @@ app.post("/a2a", async (c) => {
         404
       );
     }
-    if (!graph.defaultAgentId) {
+    if (!graph.defaultSubAgentId) {
       return c.json(
         {
           jsonrpc: "2.0",
@@ -9623,10 +9833,10 @@ app.post("/a2a", async (c) => {
         400
       );
     }
-    executionContext.agentId = graph.defaultAgentId;
+    executionContext.subAgentId = graph.defaultSubAgentId;
     const credentialStores = c.get("credentialStores");
-    const defaultAgent = await getRegisteredAgent(executionContext, credentialStores);
-    if (!defaultAgent) {
+    const defaultSubAgent = await getRegisteredAgent(executionContext, credentialStores);
+    if (!defaultSubAgent) {
       return c.json(
         {
           jsonrpc: "2.0",
@@ -9636,7 +9846,7 @@ app.post("/a2a", async (c) => {
         404
       );
     }
-    return a2aHandler(c, defaultAgent);
+    return a2aHandler(c, defaultSubAgent);
   }
 });
 var agents_default = app;
@@ -9647,20 +9857,20 @@ init_dbClient();
 // src/a2a/transfer.ts
 init_dbClient();
 init_logger();
-var logger22 = agentsCore.getLogger("Transfer");
+var logger21 = agentsCore.getLogger("Transfer");
 async function executeTransfer({
   tenantId,
   threadId,
   projectId,
-  targetAgentId
+  targetSubAgentId
 }) {
-  logger22.info({ targetAgent: targetAgentId }, "Executing transfer to agent");
+  logger21.info({ targetAgent: targetSubAgentId }, "Executing transfer to agent");
   await agentsCore.setActiveAgentForThread(dbClient_default)({
     scopes: { tenantId, projectId },
     threadId,
-    agentId: targetAgentId
+    subAgentId: targetSubAgentId
   });
-  return { success: true, targetAgentId };
+  return { success: true, targetSubAgentId };
 }
 function isTransferResponse(result) {
   return result?.artifacts.some(
@@ -10240,7 +10450,7 @@ function createMCPStreamHelper() {
 }
 
 // src/handlers/executionHandler.ts
-var logger23 = agentsCore.getLogger("ExecutionHandler");
+var logger22 = agentsCore.getLogger("ExecutionHandler");
 var ExecutionHandler = class {
   constructor() {
     // Hardcoded error limit - separate from configurable stopWhen
@@ -10276,7 +10486,7 @@ var ExecutionHandler = class {
     if (emitOperations) {
       graphSessionManager.enableEmitOperations(requestId2);
     }
-    logger23.info(
+    logger22.info(
       { sessionId: requestId2, graphId, conversationId, emitOperations },
       "Created GraphSession for message execution"
     );
@@ -10291,7 +10501,7 @@ var ExecutionHandler = class {
         );
       }
     } catch (error) {
-      logger23.error(
+      logger22.error(
         {
           error: error instanceof Error ? error.message : "Unknown error",
           stack: error instanceof Error ? error.stack : void 0
@@ -10307,7 +10517,7 @@ var ExecutionHandler = class {
     try {
       await sseHelper.writeOperation(agentInitializingOp(requestId2, graphId));
       const taskId = `task_${conversationId}-${requestId2}`;
-      logger23.info(
+      logger22.info(
         { taskId, currentAgentId, conversationId, requestId: requestId2 },
         "Attempting to create or reuse existing task"
       );
@@ -10317,7 +10527,7 @@ var ExecutionHandler = class {
           tenantId,
           projectId,
           graphId,
-          agentId: currentAgentId,
+          subAgentId: currentAgentId,
           contextId: conversationId,
           status: "pending",
           metadata: {
@@ -10331,7 +10541,7 @@ var ExecutionHandler = class {
             agent_id: currentAgentId
           }
         });
-        logger23.info(
+        logger22.info(
           {
             taskId,
             createdTaskMetadata: Array.isArray(task) ? task[0]?.metadata : task?.metadata
@@ -10340,27 +10550,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") {
-          logger23.info(
+          logger22.info(
             { taskId, error: error.message },
             "Task already exists, fetching existing task"
           );
           const existingTask = await agentsCore.getTask(dbClient_default)({ id: taskId });
           if (existingTask) {
             task = existingTask;
-            logger23.info(
+            logger22.info(
               { taskId, existingTask },
               "Successfully reused existing task from race condition"
             );
           } else {
-            logger23.error({ taskId, error }, "Task constraint failed but task not found");
+            logger22.error({ taskId, error }, "Task constraint failed but task not found");
             throw error;
           }
         } else {
-          logger23.error({ taskId, error }, "Failed to create task due to non-constraint error");
+          logger22.error({ taskId, error }, "Failed to create task due to non-constraint error");
           throw error;
         }
       }
-      logger23.debug(
+      logger22.debug(
         {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           executionType: "create_initial_task",
@@ -10378,7 +10588,7 @@ var ExecutionHandler = class {
       const maxTransfers = graphConfig?.stopWhen?.transferCountIs ?? 10;
       while (iterations < maxTransfers) {
         iterations++;
-        logger23.info(
+        logger22.info(
           { iterations, currentAgentId, graphId, conversationId, fromAgentId },
           `Execution loop iteration ${iterations} with agent ${currentAgentId}, transfer from: ${fromAgentId || "none"}`
         );
@@ -10386,10 +10596,10 @@ var ExecutionHandler = class {
           scopes: { tenantId, projectId },
           conversationId
         });
-        logger23.info({ activeAgent }, "activeAgent");
-        if (activeAgent && activeAgent.activeAgentId !== currentAgentId) {
-          currentAgentId = activeAgent.activeAgentId;
-          logger23.info({ currentAgentId }, `Updated current agent to: ${currentAgentId}`);
+        logger22.info({ activeAgent }, "activeAgent");
+        if (activeAgent && activeAgent.activeSubAgentId !== currentAgentId) {
+          currentAgentId = activeAgent.activeSubAgentId;
+          logger22.info({ currentAgentId }, `Updated current agent to: ${currentAgentId}`);
         }
         const agentBaseUrl = `${baseUrl}/agents`;
         const a2aClient = new A2AClient(agentBaseUrl, {
@@ -10430,13 +10640,13 @@ var ExecutionHandler = class {
         });
         if (!messageResponse?.result) {
           errorCount++;
-          logger23.error(
+          logger22.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`;
-            logger23.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
+            logger22.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
             await sseHelper.writeOperation(errorOp(errorMessage2, currentAgentId || "system"));
             if (task) {
               await agentsCore.updateTask(dbClient_default)({
@@ -10459,20 +10669,20 @@ var ExecutionHandler = class {
         }
         if (isTransferResponse(messageResponse.result)) {
           const transferResponse = messageResponse.result;
-          const targetAgentId = transferResponse.artifacts?.[0]?.parts?.[0]?.data?.targetAgentId;
+          const targetSubAgentId = transferResponse.artifacts?.[0]?.parts?.[0]?.data?.targetSubAgentId;
           const transferReason = transferResponse.artifacts?.[0]?.parts?.[1]?.text;
-          logger23.info({ targetAgentId, transferReason }, "transfer response");
+          logger22.info({ targetSubAgentId, transferReason }, "transfer response");
           currentMessage = `<transfer_context> ${transferReason} </transfer_context>`;
-          const { success, targetAgentId: newAgentId } = await executeTransfer({
+          const { success, targetSubAgentId: newAgentId } = await executeTransfer({
             projectId,
             tenantId,
             threadId: conversationId,
-            targetAgentId
+            targetSubAgentId
           });
           if (success) {
             fromAgentId = currentAgentId;
             currentAgentId = newAgentId;
-            logger23.info(
+            logger22.info(
               {
                 transferFrom: fromAgentId,
                 transferTo: currentAgentId,
@@ -10483,14 +10693,27 @@ var ExecutionHandler = class {
           }
           continue;
         }
-        const responseParts = messageResponse.result.artifacts?.flatMap(
-          (artifact) => artifact.parts || []
-        ) || [];
+        let responseParts = [];
+        if (messageResponse.result.streamedContent?.parts) {
+          responseParts = messageResponse.result.streamedContent.parts;
+          logger22.info(
+            { partsCount: responseParts.length },
+            "Using streamed content for conversation history"
+          );
+        } else {
+          responseParts = messageResponse.result.artifacts?.flatMap(
+            (artifact) => artifact.parts || []
+          ) || [];
+          logger22.info(
+            { partsCount: responseParts.length },
+            "Using artifacts for conversation history (fallback)"
+          );
+        }
         if (responseParts && responseParts.length > 0) {
           const graphSessionData = graphSessionManager.getSession(requestId2);
           if (graphSessionData) {
             const sessionSummary = graphSessionData.getSummary();
-            logger23.info(sessionSummary, "GraphSession data after completion");
+            logger22.info(sessionSummary, "GraphSession data after completion");
           }
           let textContent = "";
           for (const part of responseParts) {
@@ -10522,8 +10745,7 @@ var ExecutionHandler = class {
                 },
                 visibility: "user-facing",
                 messageType: "chat",
-                agentId: currentAgentId,
-                fromAgentId: currentAgentId,
+                fromSubAgentId: currentAgentId,
                 taskId: task.id
               });
               const updateTaskStart = Date.now();
@@ -10544,22 +10766,22 @@ var ExecutionHandler = class {
                 }
               });
               const updateTaskEnd = Date.now();
-              logger23.info(
+              logger22.info(
                 { duration: updateTaskEnd - updateTaskStart },
                 "Completed updateTask operation"
               );
               await sseHelper.writeOperation(completionOp(currentAgentId, iterations));
               await sseHelper.complete();
-              logger23.info({}, "Ending GraphSession and cleaning up");
+              logger22.info({}, "Ending GraphSession and cleaning up");
               graphSessionManager.endSession(requestId2);
-              logger23.info({}, "Cleaning up streamHelper");
+              logger22.info({}, "Cleaning up streamHelper");
               unregisterStreamHelper(requestId2);
               let response;
               if (sseHelper instanceof MCPStreamHelper) {
                 const captured = sseHelper.getCapturedResponse();
                 response = captured.text || "No response content";
               }
-              logger23.info({}, "ExecutionHandler returning success");
+              logger22.info({}, "ExecutionHandler returning success");
               return { success: true, iterations, response };
             } catch (error) {
               agentsCore.setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
@@ -10570,13 +10792,13 @@ var ExecutionHandler = class {
           });
         }
         errorCount++;
-        logger23.warn(
+        logger22.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`;
-          logger23.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
+          logger22.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
           await sseHelper.writeOperation(errorOp(errorMessage2, currentAgentId || "system"));
           if (task) {
             await agentsCore.updateTask(dbClient_default)({
@@ -10597,7 +10819,7 @@ var ExecutionHandler = class {
         }
       }
       const errorMessage = `Maximum transfer limit (${maxTransfers}) reached without completion`;
-      logger23.error({ maxTransfers, iterations }, errorMessage);
+      logger22.error({ maxTransfers, iterations }, errorMessage);
       await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || "system"));
       if (task) {
         await agentsCore.updateTask(dbClient_default)({
@@ -10616,7 +10838,7 @@ var ExecutionHandler = class {
       unregisterStreamHelper(requestId2);
       return { success: false, error: errorMessage, iterations };
     } catch (error) {
-      logger23.error({ error }, "Error in execution handler");
+      logger22.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")
@@ -10644,7 +10866,7 @@ var ExecutionHandler = class {
 // src/routes/chat.ts
 init_logger();
 var app2 = new zodOpenapi.OpenAPIHono();
-var logger24 = agentsCore.getLogger("completionsHandler");
+var logger23 = agentsCore.getLogger("completionsHandler");
 var chatCompletionsRoute = zodOpenapi.createRoute({
   method: "post",
   path: "/completions",
@@ -10762,7 +10984,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
     tracestate: c.req.header("tracestate"),
     baggage: c.req.header("baggage")
   };
-  logger24.info(
+  logger23.info(
     {
       otelHeaders,
       path: c.req.path,
@@ -10786,20 +11008,20 @@ app2.openapi(chatCompletionsRoute, async (c) => {
       scopes: { tenantId, projectId, graphId }
     });
     let agentGraph;
-    let defaultAgentId;
+    let defaultSubAgentId;
     if (fullGraph) {
       agentGraph = {
         id: fullGraph.id,
         name: fullGraph.name,
         tenantId,
         projectId,
-        defaultAgentId: fullGraph.defaultAgentId
+        defaultSubAgentId: fullGraph.defaultSubAgentId
       };
-      const agentKeys = Object.keys(fullGraph.agents || {});
+      const agentKeys = Object.keys(fullGraph.subAgents || {});
       const firstAgentId = agentKeys.length > 0 ? agentKeys[0] : "";
-      defaultAgentId = fullGraph.defaultAgentId || firstAgentId;
+      defaultSubAgentId = fullGraph.defaultSubAgentId || firstAgentId;
     } else {
-      agentGraph = await agentsCore.getAgentGraphWithDefaultAgent(dbClient_default)({
+      agentGraph = await agentsCore.getAgentGraphWithDefaultSubAgent(dbClient_default)({
         scopes: { tenantId, projectId, graphId }
       });
       if (!agentGraph) {
@@ -10808,9 +11030,9 @@ app2.openapi(chatCompletionsRoute, async (c) => {
           message: "Agent graph not found"
         });
       }
-      defaultAgentId = agentGraph.defaultAgentId || "";
+      defaultSubAgentId = agentGraph.defaultSubAgentId || "";
     }
-    if (!defaultAgentId) {
+    if (!defaultSubAgentId) {
       throw agentsCore.createApiError({
         code: "not_found",
         message: "No default agent found in graph"
@@ -10820,7 +11042,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
       tenantId,
       projectId,
       id: conversationId,
-      activeAgentId: defaultAgentId
+      activeSubAgentId: defaultSubAgentId
     });
     const activeAgent = await agentsCore.getActiveAgentForConversation(dbClient_default)({
       scopes: { tenantId, projectId },
@@ -10830,13 +11052,13 @@ app2.openapi(chatCompletionsRoute, async (c) => {
       agentsCore.setActiveAgentForConversation(dbClient_default)({
         scopes: { tenantId, projectId },
         conversationId,
-        agentId: defaultAgentId
+        subAgentId: defaultSubAgentId
       });
     }
-    const agentId = activeAgent?.activeAgentId || defaultAgentId;
-    const agentInfo = await agentsCore.getAgentById(dbClient_default)({
+    const subAgentId = activeAgent?.activeSubAgentId || defaultSubAgentId;
+    const agentInfo = await agentsCore.getSubAgentById(dbClient_default)({
       scopes: { tenantId, projectId, graphId },
-      agentId
+      subAgentId
     });
     if (!agentInfo) {
       throw agentsCore.createApiError({
@@ -10855,14 +11077,14 @@ app2.openapi(chatCompletionsRoute, async (c) => {
       dbClient: dbClient_default,
       credentialStores
     });
-    logger24.info(
+    logger23.info(
       {
         tenantId,
         projectId,
         graphId,
         conversationId,
-        defaultAgentId,
-        activeAgentId: activeAgent?.activeAgentId || "none",
+        defaultSubAgentId,
+        activeSubAgentId: activeAgent?.activeSubAgentId || "none",
         hasContextConfig: !!agentGraph.contextConfigId,
         hasHeaders: !!body.headers,
         hasValidatedContext: !!validatedContext,
@@ -10903,7 +11125,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
       try {
         const sseHelper = createSSEStreamHelper(stream2, requestId2, timestamp);
         await sseHelper.writeRole();
-        logger24.info({ agentId }, "Starting execution");
+        logger23.info({ subAgentId }, "Starting execution");
         const emitOperationsHeader = c.req.header("x-emit-operations");
         const emitOperations = emitOperationsHeader === "true";
         const executionHandler = new ExecutionHandler();
@@ -10911,12 +11133,12 @@ app2.openapi(chatCompletionsRoute, async (c) => {
           executionContext,
           conversationId,
           userMessage,
-          initialAgentId: agentId,
+          initialAgentId: subAgentId,
           requestId: requestId2,
           sseHelper,
           emitOperations
         });
-        logger24.info(
+        logger23.info(
           { result },
           `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
         );
@@ -10930,7 +11152,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
         }
         await sseHelper.complete();
       } catch (error) {
-        logger24.error(
+        logger23.error(
           {
             error: error instanceof Error ? error.message : error,
             stack: error instanceof Error ? error.stack : void 0
@@ -10947,12 +11169,12 @@ app2.openapi(chatCompletionsRoute, async (c) => {
           );
           await sseHelper.complete();
         } catch (streamError) {
-          logger24.error({ streamError }, "Failed to write error to stream");
+          logger23.error({ streamError }, "Failed to write error to stream");
         }
       }
     });
   } catch (error) {
-    logger24.error(
+    logger23.error(
       {
         error: error instanceof Error ? error.message : error,
         stack: error instanceof Error ? error.stack : void 0
@@ -10980,7 +11202,7 @@ var chat_default = app2;
 init_dbClient();
 init_logger();
 var app3 = new zodOpenapi.OpenAPIHono();
-var logger25 = agentsCore.getLogger("chatDataStream");
+var logger24 = agentsCore.getLogger("chatDataStream");
 var chatDataStreamRoute = zodOpenapi.createRoute({
   method: "post",
   path: "/chat",
@@ -11045,7 +11267,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
         "project.id": projectId
       });
     }
-    const agentGraph = await agentsCore.getAgentGraphWithDefaultAgent(dbClient_default)({
+    const agentGraph = await agentsCore.getAgentGraphWithDefaultSubAgent(dbClient_default)({
       scopes: { tenantId, projectId, graphId }
     });
     if (!agentGraph) {
@@ -11054,9 +11276,9 @@ app3.openapi(chatDataStreamRoute, async (c) => {
         message: "Agent graph not found"
       });
     }
-    const defaultAgentId = agentGraph.defaultAgentId;
+    const defaultSubAgentId = agentGraph.defaultSubAgentId;
     const graphName = agentGraph.name;
-    if (!defaultAgentId) {
+    if (!defaultSubAgentId) {
       throw agentsCore.createApiError({
         code: "bad_request",
         message: "Graph does not have a default agent configured"
@@ -11070,13 +11292,13 @@ app3.openapi(chatDataStreamRoute, async (c) => {
       agentsCore.setActiveAgentForConversation(dbClient_default)({
         scopes: { tenantId, projectId },
         conversationId,
-        agentId: defaultAgentId
+        subAgentId: defaultSubAgentId
       });
     }
-    const agentId = activeAgent?.activeAgentId || defaultAgentId;
-    const agentInfo = await agentsCore.getAgentById(dbClient_default)({
+    const subAgentId = activeAgent?.activeSubAgentId || defaultSubAgentId;
+    const agentInfo = await agentsCore.getSubAgentById(dbClient_default)({
       scopes: { tenantId, projectId, graphId },
-      agentId
+      subAgentId
     });
     if (!agentInfo) {
       throw agentsCore.createApiError({
@@ -11097,7 +11319,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("") || "";
-    logger25.info({ userText, lastUserMessage }, "userText");
+    logger24.info({ userText, lastUserMessage }, "userText");
     const messageSpan = api.trace.getActiveSpan();
     if (messageSpan) {
       messageSpan.setAttributes({
@@ -11133,7 +11355,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
             executionContext,
             conversationId,
             userMessage: userText,
-            initialAgentId: agentId,
+            initialAgentId: subAgentId,
             requestId: `chatds-${Date.now()}`,
             sseHelper: streamHelper,
             emitOperations
@@ -11142,7 +11364,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
             await streamHelper.writeOperation(errorOp("Unable to process request", "system"));
           }
         } catch (err) {
-          logger25.error({ err }, "Streaming error");
+          logger24.error({ err }, "Streaming error");
           await streamHelper.writeOperation(errorOp("Internal server error", "system"));
         } finally {
           if ("cleanup" in streamHelper && typeof streamHelper.cleanup === "function") {
@@ -11163,7 +11385,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
       )
     );
   } catch (error) {
-    logger25.error({ error }, "chatDataStream error");
+    logger24.error({ error }, "chatDataStream error");
     throw agentsCore.createApiError({
       code: "internal_server_error",
       message: "Failed to process chat completion"
@@ -11178,7 +11400,7 @@ init_logger();
 function createMCPSchema(schema) {
   return schema;
 }
-var logger26 = agentsCore.getLogger("mcp");
+var logger25 = agentsCore.getLogger("mcp");
 var _MockResponseSingleton = class _MockResponseSingleton {
   constructor() {
     __publicField(this, "mockRes");
@@ -11233,21 +11455,21 @@ var createSpoofInitMessage = (mcpProtocolVersion) => ({
   id: 0
 });
 var spoofTransportInitialization = async (transport, req, sessionId, mcpProtocolVersion) => {
-  logger26.info({ sessionId }, "Spoofing initialization message to set transport state");
+  logger25.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);
-    logger26.info({ sessionId }, "Successfully spoofed initialization");
+    logger25.info({ sessionId }, "Successfully spoofed initialization");
   } catch (spoofError) {
-    logger26.warn({ sessionId, error: spoofError }, "Spoof initialization failed, continuing anyway");
+    logger25.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"];
-  logger26.info({ sessionId }, "Received MCP session ID");
+  logger25.info({ sessionId }, "Received MCP session ID");
   if (!sessionId) {
-    logger26.info({ body }, "Missing session ID");
+    logger25.info({ body }, "Missing session ID");
     res.writeHead(400).end(
       JSON.stringify({
         jsonrpc: "2.0",
@@ -11273,7 +11495,7 @@ var validateSession = async (req, res, body, tenantId, projectId, graphId) => {
     scopes: { tenantId, projectId },
     conversationId: sessionId
   });
-  logger26.info(
+  logger25.info(
     {
       sessionId,
       conversationFound: !!conversation,
@@ -11284,7 +11506,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) {
-    logger26.info(
+    logger25.info(
       { sessionId, conversationId: conversation?.id },
       "MCP session not found or invalid"
     );
@@ -11333,7 +11555,7 @@ var processUserMessage = async (tenantId, projectId, conversationId, query) => {
     messageType: "chat"
   });
 };
-var executeAgentQuery = async (executionContext, conversationId, query, defaultAgentId) => {
+var executeAgentQuery = async (executionContext, conversationId, query, defaultSubAgentId) => {
   const requestId2 = `mcp-${Date.now()}`;
   const mcpStreamHelper = createMCPStreamHelper();
   const executionHandler = new ExecutionHandler();
@@ -11341,11 +11563,11 @@ var executeAgentQuery = async (executionContext, conversationId, query, defaultA
     executionContext,
     conversationId,
     userMessage: query,
-    initialAgentId: defaultAgentId,
+    initialAgentId: defaultSubAgentId,
     requestId: requestId2,
     sseHelper: mcpStreamHelper
   });
-  logger26.info(
+  logger25.info(
     { result },
     `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
   );
@@ -11372,7 +11594,7 @@ var executeAgentQuery = async (executionContext, conversationId, query, defaultA
 var getServer = async (headers, executionContext, conversationId, credentialStores) => {
   const { tenantId, projectId, graphId } = executionContext;
   setupTracing(conversationId, tenantId, graphId);
-  const agentGraph = await agentsCore.getAgentGraphWithDefaultAgent(dbClient_default)({
+  const agentGraph = await agentsCore.getAgentGraphWithDefaultSubAgent(dbClient_default)({
     scopes: { tenantId, projectId, graphId }
   });
   if (!agentGraph) {
@@ -11393,7 +11615,7 @@ var getServer = async (headers, executionContext, conversationId, credentialStor
     },
     async ({ query }) => {
       try {
-        if (!agentGraph.defaultAgentId) {
+        if (!agentGraph.defaultSubAgentId) {
           return {
             content: [
               {
@@ -11404,10 +11626,10 @@ var getServer = async (headers, executionContext, conversationId, credentialStor
             isError: true
           };
         }
-        const defaultAgentId = agentGraph.defaultAgentId;
-        const agentInfo = await agentsCore.getAgentById(dbClient_default)({
+        const defaultSubAgentId = agentGraph.defaultSubAgentId;
+        const agentInfo = await agentsCore.getSubAgentById(dbClient_default)({
           scopes: { tenantId, projectId, graphId },
-          agentId: defaultAgentId
+          subAgentId: defaultSubAgentId
         });
         if (!agentInfo) {
           return {
@@ -11429,7 +11651,7 @@ var getServer = async (headers, executionContext, conversationId, credentialStor
           dbClient: dbClient_default,
           credentialStores
         });
-        logger26.info(
+        logger25.info(
           {
             tenantId,
             projectId,
@@ -11442,7 +11664,7 @@ var getServer = async (headers, executionContext, conversationId, credentialStor
           "parameters"
         );
         await processUserMessage(tenantId, projectId, conversationId, query);
-        return executeAgentQuery(executionContext, conversationId, query, defaultAgentId);
+        return executeAgentQuery(executionContext, conversationId, query, defaultSubAgentId);
       } catch (error) {
         return {
           content: [
@@ -11491,9 +11713,9 @@ var validateRequestParameters = (c) => {
 };
 var handleInitializationRequest = async (body, executionContext, validatedContext, req, res, c, credentialStores) => {
   const { tenantId, projectId, graphId } = executionContext;
-  logger26.info({ body }, "Received initialization request");
+  logger25.info({ body }, "Received initialization request");
   const sessionId = agentsCore.getConversationId();
-  const agentGraph = await agentsCore.getAgentGraphWithDefaultAgent(dbClient_default)({
+  const agentGraph = await agentsCore.getAgentGraphWithDefaultSubAgent(dbClient_default)({
     scopes: { tenantId, projectId, graphId }
   });
   if (!agentGraph) {
@@ -11506,7 +11728,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
       { status: 404 }
     );
   }
-  if (!agentGraph.defaultAgentId) {
+  if (!agentGraph.defaultSubAgentId) {
     return c.json(
       {
         jsonrpc: "2.0",
@@ -11520,7 +11742,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
     id: sessionId,
     tenantId,
     projectId,
-    activeAgentId: agentGraph.defaultAgentId,
+    activeSubAgentId: agentGraph.defaultSubAgentId,
     metadata: {
       sessionData: {
         graphId,
@@ -11531,7 +11753,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
       }
     }
   });
-  logger26.info(
+  logger25.info(
     { sessionId, conversationId: conversation.id },
     "Created MCP session as conversation"
   );
@@ -11540,9 +11762,9 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
   });
   const server = await getServer(validatedContext, executionContext, sessionId, credentialStores);
   await server.connect(transport);
-  logger26.info({ sessionId }, "Server connected for initialization");
+  logger25.info({ sessionId }, "Server connected for initialization");
   res.setHeader("Mcp-Session-Id", sessionId);
-  logger26.info(
+  logger25.info(
     {
       sessionId,
       bodyMethod: body?.method,
@@ -11551,7 +11773,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
     "About to handle initialization request"
   );
   await transport.handleRequest(req, res, body);
-  logger26.info({ sessionId }, "Successfully handled initialization request");
+  logger25.info({ sessionId }, "Successfully handled initialization request");
   return fetchToNode.toFetchResponse(res);
 };
 var handleExistingSessionRequest = async (body, executionContext, validatedContext, req, res, credentialStores) => {
@@ -11579,8 +11801,8 @@ var handleExistingSessionRequest = async (body, executionContext, validatedConte
     sessionId,
     conversation.metadata?.session_data?.mcpProtocolVersion
   );
-  logger26.info({ sessionId }, "Server connected and transport initialized");
-  logger26.info(
+  logger25.info({ sessionId }, "Server connected and transport initialized");
+  logger25.info(
     {
       sessionId,
       bodyKeys: Object.keys(body || {}),
@@ -11594,9 +11816,9 @@ var handleExistingSessionRequest = async (body, executionContext, validatedConte
   );
   try {
     await transport.handleRequest(req, res, body);
-    logger26.info({ sessionId }, "Successfully handled MCP request");
+    logger25.info({ sessionId }, "Successfully handled MCP request");
   } catch (transportError) {
-    logger26.error(
+    logger25.error(
       {
         sessionId,
         error: transportError,
@@ -11647,13 +11869,13 @@ app4.openapi(
       }
       const { executionContext } = paramValidation;
       const body = c.get("requestBody") || {};
-      logger26.info({ body, bodyKeys: Object.keys(body || {}) }, "Parsed request body");
+      logger25.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");
-      logger26.info({ validatedContext }, "Validated context");
-      logger26.info({ req }, "request");
+      logger25.info({ validatedContext }, "Validated context");
+      logger25.info({ req }, "request");
       if (isInitRequest) {
         return await handleInitializationRequest(
           body,
@@ -11675,7 +11897,7 @@ app4.openapi(
         );
       }
     } catch (e) {
-      logger26.error(
+      logger25.error(
         {
           error: e instanceof Error ? e.message : e,
           stack: e instanceof Error ? e.stack : void 0
@@ -11687,7 +11909,7 @@ app4.openapi(
   }
 );
 app4.get("/", async (c) => {
-  logger26.info({}, "Received GET MCP request");
+  logger25.info({}, "Received GET MCP request");
   return c.json(
     {
       jsonrpc: "2.0",
@@ -11701,7 +11923,7 @@ app4.get("/", async (c) => {
   );
 });
 app4.delete("/", async (c) => {
-  logger26.info({}, "Received DELETE MCP request");
+  logger25.info({}, "Received DELETE MCP request");
   return c.json(
     {
       jsonrpc: "2.0",
@@ -11714,7 +11936,7 @@ app4.delete("/", async (c) => {
 var mcp_default = app4;
 
 // src/app.ts
-var logger27 = agentsCore.getLogger("agents-run-api");
+var logger26 = agentsCore.getLogger("agents-run-api");
 function createExecutionHono(serverConfig, credentialStores) {
   const app6 = new zodOpenapi.OpenAPIHono();
   app6.use("*", otel.otel());
@@ -11730,7 +11952,7 @@ function createExecutionHono(serverConfig, credentialStores) {
         const body = await c.req.json();
         c.set("requestBody", body);
       } catch (error) {
-        logger27.debug({ error }, "Failed to parse JSON body, continuing without parsed body");
+        logger26.debug({ error }, "Failed to parse JSON body, continuing without parsed body");
       }
     }
     return next();
@@ -11781,8 +12003,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 (logger27) {
-          logger27.error(
+        if (logger26) {
+          logger26.error(
             {
               error: err,
               message: errorMessage,
@@ -11794,8 +12016,8 @@ function createExecutionHono(serverConfig, credentialStores) {
           );
         }
       } else {
-        if (logger27) {
-          logger27.error(
+        if (logger26) {
+          logger26.error(
             {
               error: err,
               path: c.req.path,
@@ -11812,8 +12034,8 @@ function createExecutionHono(serverConfig, credentialStores) {
         const response = err.getResponse();
         return response;
       } catch (responseError) {
-        if (logger27) {
-          logger27.error({ error: responseError }, "Error while handling HTTPException response");
+        if (logger26) {
+          logger26.error({ error: responseError }, "Error while handling HTTPException response");
         }
       }
     }
@@ -11847,7 +12069,7 @@ function createExecutionHono(serverConfig, credentialStores) {
   app6.use("*", async (c, next) => {
     const executionContext = c.get("executionContext");
     if (!executionContext) {
-      logger27.debug({}, "Empty execution context");
+      logger26.debug({}, "Empty execution context");
       return next();
     }
     const { tenantId, projectId, graphId } = executionContext;
@@ -11856,7 +12078,7 @@ function createExecutionHono(serverConfig, credentialStores) {
     if (requestBody) {
       conversationId = requestBody.conversationId;
       if (!conversationId) {
-        logger27.debug({ requestBody }, "No conversation ID found in request body");
+        logger26.debug({ requestBody }, "No conversation ID found in request body");
       }
     }
     const entries = Object.fromEntries(
@@ -11871,7 +12093,7 @@ function createExecutionHono(serverConfig, credentialStores) {
       })
     );
     if (!Object.keys(entries).length) {
-      logger27.debug({}, "Empty entries for baggage");
+      logger26.debug({}, "Empty entries for baggage");
       return next();
     }
     const bag = Object.entries(entries).reduce(