@inkeep/agents-run-api 0.14.16 → 0.16.0

package/dist/index.cjs

@@ -3,8 +3,13 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var agentsCore = require('@inkeep/agents-core');
-var z5 = require('zod');
+var z6 = require('zod');
 var nanoid = require('nanoid');
+var child_process = require('child_process');
+var crypto = require('crypto');
+var fs = require('fs');
+var os = require('os');
+var path = require('path');
 var otel = require('@hono/otel');
 var zodOpenapi = require('@hono/zod-openapi');
 var api = require('@opentelemetry/api');
@@ -31,6 +36,7 @@ var google = require('@ai-sdk/google');
 var openai = require('@ai-sdk/openai');
 var aiSdkProvider = require('@openrouter/ai-sdk-provider');
 var jmespath = require('jmespath');
+var Ajv = require('ajv');
 var destr = require('destr');
 var traverse = require('traverse');
 var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
@@ -40,8 +46,9 @@ var fetchToNode = require('fetch-to-node');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var z5__default = /*#__PURE__*/_interopDefault(z5);
+var z6__default = /*#__PURE__*/_interopDefault(z6);
 var jmespath__default = /*#__PURE__*/_interopDefault(jmespath);
+var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
 var destr__default = /*#__PURE__*/_interopDefault(destr);
 var traverse__default = /*#__PURE__*/_interopDefault(traverse);
 
@@ -60,27 +67,27 @@ var envSchema, parseEnv, env;
 var init_env = __esm({
   "src/env.ts"() {
     agentsCore.loadEnvironmentFiles();
-    envSchema = z5.z.object({
-      NODE_ENV: z5.z.enum(["development", "production", "test"]).optional(),
-      ENVIRONMENT: z5.z.enum(["development", "production", "pentest", "test"]).optional().default("development"),
-      DB_FILE_NAME: z5.z.string().optional(),
-      TURSO_DATABASE_URL: z5.z.string().optional(),
-      TURSO_AUTH_TOKEN: z5.z.string().optional(),
-      AGENTS_RUN_API_URL: z5.z.string().optional().default("http://localhost:3003"),
-      LOG_LEVEL: z5.z.enum(["trace", "debug", "info", "warn", "error"]).optional().default("debug"),
-      NANGO_SECRET_KEY: z5.z.string().optional(),
-      OPENAI_API_KEY: z5.z.string().optional(),
-      ANTHROPIC_API_KEY: z5.z.string(),
-      INKEEP_AGENTS_RUN_API_BYPASS_SECRET: z5.z.string().optional(),
-      OTEL_BSP_SCHEDULE_DELAY: z5.z.coerce.number().optional().default(500),
-      OTEL_BSP_MAX_EXPORT_BATCH_SIZE: z5.z.coerce.number().optional().default(64)
+    envSchema = z6.z.object({
+      NODE_ENV: z6.z.enum(["development", "production", "test"]).optional(),
+      ENVIRONMENT: z6.z.enum(["development", "production", "pentest", "test"]).optional().default("development"),
+      DB_FILE_NAME: z6.z.string().optional(),
+      TURSO_DATABASE_URL: z6.z.string().optional(),
+      TURSO_AUTH_TOKEN: z6.z.string().optional(),
+      AGENTS_RUN_API_URL: z6.z.string().optional().default("http://localhost:3003"),
+      LOG_LEVEL: z6.z.enum(["trace", "debug", "info", "warn", "error"]).optional().default("debug"),
+      NANGO_SECRET_KEY: z6.z.string().optional(),
+      OPENAI_API_KEY: z6.z.string().optional(),
+      ANTHROPIC_API_KEY: z6.z.string(),
+      INKEEP_AGENTS_RUN_API_BYPASS_SECRET: z6.z.string().optional(),
+      OTEL_BSP_SCHEDULE_DELAY: z6.z.coerce.number().optional().default(500),
+      OTEL_BSP_MAX_EXPORT_BATCH_SIZE: z6.z.coerce.number().optional().default(64)
     });
     parseEnv = () => {
       try {
         const parsedEnv = envSchema.parse(process.env);
         return parsedEnv;
       } catch (error) {
-        if (error instanceof z5.z.ZodError) {
+        if (error instanceof z6.z.ZodError) {
           const missingVars = error.issues.map((issue) => issue.path.join("."));
           throw new Error(
             `\u274C Invalid environment variables: ${missingVars.join(", ")}
@@ -345,8 +352,8 @@ async function getConversationScopedArtifacts(params) {
       });
       referenceArtifacts.push(...artifacts);
     }
-    const logger26 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
-    logger26.debug(
+    const logger28 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
+    logger28.debug(
       {
         conversationId,
         visibleMessages: visibleMessages.length,
@@ -358,8 +365,8 @@ async function getConversationScopedArtifacts(params) {
     );
     return referenceArtifacts;
   } catch (error) {
-    const logger26 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
-    logger26.error(
+    const logger28 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
+    logger28.error(
       {
         error: error instanceof Error ? error.message : "Unknown error",
         conversationId
@@ -375,6 +382,326 @@ var init_conversations = __esm({
   }
 });
 
+// src/tools/LocalSandboxExecutor.ts
+var LocalSandboxExecutor_exports = {};
+__export(LocalSandboxExecutor_exports, {
+  LocalSandboxExecutor: () => LocalSandboxExecutor
+});
+var logger18, _LocalSandboxExecutor, LocalSandboxExecutor;
+var init_LocalSandboxExecutor = __esm({
+  "src/tools/LocalSandboxExecutor.ts"() {
+    logger18 = agentsCore.getLogger("local-sandbox-executor");
+    _LocalSandboxExecutor = class _LocalSandboxExecutor {
+      constructor() {
+        __publicField(this, "tempDir");
+        __publicField(this, "sandboxPool", {});
+        __publicField(this, "POOL_TTL", 5 * 60 * 1e3);
+        // 5 minutes
+        __publicField(this, "MAX_USE_COUNT", 50);
+        this.tempDir = path.join(os.tmpdir(), "inkeep-sandboxes");
+        this.ensureTempDir();
+        this.startPoolCleanup();
+      }
+      static getInstance() {
+        if (!_LocalSandboxExecutor.instance) {
+          _LocalSandboxExecutor.instance = new _LocalSandboxExecutor();
+        }
+        return _LocalSandboxExecutor.instance;
+      }
+      ensureTempDir() {
+        try {
+          fs.mkdirSync(this.tempDir, { recursive: true });
+        } catch {
+        }
+      }
+      generateDependencyHash(dependencies) {
+        const sortedDeps = Object.keys(dependencies).sort().map((key) => `${key}@${dependencies[key]}`).join(",");
+        return crypto.createHash("sha256").update(sortedDeps).digest("hex").substring(0, 16);
+      }
+      getCachedSandbox(dependencyHash) {
+        const poolKey = dependencyHash;
+        const sandbox = this.sandboxPool[poolKey];
+        if (sandbox && fs.existsSync(sandbox.sandboxDir)) {
+          const now = Date.now();
+          if (now - sandbox.lastUsed < this.POOL_TTL && sandbox.useCount < this.MAX_USE_COUNT) {
+            sandbox.lastUsed = now;
+            sandbox.useCount++;
+            logger18.debug(
+              {
+                poolKey,
+                useCount: sandbox.useCount,
+                sandboxDir: sandbox.sandboxDir,
+                lastUsed: new Date(sandbox.lastUsed).toISOString()
+              },
+              "Reusing cached sandbox"
+            );
+            return sandbox.sandboxDir;
+          } else {
+            this.cleanupSandbox(sandbox.sandboxDir);
+            delete this.sandboxPool[poolKey];
+          }
+        }
+        return null;
+      }
+      addToPool(dependencyHash, sandboxDir, dependencies) {
+        const poolKey = dependencyHash;
+        if (this.sandboxPool[poolKey]) {
+          this.cleanupSandbox(this.sandboxPool[poolKey].sandboxDir);
+        }
+        this.sandboxPool[poolKey] = {
+          sandboxDir,
+          lastUsed: Date.now(),
+          useCount: 1,
+          dependencies
+        };
+        logger18.debug({ poolKey, sandboxDir }, "Added sandbox to pool");
+      }
+      cleanupSandbox(sandboxDir) {
+        try {
+          fs.rmSync(sandboxDir, { recursive: true, force: true });
+          logger18.debug({ sandboxDir }, "Cleaned up sandbox");
+        } catch (error) {
+          logger18.warn({ sandboxDir, error }, "Failed to clean up sandbox");
+        }
+      }
+      startPoolCleanup() {
+        setInterval(() => {
+          const now = Date.now();
+          const keysToDelete = [];
+          for (const [key, sandbox] of Object.entries(this.sandboxPool)) {
+            if (now - sandbox.lastUsed > this.POOL_TTL || sandbox.useCount >= this.MAX_USE_COUNT) {
+              this.cleanupSandbox(sandbox.sandboxDir);
+              keysToDelete.push(key);
+            }
+          }
+          keysToDelete.forEach((key) => {
+            delete this.sandboxPool[key];
+          });
+          if (keysToDelete.length > 0) {
+            logger18.debug({ cleanedCount: keysToDelete.length }, "Cleaned up expired sandboxes");
+          }
+        }, 6e4);
+      }
+      detectModuleType(executeCode) {
+        const esmPatterns = [
+          /import\s+.*\s+from\s+['"]/g,
+          // import ... from '...'
+          /import\s*\(/g,
+          // import(...)
+          /export\s+(default|const|let|var|function|class)/g,
+          // export statements
+          /export\s*\{/g
+          // export { ... }
+        ];
+        const cjsPatterns = [
+          /require\s*\(/g,
+          // require(...)
+          /module\.exports/g,
+          // module.exports
+          /exports\./g
+          // exports.something
+        ];
+        const hasEsmSyntax = esmPatterns.some((pattern) => pattern.test(executeCode));
+        const hasCjsSyntax = cjsPatterns.some((pattern) => pattern.test(executeCode));
+        if (hasEsmSyntax && hasCjsSyntax) {
+          logger18.warn(
+            { executeCode: `${executeCode.substring(0, 100)}...` },
+            "Both ESM and CommonJS syntax detected, defaulting to ESM"
+          );
+          return "esm";
+        }
+        if (hasEsmSyntax) {
+          return "esm";
+        }
+        if (hasCjsSyntax) {
+          return "cjs";
+        }
+        return "cjs";
+      }
+      async executeFunctionTool(toolId, args, config) {
+        const dependencies = config.dependencies || {};
+        const dependencyHash = this.generateDependencyHash(dependencies);
+        logger18.debug(
+          {
+            toolId,
+            dependencies,
+            dependencyHash,
+            poolSize: Object.keys(this.sandboxPool).length
+          },
+          "Executing function tool"
+        );
+        let sandboxDir = this.getCachedSandbox(dependencyHash);
+        let isNewSandbox = false;
+        if (!sandboxDir) {
+          sandboxDir = path.join(this.tempDir, `sandbox-${dependencyHash}-${Date.now()}`);
+          fs.mkdirSync(sandboxDir, { recursive: true });
+          isNewSandbox = true;
+          logger18.debug(
+            {
+              toolId,
+              dependencyHash,
+              sandboxDir,
+              dependencies
+            },
+            "Creating new sandbox"
+          );
+          const moduleType = this.detectModuleType(config.executeCode);
+          const packageJson = {
+            name: `function-tool-${toolId}`,
+            version: "1.0.0",
+            ...moduleType === "esm" && { type: "module" },
+            dependencies,
+            scripts: {
+              start: moduleType === "esm" ? "node index.mjs" : "node index.js"
+            }
+          };
+          fs.writeFileSync(path.join(sandboxDir, "package.json"), JSON.stringify(packageJson, null, 2), "utf8");
+          if (Object.keys(dependencies).length > 0) {
+            await this.installDependencies(sandboxDir);
+          }
+          this.addToPool(dependencyHash, sandboxDir, dependencies);
+        }
+        try {
+          const moduleType = this.detectModuleType(config.executeCode);
+          const executionCode = this.wrapFunctionCode(config.executeCode, args);
+          const fileExtension = moduleType === "esm" ? "mjs" : "js";
+          fs.writeFileSync(path.join(sandboxDir, `index.${fileExtension}`), executionCode, "utf8");
+          const result = await this.executeInSandbox(
+            sandboxDir,
+            config.sandboxConfig?.timeout || 3e4,
+            moduleType
+          );
+          return result;
+        } catch (error) {
+          if (isNewSandbox) {
+            this.cleanupSandbox(sandboxDir);
+            const poolKey = dependencyHash;
+            delete this.sandboxPool[poolKey];
+          }
+          throw error;
+        }
+      }
+      async installDependencies(sandboxDir) {
+        return new Promise((resolve, reject) => {
+          const npm = child_process.spawn("npm", ["install"], {
+            cwd: sandboxDir,
+            stdio: "pipe"
+          });
+          let stderr = "";
+          npm.stdout?.on("data", () => {
+          });
+          npm.stderr?.on("data", (data) => {
+            stderr += data.toString();
+          });
+          npm.on("close", (code) => {
+            if (code === 0) {
+              logger18.debug({ sandboxDir }, "Dependencies installed successfully");
+              resolve();
+            } else {
+              logger18.error({ sandboxDir, code, stderr }, "Failed to install dependencies");
+              reject(new Error(`npm install failed with code ${code}: ${stderr}`));
+            }
+          });
+          npm.on("error", (err) => {
+            logger18.error({ sandboxDir, error: err }, "Failed to spawn npm install");
+            reject(err);
+          });
+        });
+      }
+      async executeInSandbox(sandboxDir, timeout, moduleType) {
+        return new Promise((resolve, reject) => {
+          const fileExtension = moduleType === "esm" ? "mjs" : "js";
+          const spawnOptions = {
+            cwd: sandboxDir,
+            stdio: "pipe",
+            // Security: drop privileges and limit resources
+            uid: process.getuid ? process.getuid() : void 0,
+            gid: process.getgid ? process.getgid() : void 0
+          };
+          const node = child_process.spawn("node", [`index.${fileExtension}`], spawnOptions);
+          let stdout = "";
+          let stderr = "";
+          let outputSize = 0;
+          const MAX_OUTPUT_SIZE = 1024 * 1024;
+          node.stdout?.on("data", (data) => {
+            const dataStr = data.toString();
+            outputSize += dataStr.length;
+            if (outputSize > MAX_OUTPUT_SIZE) {
+              node.kill("SIGTERM");
+              reject(new Error(`Output size exceeded limit of ${MAX_OUTPUT_SIZE} bytes`));
+              return;
+            }
+            stdout += dataStr;
+          });
+          node.stderr?.on("data", (data) => {
+            const dataStr = data.toString();
+            outputSize += dataStr.length;
+            if (outputSize > MAX_OUTPUT_SIZE) {
+              node.kill("SIGTERM");
+              reject(new Error(`Output size exceeded limit of ${MAX_OUTPUT_SIZE} bytes`));
+              return;
+            }
+            stderr += dataStr;
+          });
+          const timeoutId = setTimeout(() => {
+            logger18.warn({ sandboxDir, timeout }, "Function execution timed out, killing process");
+            node.kill("SIGTERM");
+            setTimeout(() => {
+              try {
+                node.kill("SIGKILL");
+              } catch {
+              }
+            }, 5e3);
+            reject(new Error(`Function execution timed out after ${timeout}ms`));
+          }, timeout);
+          node.on("close", (code, signal) => {
+            clearTimeout(timeoutId);
+            if (code === 0) {
+              try {
+                const result = JSON.parse(stdout);
+                if (result.success) {
+                  resolve(result.result);
+                } else {
+                  reject(new Error(result.error || "Function execution failed"));
+                }
+              } catch (parseError) {
+                logger18.error({ stdout, stderr, parseError }, "Failed to parse function result");
+                reject(new Error(`Invalid function result: ${stdout}`));
+              }
+            } else {
+              const errorMsg = signal ? `Function execution killed by signal ${signal}: ${stderr}` : `Function execution failed with code ${code}: ${stderr}`;
+              logger18.error({ code, signal, stderr }, "Function execution failed");
+              reject(new Error(errorMsg));
+            }
+          });
+          node.on("error", (error) => {
+            clearTimeout(timeoutId);
+            logger18.error({ sandboxDir, error }, "Failed to spawn node process");
+            reject(error);
+          });
+        });
+      }
+      wrapFunctionCode(executeCode, args) {
+        return `
+// Wrapped function execution (ESM)
+const execute = ${executeCode};
+const args = ${JSON.stringify(args)};
+
+execute(args)
+  .then(result => {
+    console.log(JSON.stringify({ success: true, result }));
+  })
+  .catch(error => {
+    console.log(JSON.stringify({ success: false, error: error.message }));
+  });
+`;
+      }
+    };
+    __publicField(_LocalSandboxExecutor, "instance", null);
+    LocalSandboxExecutor = _LocalSandboxExecutor;
+  }
+});
+
 // src/utils/json-postprocessor.ts
 var json_postprocessor_exports = {};
 __export(json_postprocessor_exports, {
@@ -496,7 +823,9 @@ var apiKeyAuth = () => factory.createMiddleware(async (c, next) => {
   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 baseUrl = new URL(c.req.url).origin;
+  const proto = c.req.header("x-forwarded-proto") ?? "http";
+  const host = c.req.header("x-forwarded-host") ?? c.req.header("host");
+  const baseUrl = `${proto}://${host}`;
   if (process.env.ENVIRONMENT === "development" || process.env.ENVIRONMENT === "test") {
     let executionContext;
     if (authHeader?.startsWith("Bearer ")) {
@@ -1394,46 +1723,6 @@ async function getRegisteredAgent(executionContext, credentialStoreRegistry) {
 init_dbClient();
 init_logger();
 
-// src/utils/model-resolver.ts
-init_dbClient();
-async function resolveModelConfig(graphId, agent) {
-  if (agent.models?.base?.model) {
-    return {
-      base: agent.models.base,
-      structuredOutput: agent.models.structuredOutput || agent.models.base,
-      summarizer: agent.models.summarizer || agent.models.base
-    };
-  }
-  const graph = await agentsCore.getAgentGraphById(dbClient_default)({
-    scopes: { tenantId: agent.tenantId, projectId: agent.projectId, graphId }
-  });
-  if (graph?.models?.base?.model) {
-    return {
-      base: graph.models.base,
-      structuredOutput: agent.models?.structuredOutput || graph.models.structuredOutput || graph.models.base,
-      summarizer: agent.models?.summarizer || graph.models.summarizer || graph.models.base
-    };
-  }
-  const project = await agentsCore.getProject(dbClient_default)({
-    scopes: { tenantId: agent.tenantId, projectId: agent.projectId }
-  });
-  if (project?.models?.base?.model) {
-    return {
-      base: project.models.base,
-      structuredOutput: agent.models?.structuredOutput || project.models.structuredOutput || project.models.base,
-      summarizer: agent.models?.summarizer || project.models.summarizer || project.models.base
-    };
-  }
-  throw new Error(
-    "Base model configuration is required. Please configure models at the project level."
-  );
-}
-
-// src/agents/Agent.ts
-init_conversations();
-init_dbClient();
-init_logger();
-
 // src/agents/ModelFactory.ts
 init_logger();
 var logger5 = agentsCore.getLogger("ModelFactory");
@@ -1832,7 +2121,46 @@ var tracer = agentsCore.getTracer("agents-run-api");
 init_logger();
 init_dbClient();
 init_logger();
-var logger7 = agentsCore.getLogger("ArtifactService");
+
+// src/utils/schema-validation.ts
+init_logger();
+agentsCore.getLogger("SchemaValidation");
+new Ajv__default.default({ allErrors: true, strict: false });
+function extractPreviewFields(schema) {
+  const previewProperties = {};
+  if (schema.properties) {
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      if (prop.inPreview === true) {
+        const cleanProp = { ...prop };
+        delete cleanProp.inPreview;
+        previewProperties[key] = cleanProp;
+      }
+    }
+  }
+  return {
+    type: "object",
+    properties: previewProperties,
+    required: schema.required?.filter((field) => previewProperties[field])
+  };
+}
+function extractFullFields(schema) {
+  const fullProperties = {};
+  if (schema.properties) {
+    for (const [key, prop] of Object.entries(schema.properties)) {
+      const cleanProp = { ...prop };
+      delete cleanProp.inPreview;
+      fullProperties[key] = cleanProp;
+    }
+  }
+  return {
+    type: "object",
+    properties: fullProperties,
+    required: schema.required
+  };
+}
+
+// src/services/ArtifactService.ts
+var logger8 = agentsCore.getLogger("ArtifactService");
 var _ArtifactService = class _ArtifactService {
   constructor(context) {
     this.context = context;
@@ -1844,6 +2172,12 @@ var _ArtifactService = class _ArtifactService {
   static clearCaches() {
     _ArtifactService.selectorCache.clear();
   }
+  /**
+   * Update artifact components in the context
+   */
+  updateArtifactComponents(artifactComponents) {
+    this.context.artifactComponents = artifactComponents;
+  }
   /**
    * Get all artifacts for a context from database
    */
@@ -1858,7 +2192,7 @@ var _ArtifactService = class _ArtifactService {
           id: taskId
         });
         if (!task) {
-          logger7.warn({ taskId }, "Task not found when fetching artifacts");
+          logger8.warn({ taskId }, "Task not found when fetching artifacts");
           continue;
         }
         const taskArtifacts = await agentsCore.getLedgerArtifacts(dbClient_default)({
@@ -1876,7 +2210,7 @@ var _ArtifactService = class _ArtifactService {
         }
       }
     } catch (error) {
-      logger7.error({ error, contextId }, "Error loading context artifacts");
+      logger8.error({ error, contextId }, "Error loading context artifacts");
     }
     return artifacts;
   }
@@ -1885,12 +2219,12 @@ var _ArtifactService = class _ArtifactService {
    */
   async createArtifact(request, agentId) {
     if (!this.context.sessionId) {
-      logger7.warn({ request }, "No session ID available for artifact creation");
+      logger8.warn({ request }, "No session ID available for artifact creation");
       return null;
     }
     const toolResult = toolSessionManager.getToolResult(this.context.sessionId, request.toolCallId);
     if (!toolResult) {
-      logger7.warn(
+      logger8.warn(
         { request, sessionId: this.context.sessionId },
         "Tool result not found for artifact"
       );
@@ -1906,7 +2240,7 @@ var _ArtifactService = class _ArtifactService {
         selectedData = selectedData.length > 0 ? selectedData[0] : {};
       }
       if (!selectedData) {
-        logger7.warn(
+        logger8.warn(
           {
             request,
             baseSelector: request.baseSelector
@@ -1915,8 +2249,26 @@ var _ArtifactService = class _ArtifactService {
         );
         selectedData = {};
       }
-      const summaryData = this.extractProps(selectedData, request.summaryProps || {});
-      let fullData = this.extractProps(selectedData, request.fullProps || {});
+      const component = this.context.artifactComponents?.find((ac) => ac.name === request.type);
+      let summaryData = {};
+      let fullData = {};
+      if (component?.props) {
+        const previewSchema = extractPreviewFields(component.props);
+        const fullSchema = extractFullFields(component.props);
+        summaryData = this.extractPropsFromSchema(
+          selectedData,
+          previewSchema,
+          request.detailsSelector || {}
+        );
+        fullData = this.extractPropsFromSchema(
+          selectedData,
+          fullSchema,
+          request.detailsSelector || {}
+        );
+      } else {
+        summaryData = selectedData;
+        fullData = selectedData;
+      }
       const isFullDataEmpty = !fullData || Object.keys(fullData).length === 0 || Object.values(fullData).every(
         (val) => val === null || val === void 0 || val === "" || Array.isArray(val) && val.length === 0 || typeof val === "object" && Object.keys(val).length === 0
       );
@@ -1925,14 +2277,13 @@ var _ArtifactService = class _ArtifactService {
       }
       const cleanedSummaryData = this.cleanEscapedContent(summaryData);
       const cleanedFullData = this.cleanEscapedContent(fullData);
-      const component = this.context.artifactComponents?.find((ac) => ac.name === request.type);
       const artifactData = {
         artifactId: request.artifactId,
         toolCallId: request.toolCallId,
         name: "Processing...",
         description: "Name and description being generated...",
         type: request.type,
-        artifactSummary: component?.summaryProps ? this.filterBySchema(cleanedSummaryData, component.summaryProps) : cleanedSummaryData
+        data: cleanedSummaryData
       };
       await this.persistArtifact(request, cleanedSummaryData, cleanedFullData, agentId);
       await this.cacheArtifact(
@@ -1943,15 +2294,61 @@ var _ArtifactService = class _ArtifactService {
       );
       return artifactData;
     } catch (error) {
-      logger7.error({ error, request }, "Failed to create artifact");
+      logger8.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}`);
     }
   }
   /**
-   * Get artifact data by ID and tool call ID
+   * Get artifact summary data by ID and tool call ID
    */
-  async getArtifactData(artifactId, toolCallId, artifactMap) {
+  async getArtifactSummary(artifactId, toolCallId, artifactMap) {
+    const key = `${artifactId}:${toolCallId}`;
+    if (this.context.streamRequestId) {
+      const cachedArtifact = await graphSessionManager.getArtifactCache(
+        this.context.streamRequestId,
+        key
+      );
+      if (cachedArtifact) {
+        return this.formatArtifactSummaryData(cachedArtifact, artifactId, toolCallId);
+      }
+    }
+    if (this.createdArtifacts.has(key)) {
+      const cached = this.createdArtifacts.get(key);
+      return this.formatArtifactSummaryData(cached, artifactId, toolCallId);
+    }
+    if (artifactMap?.has(key)) {
+      const artifact = artifactMap.get(key);
+      return this.formatArtifactSummaryData(artifact, artifactId, toolCallId);
+    }
+    try {
+      if (!this.context.projectId || !this.context.taskId) {
+        logger8.warn(
+          { artifactId, toolCallId },
+          "No projectId or taskId available for artifact lookup"
+        );
+        return null;
+      }
+      const artifacts = await agentsCore.getLedgerArtifacts(dbClient_default)({
+        scopes: { tenantId: this.context.tenantId, projectId: this.context.projectId },
+        artifactId,
+        taskId: this.context.taskId
+      });
+      if (artifacts.length > 0) {
+        return this.formatArtifactSummaryData(artifacts[0], artifactId, toolCallId);
+      }
+    } catch (error) {
+      logger8.warn(
+        { artifactId, toolCallId, taskId: this.context.taskId, error },
+        "Failed to fetch artifact"
+      );
+    }
+    return null;
+  }
+  /**
+   * Get artifact full data by ID and tool call ID
+   */
+  async getArtifactFull(artifactId, toolCallId, artifactMap) {
     const key = `${artifactId}:${toolCallId}`;
     if (this.context.streamRequestId) {
       const cachedArtifact = await graphSessionManager.getArtifactCache(
@@ -1959,20 +2356,20 @@ var _ArtifactService = class _ArtifactService {
         key
       );
       if (cachedArtifact) {
-        return this.formatArtifactData(cachedArtifact, artifactId, toolCallId);
+        return this.formatArtifactFullData(cachedArtifact, artifactId, toolCallId);
       }
     }
     if (this.createdArtifacts.has(key)) {
       const cached = this.createdArtifacts.get(key);
-      return this.formatArtifactData(cached, artifactId, toolCallId);
+      return this.formatArtifactFullData(cached, artifactId, toolCallId);
     }
     if (artifactMap?.has(key)) {
       const artifact = artifactMap.get(key);
-      return this.formatArtifactData(artifact, artifactId, toolCallId);
+      return this.formatArtifactFullData(artifact, artifactId, toolCallId);
     }
     try {
       if (!this.context.projectId || !this.context.taskId) {
-        logger7.warn(
+        logger8.warn(
           { artifactId, toolCallId },
           "No projectId or taskId available for artifact lookup"
         );
@@ -1984,10 +2381,10 @@ var _ArtifactService = class _ArtifactService {
         taskId: this.context.taskId
       });
       if (artifacts.length > 0) {
-        return this.formatArtifactData(artifacts[0], artifactId, toolCallId);
+        return this.formatArtifactFullData(artifacts[0], artifactId, toolCallId);
       }
     } catch (error) {
-      logger7.warn(
+      logger8.warn(
         { artifactId, toolCallId, taskId: this.context.taskId, error },
         "Failed to fetch artifact"
       );
@@ -1995,16 +2392,29 @@ var _ArtifactService = class _ArtifactService {
     return null;
   }
   /**
-   * Format raw artifact to standardized data format
+   * Format raw artifact to standardized summary data format
    */
-  formatArtifactData(artifact, artifactId, toolCallId) {
+  formatArtifactSummaryData(artifact, artifactId, toolCallId) {
     return {
       artifactId,
       toolCallId,
       name: artifact.name || "Processing...",
       description: artifact.description || "Name and description being generated...",
       type: artifact.metadata?.artifactType || artifact.artifactType,
-      artifactSummary: artifact.parts?.[0]?.data?.summary || {}
+      data: artifact.parts?.[0]?.data?.summary || {}
+    };
+  }
+  /**
+   * Format raw artifact to standardized full data format
+   */
+  formatArtifactFullData(artifact, artifactId, toolCallId) {
+    return {
+      artifactId,
+      toolCallId,
+      name: artifact.name || "Processing...",
+      description: artifact.description || "Name and description being generated...",
+      type: artifact.metadata?.artifactType || artifact.artifactType,
+      data: artifact.parts?.[0]?.data?.full || {}
     };
   }
   /**
@@ -2022,14 +2432,13 @@ var _ArtifactService = class _ArtifactService {
           taskId: this.context.taskId,
           toolCallId: request.toolCallId,
           artifactType: request.type,
-          summaryProps: summaryData,
-          fullProps: fullData,
+          summaryData,
+          data: fullData,
           agentId: effectiveAgentId,
           metadata: {
             toolCallId: request.toolCallId,
             baseSelector: request.baseSelector,
-            summaryProps: request.summaryProps,
-            fullProps: request.fullProps,
+            detailsSelector: request.detailsSelector,
             sessionId: this.context.sessionId,
             artifactType: request.type
           },
@@ -2040,14 +2449,17 @@ var _ArtifactService = class _ArtifactService {
         }
       );
     } else {
-      logger7.warn({
-        artifactId: request.artifactId,
-        hasStreamRequestId: !!this.context.streamRequestId,
-        hasAgentId: !!effectiveAgentId,
-        hasTaskId: !!this.context.taskId,
-        passedAgentId: agentId,
-        contextAgentId: this.context.agentId
-      }, "Skipping artifact_saved event - missing required context");
+      logger8.warn(
+        {
+          artifactId: request.artifactId,
+          hasStreamRequestId: !!this.context.streamRequestId,
+          hasAgentId: !!effectiveAgentId,
+          hasTaskId: !!this.context.taskId,
+          passedAgentId: agentId,
+          contextAgentId: this.context.agentId
+        },
+        "Skipping artifact_saved event - missing required context"
+      );
     }
   }
   /**
@@ -2057,7 +2469,7 @@ var _ArtifactService = class _ArtifactService {
     const cacheKey = `${artifactId}:${toolCallId}`;
     const artifactForCache = {
       ...artifactData,
-      parts: [{ data: { summary: artifactData.artifactSummary, full: fullData } }],
+      parts: [{ data: { summary: artifactData.data, data: fullData } }],
       metadata: { artifactType: artifactData.type, toolCallId },
       taskId: this.context.taskId
     };
@@ -2098,6 +2510,30 @@ var _ArtifactService = class _ArtifactService {
    * Used by GraphSession to save artifacts after name/description generation
    */
   async saveArtifact(artifact) {
+    let summaryData = artifact.data;
+    let fullData = artifact.data;
+    if (this.context.artifactComponents) {
+      const artifactComponent = this.context.artifactComponents.find(
+        (ac) => ac.name === artifact.type
+      );
+      if (artifactComponent?.props) {
+        try {
+          const schema = artifactComponent.props;
+          const previewSchema = extractPreviewFields(schema);
+          const fullSchema = extractFullFields(schema);
+          summaryData = this.filterBySchema(artifact.data, previewSchema);
+          fullData = this.filterBySchema(artifact.data, fullSchema);
+        } catch (error) {
+          logger8.warn(
+            {
+              artifactType: artifact.type,
+              error: error instanceof Error ? error.message : "Unknown error"
+            },
+            "Failed to extract preview/full fields from schema, using full data for both"
+          );
+        }
+      }
+    }
     const artifactToSave = {
       artifactId: artifact.artifactId,
       name: artifact.name,
@@ -2108,8 +2544,8 @@ var _ArtifactService = class _ArtifactService {
         {
           kind: "data",
           data: {
-            summary: artifact.summaryProps,
-            full: artifact.fullProps
+            summary: summaryData,
+            full: fullData
           }
         }
       ],
@@ -2122,10 +2558,11 @@ var _ArtifactService = class _ArtifactService {
       },
       contextId: this.context.contextId,
       taskId: this.context.taskId,
+      toolCallId: artifact.toolCallId,
       artifact: artifactToSave
     });
     if (!result.created && result.existing) {
-      logger7.debug(
+      logger8.debug(
         {
           artifactId: artifact.artifactId,
           taskId: this.context.taskId
@@ -2178,7 +2615,7 @@ var _ArtifactService = class _ArtifactService {
           extracted[propName] = this.cleanEscapedContent(rawValue);
         }
       } catch (error) {
-        logger7.warn(
+        logger8.warn(
           { propName, selector, error: error instanceof Error ? error.message : "Unknown error" },
           "Failed to extract property"
         );
@@ -2190,6 +2627,39 @@ var _ArtifactService = class _ArtifactService {
     }
     return extracted;
   }
+  /**
+   * Extract properties from data using schema-defined fields and custom selectors
+   */
+  extractPropsFromSchema(item, schema, customSelectors) {
+    const extracted = {};
+    if (schema.properties) {
+      for (const fieldName of Object.keys(schema.properties)) {
+        try {
+          const customSelector = customSelectors[fieldName];
+          let rawValue;
+          if (customSelector) {
+            const sanitizedSelector = this.sanitizeJMESPathSelector(customSelector);
+            rawValue = jmespath__default.default.search(item, sanitizedSelector);
+          } else {
+            rawValue = item[fieldName];
+          }
+          if (rawValue !== null && rawValue !== void 0) {
+            extracted[fieldName] = this.cleanEscapedContent(rawValue);
+          }
+        } catch (error) {
+          logger8.warn(
+            { fieldName, error: error instanceof Error ? error.message : "Unknown error" },
+            "Failed to extract schema field"
+          );
+          const fallbackValue = item[fieldName];
+          if (fallbackValue !== null && fallbackValue !== void 0) {
+            extracted[fieldName] = this.cleanEscapedContent(fallbackValue);
+          }
+        }
+      }
+    }
+    return extracted;
+  }
   /**
    * Filter extracted props based on schema
    */
@@ -2208,15 +2678,19 @@ __publicField(_ArtifactService, "selectorCache", /* @__PURE__ */ new Map());
 var ArtifactService = _ArtifactService;
 
 // src/services/ArtifactParser.ts
-var logger8 = agentsCore.getLogger("ArtifactParser");
+var logger9 = agentsCore.getLogger("ArtifactParser");
 var _ArtifactParser = class _ArtifactParser {
   constructor(tenantId, options) {
     __publicField(this, "artifactService");
-    const context = {
-      tenantId,
-      ...options
-    };
-    this.artifactService = new ArtifactService(context);
+    if (options?.artifactService) {
+      this.artifactService = options.artifactService;
+    } else {
+      const context = {
+        tenantId,
+        ...options
+      };
+      this.artifactService = new ArtifactService(context);
+    }
   }
   /**
    * Check if text contains complete artifact markers (ref or create)
@@ -2292,7 +2766,7 @@ var _ArtifactParser = class _ArtifactParser {
       attrs[key] = value;
     }
     if (!attrs.id || !attrs.tool || !attrs.type || !attrs.base) {
-      logger8.warn({ attrs, attrString }, "Missing required attributes in artifact annotation");
+      logger9.warn({ attrs, attrString }, "Missing required attributes in artifact annotation");
       return null;
     }
     return {
@@ -2300,8 +2774,7 @@ var _ArtifactParser = class _ArtifactParser {
       toolCallId: attrs.tool,
       type: attrs.type,
       baseSelector: attrs.base,
-      summaryProps: attrs.summary || {},
-      fullProps: attrs.full || {}
+      detailsSelector: attrs.details || {}
     };
   }
   /**
@@ -2330,8 +2803,7 @@ var _ArtifactParser = class _ArtifactParser {
       toolCallId: annotation.toolCallId,
       type: annotation.type,
       baseSelector: annotation.baseSelector,
-      summaryProps: annotation.summaryProps,
-      fullProps: annotation.fullProps
+      detailsSelector: annotation.detailsSelector
     };
     return this.artifactService.createArtifact(request, agentId);
   }
@@ -2351,9 +2823,14 @@ var _ArtifactParser = class _ArtifactParser {
         if (artifactData && annotation.raw) {
           createdArtifactData.set(annotation.raw, artifactData);
         } else if (annotation.raw) {
-          failedAnnotations.push(`Failed to create artifact "${annotation.artifactId}": Missing or invalid data`);
+          failedAnnotations.push(
+            `Failed to create artifact "${annotation.artifactId}": Missing or invalid data`
+          );
           processedText = processedText.replace(annotation.raw, "");
-          logger8.warn({ annotation, artifactData }, "Removed failed artifact:create annotation from output");
+          logger9.warn(
+            { annotation, artifactData },
+            "Removed failed artifact:create annotation from output"
+          );
         }
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : "Unknown error";
@@ -2361,14 +2838,17 @@ var _ArtifactParser = class _ArtifactParser {
         if (annotation.raw) {
           processedText = processedText.replace(annotation.raw, "");
         }
-        logger8.error({ annotation, error }, "Failed to extract artifact from create annotation");
+        logger9.error({ annotation, error }, "Failed to extract artifact from create annotation");
       }
     }
     if (failedAnnotations.length > 0) {
-      logger8.warn({
-        failedCount: failedAnnotations.length,
-        failures: failedAnnotations
-      }, "Some artifact creation attempts failed");
+      logger9.warn(
+        {
+          failedCount: failedAnnotations.length,
+          failures: failedAnnotations
+        },
+        "Some artifact creation attempts failed"
+      );
     }
     const parts = [];
     const createRegex = /<artifact:create\s+([^>]+?)(?:\s*\/)?>(?:(.*?)<\/artifact:create>)?/gs;
@@ -2401,7 +2881,17 @@ var _ArtifactParser = class _ArtifactParser {
         artifactData = await this.getArtifactData(artifactId, toolCallId, artifactMap);
       }
       if (artifactData) {
-        parts.push({ kind: "data", data: artifactData });
+        parts.push({
+          kind: "data",
+          data: {
+            artifactId: artifactData.artifactId,
+            toolCallId: artifactData.toolCallId,
+            name: artifactData.name,
+            description: artifactData.description,
+            type: artifactData.type,
+            artifactSummary: artifactData.data
+          }
+        });
       }
       lastIndex = matchStart + fullMatch.length;
     }
@@ -2427,12 +2917,32 @@ var _ArtifactParser = class _ArtifactParser {
             artifactMap
           );
           if (artifactData) {
-            parts.push({ kind: "data", data: artifactData });
+            parts.push({
+              kind: "data",
+              data: {
+                artifactId: artifactData.artifactId,
+                toolCallId: artifactData.toolCallId,
+                name: artifactData.name,
+                description: artifactData.description,
+                type: artifactData.type,
+                artifactSummary: artifactData.data
+              }
+            });
           }
         } else if (this.isArtifactCreateComponent(component)) {
           const createData = await this.extractFromArtifactCreateComponent(component, agentId);
           if (createData) {
-            parts.push({ kind: "data", data: createData });
+            parts.push({
+              kind: "data",
+              data: {
+                artifactId: createData.artifactId,
+                toolCallId: createData.toolCallId,
+                name: createData.name,
+                description: createData.description,
+                type: createData.type,
+                artifactSummary: createData.data
+              }
+            });
           }
         } else {
           parts.push({ kind: "data", data: component });
@@ -2446,11 +2956,35 @@ var _ArtifactParser = class _ArtifactParser {
         obj.props.tool_call_id,
         artifactMap
       );
-      return artifactData ? [{ kind: "data", data: artifactData }] : [];
+      return artifactData ? [
+        {
+          kind: "data",
+          data: {
+            artifactId: artifactData.artifactId,
+            toolCallId: artifactData.toolCallId,
+            name: artifactData.name,
+            description: artifactData.description,
+            type: artifactData.type,
+            artifactSummary: artifactData.data
+          }
+        }
+      ] : [];
     }
     if (this.isArtifactCreateComponent(obj)) {
       const createData = await this.extractFromArtifactCreateComponent(obj, agentId);
-      return createData ? [{ kind: "data", data: createData }] : [];
+      return createData ? [
+        {
+          kind: "data",
+          data: {
+            artifactId: createData.artifactId,
+            toolCallId: createData.toolCallId,
+            name: createData.name,
+            description: createData.description,
+            type: createData.type,
+            artifactSummary: createData.data
+          }
+        }
+      ] : [];
     }
     return [{ kind: "data", data: obj }];
   }
@@ -2479,8 +3013,7 @@ var _ArtifactParser = class _ArtifactParser {
       toolCallId: props.tool_call_id,
       type: props.type,
       baseSelector: props.base_selector,
-      summaryProps: props.summary_props || {},
-      fullProps: props.full_props || {}
+      detailsSelector: props.details_selector || {}
     };
     return await this.extractFromCreateAnnotation(annotation, agentId);
   }
@@ -2488,7 +3021,7 @@ var _ArtifactParser = class _ArtifactParser {
    * Get artifact data - delegates to service
    */
   async getArtifactData(artifactId, toolCallId, artifactMap) {
-    return this.artifactService.getArtifactData(artifactId, toolCallId, artifactMap);
+    return await this.artifactService.getArtifactSummary(artifactId, toolCallId, artifactMap);
   }
 };
 // Shared regex patterns - support both single and double quotes
@@ -2522,9 +3055,9 @@ __publicField(_ArtifactParser, "INCOMPLETE_CREATE_REGEX", /<artifact:create(?![^
 var ArtifactParser = _ArtifactParser;
 
 // src/services/GraphSession.ts
-var logger9 = agentsCore.getLogger("GraphSession");
+var logger10 = agentsCore.getLogger("GraphSession");
 var GraphSession = class {
-  // Session-scoped ArtifactParser instance
+  // Whether to send data operations
   constructor(sessionId, messageId, graphId, tenantId, projectId, contextId) {
     this.sessionId = sessionId;
     this.messageId = messageId;
@@ -2553,7 +3086,9 @@ var GraphSession = class {
     __publicField(this, "artifactService");
     // Session-scoped ArtifactService instance
     __publicField(this, "artifactParser");
-    logger9.debug({ sessionId, messageId, graphId }, "GraphSession created");
+    // Session-scoped ArtifactParser instance
+    __publicField(this, "isEmitOperations", false);
+    logger10.debug({ sessionId, messageId, graphId }, "GraphSession created");
     if (tenantId && projectId) {
       toolSessionManager.createSessionWithId(
         sessionId,
@@ -2577,10 +3112,84 @@ var GraphSession = class {
         sessionId,
         contextId,
         taskId: `task_${contextId}-${messageId}`,
-        streamRequestId: sessionId
+        streamRequestId: sessionId,
+        artifactService: this.artifactService
+        // Pass the shared ArtifactService
       });
     }
   }
+  /**
+   * Enable emit operations to send data operations
+   */
+  enableEmitOperations() {
+    this.isEmitOperations = true;
+    logger10.info(
+      { sessionId: this.sessionId },
+      "\u{1F50D} DEBUG: Emit operations enabled for GraphSession"
+    );
+  }
+  /**
+   * Send data operation to stream when emit operations is enabled
+   */
+  async sendDataOperation(event) {
+    try {
+      const streamHelper = getStreamHelper(this.sessionId);
+      if (streamHelper) {
+        const formattedOperation = {
+          type: event.eventType,
+          label: this.generateEventLabel(event),
+          details: {
+            timestamp: event.timestamp,
+            agentId: event.agentId,
+            data: event.data
+          }
+        };
+        await streamHelper.writeOperation(formattedOperation);
+      }
+    } catch (error) {
+      logger10.error(
+        {
+          sessionId: this.sessionId,
+          eventType: event.eventType,
+          error: error instanceof Error ? error.message : error
+        },
+        "\u274C DEBUG: Failed to send data operation"
+      );
+    }
+  }
+  /**
+   * Generate human-readable labels for events
+   */
+  generateEventLabel(event) {
+    switch (event.eventType) {
+      case "agent_generate":
+        return `Agent ${event.agentId} 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"}`;
+      }
+      default:
+        return `${event.eventType} event`;
+    }
+  }
   /**
    * Initialize status updates for this session
    */
@@ -2601,7 +3210,7 @@ var GraphSession = class {
     if (this.statusUpdateState.config.timeInSeconds) {
       this.statusUpdateTimer = setInterval(async () => {
         if (!this.statusUpdateState || this.isEnded) {
-          logger9.debug(
+          logger10.debug(
             { sessionId: this.sessionId },
             "Timer triggered but session already cleaned up or ended"
           );
@@ -2613,7 +3222,7 @@ var GraphSession = class {
         }
         await this.checkAndSendTimeBasedUpdate();
       }, this.statusUpdateState.config.timeInSeconds * 1e3);
-      logger9.info(
+      logger10.info(
         {
           sessionId: this.sessionId,
           intervalMs: this.statusUpdateState.config.timeInSeconds * 1e3
@@ -2626,8 +3235,16 @@ var GraphSession = class {
    * Record an event in the session and trigger status updates if configured
    */
   recordEvent(eventType, agentId, data) {
+    if (this.isEmitOperations) {
+      this.sendDataOperation({
+        timestamp: Date.now(),
+        eventType,
+        agentId,
+        data
+      });
+    }
     if (this.isEnded) {
-      logger9.debug(
+      logger10.debug(
         {
           sessionId: this.sessionId,
           eventType,
@@ -2647,7 +3264,7 @@ var GraphSession = class {
     if (eventType === "artifact_saved" && data.pendingGeneration) {
       const artifactId = data.artifactId;
       if (this.pendingArtifacts.size >= this.MAX_PENDING_ARTIFACTS) {
-        logger9.warn(
+        logger10.warn(
           {
             sessionId: this.sessionId,
             artifactId,
@@ -2669,7 +3286,7 @@ var GraphSession = class {
           this.artifactProcessingErrors.set(artifactId, errorCount);
           if (errorCount >= this.MAX_ARTIFACT_RETRIES) {
             this.pendingArtifacts.delete(artifactId);
-            logger9.error(
+            logger10.error(
               {
                 sessionId: this.sessionId,
                 artifactId,
@@ -2681,7 +3298,7 @@ var GraphSession = class {
               "Artifact processing failed after max retries, giving up"
             );
           } else {
-            logger9.warn(
+            logger10.warn(
               {
                 sessionId: this.sessionId,
                 artifactId,
@@ -2703,14 +3320,14 @@ var GraphSession = class {
    */
   checkStatusUpdates() {
     if (this.isEnded) {
-      logger9.debug(
+      logger10.debug(
         { sessionId: this.sessionId },
         "Session has ended - skipping status update check"
       );
       return;
     }
     if (!this.statusUpdateState) {
-      logger9.debug({ sessionId: this.sessionId }, "No status update state - skipping check");
+      logger10.debug({ sessionId: this.sessionId }, "No status update state - skipping check");
       return;
     }
     const statusUpdateState = this.statusUpdateState;
@@ -2721,11 +3338,11 @@ var GraphSession = class {
    */
   async checkAndSendTimeBasedUpdate() {
     if (this.isEnded) {
-      logger9.debug({ sessionId: this.sessionId }, "Session has ended - skipping time-based update");
+      logger10.debug({ sessionId: this.sessionId }, "Session has ended - skipping time-based update");
       return;
     }
     if (!this.statusUpdateState) {
-      logger9.debug(
+      logger10.debug(
         { sessionId: this.sessionId },
         "No status updates configured for time-based check"
       );
@@ -2738,7 +3355,7 @@ var GraphSession = class {
     try {
       await this.generateAndSendUpdate();
     } catch (error) {
-      logger9.error(
+      logger10.error(
         {
           sessionId: this.sessionId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -2841,29 +3458,29 @@ var GraphSession = class {
    */
   async generateAndSendUpdate() {
     if (this.isEnded) {
-      logger9.debug({ sessionId: this.sessionId }, "Session has ended - not generating update");
+      logger10.debug({ sessionId: this.sessionId }, "Session has ended - not generating update");
       return;
     }
     if (this.isTextStreaming) {
-      logger9.debug(
+      logger10.debug(
         { sessionId: this.sessionId },
         "Text is currently streaming - skipping status update"
       );
       return;
     }
     if (this.isGeneratingUpdate) {
-      logger9.debug(
+      logger10.debug(
         { sessionId: this.sessionId },
         "Update already in progress - skipping duplicate generation"
       );
       return;
     }
     if (!this.statusUpdateState) {
-      logger9.warn({ sessionId: this.sessionId }, "No status update state - cannot generate update");
+      logger10.warn({ sessionId: this.sessionId }, "No status update state - cannot generate update");
       return;
     }
     if (!this.graphId) {
-      logger9.warn({ sessionId: this.sessionId }, "No graph ID - cannot generate update");
+      logger10.warn({ sessionId: this.sessionId }, "No graph ID - cannot generate update");
       return;
     }
     const newEventCount = this.events.length - this.statusUpdateState.lastEventCount;
@@ -2875,7 +3492,7 @@ var GraphSession = class {
     try {
       const streamHelper = getStreamHelper(this.sessionId);
       if (!streamHelper) {
-        logger9.warn(
+        logger10.warn(
           { sessionId: this.sessionId },
           "No stream helper found - cannot send status update"
         );
@@ -2895,7 +3512,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) {
-            logger9.warn(
+            logger10.warn(
               {
                 sessionId: this.sessionId,
                 summary
@@ -2932,7 +3549,7 @@ var GraphSession = class {
         this.statusUpdateState.lastEventCount = this.events.length;
       }
     } catch (error) {
-      logger9.error(
+      logger10.error(
         {
           sessionId: this.sessionId,
           error: error instanceof Error ? error.message : "Unknown error",
@@ -2970,7 +3587,7 @@ var GraphSession = class {
           this.releaseUpdateLock();
         }
       } catch (error) {
-        logger9.error(
+        logger10.error(
           {
             sessionId: this.sessionId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -3048,7 +3665,7 @@ User's Question/Context:
 ${conversationHistory}
 ` : "";
             } catch (error) {
-              logger9.warn(
+              logger10.warn(
                 { sessionId: this.sessionId, error },
                 "Failed to fetch conversation history for structured status update"
               );
@@ -3058,13 +3675,13 @@ ${conversationHistory}
 Previous updates sent to user:
 ${previousSummaries.map((s, i) => `${i + 1}. ${s}`).join("\n")}
 ` : "";
-          const selectionSchema = z5.z.object(
+          const selectionSchema = z6.z.object(
             Object.fromEntries([
               // Add no_relevant_updates schema
               [
                 "no_relevant_updates",
-                z5.z.object({
-                  no_updates: z5.z.boolean().default(true)
+                z6.z.object({
+                  no_updates: z6.z.boolean().default(true)
                 }).optional().describe(
                   "Use when nothing substantially new to report. Should only use on its own."
                 )
@@ -3182,7 +3799,7 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
           return { summaries };
         } catch (error) {
           agentsCore.setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
-          logger9.error({ error }, "Failed to generate structured update, using fallback");
+          logger10.error({ error }, "Failed to generate structured update, using fallback");
           return { summaries: [] };
         } finally {
           span.end();
@@ -3197,8 +3814,8 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
     if (component.detailsSchema && "properties" in component.detailsSchema) {
       return this.buildZodSchemaFromJson(component.detailsSchema);
     }
-    return z5.z.object({
-      label: z5.z.string().describe(
+    return z6.z.object({
+      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 ACTUAL finding or result, not the action. What specific information was discovered? (e.g., "Slack requires OAuth 2.0 setup", "Found 5 integration methods", "API rate limit is 100/minute"). Include the actual detail or insight, not just that you searched or processed. 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.'
       )
     });
@@ -3208,56 +3825,56 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
    */
   buildZodSchemaFromJson(jsonSchema) {
     const properties = {};
-    properties["label"] = z5.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)) {
       let zodType;
       if (value.enum && Array.isArray(value.enum)) {
         if (value.enum.length === 1) {
-          zodType = z5.z.literal(value.enum[0]);
+          zodType = z6.z.literal(value.enum[0]);
         } else {
           const [first, ...rest] = value.enum;
-          zodType = z5.z.enum([first, ...rest]);
+          zodType = z6.z.enum([first, ...rest]);
         }
       } else if (value.type === "string") {
-        zodType = z5.z.string();
+        zodType = z6.z.string();
         if (value.minLength) zodType = zodType.min(value.minLength);
         if (value.maxLength) zodType = zodType.max(value.maxLength);
         if (value.format === "email") zodType = zodType.email();
         if (value.format === "url" || value.format === "uri")
           zodType = zodType.url();
       } else if (value.type === "number" || value.type === "integer") {
-        zodType = value.type === "integer" ? z5.z.number().int() : z5.z.number();
+        zodType = value.type === "integer" ? z6.z.number().int() : z6.z.number();
         if (value.minimum !== void 0) zodType = zodType.min(value.minimum);
         if (value.maximum !== void 0) zodType = zodType.max(value.maximum);
       } else if (value.type === "boolean") {
-        zodType = z5.z.boolean();
+        zodType = z6.z.boolean();
       } else if (value.type === "array") {
         if (value.items) {
           if (value.items.enum && Array.isArray(value.items.enum)) {
             const [first, ...rest] = value.items.enum;
-            zodType = z5.z.array(z5.z.enum([first, ...rest]));
+            zodType = z6.z.array(z6.z.enum([first, ...rest]));
           } else if (value.items.type === "string") {
-            zodType = z5.z.array(z5.z.string());
+            zodType = z6.z.array(z6.z.string());
           } else if (value.items.type === "number") {
-            zodType = z5.z.array(z5.z.number());
+            zodType = z6.z.array(z6.z.number());
           } else if (value.items.type === "boolean") {
-            zodType = z5.z.array(z5.z.boolean());
+            zodType = z6.z.array(z6.z.boolean());
           } else if (value.items.type === "object") {
-            zodType = z5.z.array(z5.z.record(z5.z.string(), z5.z.any()));
+            zodType = z6.z.array(z6.z.record(z6.z.string(), z6.z.any()));
           } else {
-            zodType = z5.z.array(z5.z.any());
+            zodType = z6.z.array(z6.z.any());
           }
         } else {
-          zodType = z5.z.array(z5.z.any());
+          zodType = z6.z.array(z6.z.any());
         }
         if (value.minItems) zodType = zodType.min(value.minItems);
         if (value.maxItems) zodType = zodType.max(value.maxItems);
       } else if (value.type === "object") {
-        zodType = z5.z.record(z5.z.string(), z5.z.any());
+        zodType = z6.z.record(z6.z.string(), z6.z.any());
       } else {
-        zodType = z5.z.any();
+        zodType = z6.z.any();
       }
       if (value.description) {
         zodType = zodType.describe(value.description);
@@ -3267,7 +3884,7 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
       }
       properties[key] = zodType;
     }
-    return z5.z.object(properties);
+    return z6.z.object(properties);
   }
   /**
    * Extract user-visible activities with rich formatting and complete information
@@ -3327,6 +3944,9 @@ ${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.tool_call_id": artifactData.metadata?.toolCallId || "unknown",
+          "artifact.data": JSON.stringify(artifactData.data, null, 2),
           "tenant.id": artifactData.tenantId || "unknown",
           "project.id": artifactData.projectId || "unknown",
           "context.id": artifactData.contextId || "unknown",
@@ -3377,8 +3997,7 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
 Tool Context: ${toolContext ? JSON.stringify(toolContext, null, 2) : "No tool context"}
 Context: ${conversationHistory?.slice(-200) || "Processing"}
 Type: ${artifactData.artifactType || "data"}
-Summary: ${JSON.stringify(artifactData.summaryProps, null, 2)}
-Full: ${JSON.stringify(artifactData.fullProps, null, 2)}
+Data: ${JSON.stringify(artifactData.data || artifactData.summaryData, null, 2)}
 
 Make it specific and relevant.`;
           let modelToUse = this.statusUpdateState?.summarizerModel;
@@ -3396,7 +4015,7 @@ Make it specific and relevant.`;
                   });
                   if (agentData && "models" in agentData && agentData.models?.base?.model) {
                     modelToUse = agentData.models.base;
-                    logger9.info(
+                    logger10.info(
                       {
                         sessionId: this.sessionId,
                         artifactId: artifactData.artifactId,
@@ -3407,7 +4026,7 @@ Make it specific and relevant.`;
                     );
                   }
                 } catch (error) {
-                  logger9.warn(
+                  logger10.warn(
                     {
                       sessionId: this.sessionId,
                       artifactId: artifactData.artifactId,
@@ -3419,7 +4038,7 @@ Make it specific and relevant.`;
                 }
               }
               if (!modelToUse?.model?.trim()) {
-                logger9.warn(
+                logger10.warn(
                   {
                     sessionId: this.sessionId,
                     artifactId: artifactData.artifactId
@@ -3440,9 +4059,9 @@ Make it specific and relevant.`;
             };
           } else {
             const model = ModelFactory.createModel(modelToUse);
-            const schema = z5.z.object({
-              name: z5.z.string().describe("Concise, descriptive name for the artifact"),
-              description: z5.z.string().describe("Brief description of the artifact's relevance to the user's question")
+            const schema = z6.z.object({
+              name: z6.z.string().describe("Concise, descriptive name for the artifact"),
+              description: z6.z.string().describe("Brief description of the artifact's relevance to the user's question")
             });
             const { object } = await tracer.startActiveSpan(
               "graph_session.generate_artifact_metadata",
@@ -3452,8 +4071,12 @@ Make it specific and relevant.`;
                   "llm.operation": "generate_object",
                   "artifact.id": artifactData.artifactId,
                   "artifact.type": artifactData.artifactType,
-                  "artifact.summary": JSON.stringify(artifactData.summaryProps, null, 2),
-                  "artifact.full": JSON.stringify(artifactData.fullProps, null, 2),
+                  "artifact.summary": JSON.stringify(artifactData.summaryData, null, 2),
+                  "artifact.full": JSON.stringify(
+                    artifactData.data || artifactData.summaryData,
+                    null,
+                    2
+                  ),
                   "prompt.length": prompt.length
                 }
               },
@@ -3483,8 +4106,12 @@ Make it specific and relevant.`;
                       "artifact.type": artifactData.artifactType,
                       "artifact.name": result2.object.name,
                       "artifact.description": result2.object.description,
-                      "artifact.summary": JSON.stringify(artifactData.summaryProps, null, 2),
-                      "artifact.full": JSON.stringify(artifactData.fullProps, null, 2),
+                      "artifact.summary": JSON.stringify(artifactData.summaryData, null, 2),
+                      "artifact.full": JSON.stringify(
+                        artifactData.data || artifactData.summaryData,
+                        null,
+                        2
+                      ),
                       "generation.name_length": result2.object.name.length,
                       "generation.description_length": result2.object.description.length,
                       "generation.attempts": attempt
@@ -3493,7 +4120,7 @@ Make it specific and relevant.`;
                     return result2;
                   } catch (error) {
                     lastError = error instanceof Error ? error : new Error(String(error));
-                    logger9.warn(
+                    logger10.warn(
                       {
                         sessionId: this.sessionId,
                         artifactId: artifactData.artifactId,
@@ -3509,7 +4136,10 @@ Make it specific and relevant.`;
                     }
                   }
                 }
-                agentsCore.setSpanWithError(generationSpan, lastError instanceof Error ? lastError : new Error(String(lastError)));
+                agentsCore.setSpanWithError(
+                  generationSpan,
+                  lastError instanceof Error ? lastError : new Error(String(lastError))
+                );
                 throw new Error(
                   `Artifact name/description generation failed after ${maxRetries} attempts: ${lastError?.message}`
                 );
@@ -3530,9 +4160,9 @@ Make it specific and relevant.`;
               name: result.name,
               description: result.description,
               type: artifactData.artifactType || "source",
-              summaryProps: artifactData.summaryProps || {},
-              fullProps: artifactData.fullProps || {},
-              metadata: artifactData.metadata || {}
+              data: artifactData.data || {},
+              metadata: artifactData.metadata || {},
+              toolCallId: artifactData.toolCallId
             });
             mainSaveSucceeded = true;
             span.setAttributes({
@@ -3542,7 +4172,7 @@ Make it specific and relevant.`;
             });
             span.setStatus({ code: api.SpanStatusCode.OK });
           } catch (saveError) {
-            logger9.error(
+            logger10.error(
               {
                 sessionId: this.sessionId,
                 artifactId: artifactData.artifactId,
@@ -3566,11 +4196,11 @@ Make it specific and relevant.`;
                   name: `Artifact ${artifactData.artifactId.substring(0, 8)}`,
                   description: `${artifactData.artifactType || "Data"} from ${artifactData.metadata?.toolName || "tool results"}`,
                   type: artifactData.artifactType || "source",
-                  summaryProps: artifactData.summaryProps || {},
-                  fullProps: artifactData.fullProps || {},
-                  metadata: artifactData.metadata || {}
+                  data: artifactData.data || {},
+                  metadata: artifactData.metadata || {},
+                  toolCallId: artifactData.toolCallId
                 });
-                logger9.info(
+                logger10.info(
                   {
                     sessionId: this.sessionId,
                     artifactId: artifactData.artifactId
@@ -3581,7 +4211,7 @@ Make it specific and relevant.`;
             } catch (fallbackError) {
               const isDuplicateError = fallbackError instanceof Error && (fallbackError.message?.includes("UNIQUE") || fallbackError.message?.includes("duplicate"));
               if (isDuplicateError) ; else {
-                logger9.error(
+                logger10.error(
                   {
                     sessionId: this.sessionId,
                     artifactId: artifactData.artifactId,
@@ -3594,7 +4224,7 @@ Make it specific and relevant.`;
           }
         } catch (error) {
           agentsCore.setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
-          logger9.error(
+          logger10.error(
             {
               sessionId: this.sessionId,
               artifactId: artifactData.artifactId,
@@ -3613,7 +4243,7 @@ Make it specific and relevant.`;
    */
   setArtifactCache(key, artifact) {
     this.artifactCache.set(key, artifact);
-    logger9.debug({ sessionId: this.sessionId, key }, "Artifact cached in session");
+    logger10.debug({ sessionId: this.sessionId, key }, "Artifact cached in session");
   }
   /**
    * Get session-scoped ArtifactService instance
@@ -3632,9 +4262,17 @@ Make it specific and relevant.`;
    */
   getArtifactCache(key) {
     const artifact = this.artifactCache.get(key);
-    logger9.debug({ sessionId: this.sessionId, key, found: !!artifact }, "Artifact cache lookup");
+    logger10.debug({ sessionId: this.sessionId, key, found: !!artifact }, "Artifact cache lookup");
     return artifact || null;
   }
+  /**
+   * Update artifact components in the shared ArtifactService
+   */
+  updateArtifactComponents(artifactComponents) {
+    if (this.artifactService) {
+      this.artifactService.updateArtifactComponents(artifactComponents);
+    }
+  }
 };
 var GraphSessionManager = class {
   constructor() {
@@ -3647,7 +4285,7 @@ var GraphSessionManager = class {
     const sessionId = messageId;
     const session = new GraphSession(sessionId, messageId, graphId, tenantId, projectId, contextId);
     this.sessions.set(sessionId, session);
-    logger9.info(
+    logger10.info(
       { sessionId, messageId, graphId, tenantId, projectId, contextId },
       "GraphSession created"
     );
@@ -3661,7 +4299,7 @@ var GraphSessionManager = class {
     if (session) {
       session.initializeStatusUpdates(config, summarizerModel);
     } else {
-      logger9.error(
+      logger10.error(
         {
           sessionId,
           availableSessions: Array.from(this.sessions.keys())
@@ -3670,6 +4308,23 @@ var GraphSessionManager = class {
       );
     }
   }
+  /**
+   * Enable emit operations for a session to send data operations
+   */
+  enableEmitOperations(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.enableEmitOperations();
+    } else {
+      logger10.error(
+        {
+          sessionId,
+          availableSessions: Array.from(this.sessions.keys())
+        },
+        "Session not found for emit operations enablement"
+      );
+    }
+  }
   /**
    * Get an existing session
    */
@@ -3682,7 +4337,7 @@ var GraphSessionManager = class {
   recordEvent(sessionId, eventType, agentId, data) {
     const session = this.sessions.get(sessionId);
     if (!session) {
-      logger9.warn({ sessionId }, "Attempted to record event in non-existent session");
+      logger10.warn({ sessionId }, "Attempted to record event in non-existent session");
       return;
     }
     session.recordEvent(eventType, agentId, data);
@@ -3693,12 +4348,12 @@ var GraphSessionManager = class {
   endSession(sessionId) {
     const session = this.sessions.get(sessionId);
     if (!session) {
-      logger9.warn({ sessionId }, "Attempted to end non-existent session");
+      logger10.warn({ sessionId }, "Attempted to end non-existent session");
       return [];
     }
     const events = session.getEvents();
     const summary = session.getSummary();
-    logger9.info({ sessionId, summary }, "GraphSession ended");
+    logger10.info({ sessionId, summary }, "GraphSession ended");
     session.cleanup();
     this.sessions.delete(sessionId);
     return events;
@@ -3752,12 +4407,61 @@ var GraphSessionManager = class {
     const session = this.sessions.get(sessionId);
     return session ? session.getArtifactParser() : null;
   }
+  /**
+   * Update artifact components for a session
+   */
+  updateArtifactComponents(sessionId, artifactComponents) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.updateArtifactComponents(artifactComponents);
+    }
+  }
 };
 var graphSessionManager = new GraphSessionManager();
 
+// src/utils/model-resolver.ts
+init_dbClient();
+async function resolveModelConfig(graphId, agent) {
+  if (agent.models?.base?.model) {
+    return {
+      base: agent.models.base,
+      structuredOutput: agent.models.structuredOutput || agent.models.base,
+      summarizer: agent.models.summarizer || agent.models.base
+    };
+  }
+  const graph = await agentsCore.getAgentGraphById(dbClient_default)({
+    scopes: { tenantId: agent.tenantId, projectId: agent.projectId, graphId }
+  });
+  if (graph?.models?.base?.model) {
+    return {
+      base: graph.models.base,
+      structuredOutput: agent.models?.structuredOutput || graph.models.structuredOutput || graph.models.base,
+      summarizer: agent.models?.summarizer || graph.models.summarizer || graph.models.base
+    };
+  }
+  const project = await agentsCore.getProject(dbClient_default)({
+    scopes: { tenantId: agent.tenantId, projectId: agent.projectId }
+  });
+  if (project?.models?.base?.model) {
+    return {
+      base: project.models.base,
+      structuredOutput: agent.models?.structuredOutput || project.models.structuredOutput || project.models.base,
+      summarizer: agent.models?.summarizer || project.models.summarizer || project.models.base
+    };
+  }
+  throw new Error(
+    "Base model configuration is required. Please configure models at the project level."
+  );
+}
+
+// src/agents/Agent.ts
+init_conversations();
+init_dbClient();
+init_logger();
+
 // src/services/IncrementalStreamParser.ts
 init_logger();
-var logger10 = agentsCore.getLogger("IncrementalStreamParser");
+var logger11 = agentsCore.getLogger("IncrementalStreamParser");
 var _IncrementalStreamParser = class _IncrementalStreamParser {
   // Max number of collected parts to prevent unbounded growth
   constructor(streamHelper, tenantId, contextId, artifactParserOptions) {
@@ -3786,9 +4490,20 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
         return;
       }
     }
+    let sharedArtifactService = null;
+    if (artifactParserOptions?.streamRequestId && typeof graphSessionManager.getArtifactService === "function") {
+      try {
+        sharedArtifactService = graphSessionManager.getArtifactService(
+          artifactParserOptions.streamRequestId
+        );
+      } catch (error) {
+      }
+    }
     this.artifactParser = new ArtifactParser(tenantId, {
       ...artifactParserOptions,
-      contextId
+      contextId,
+      artifactService: sharedArtifactService
+      // Use shared ArtifactService if available
     });
   }
   /**
@@ -3798,7 +4513,7 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
   async initializeArtifactMap() {
     try {
       this.artifactMap = await this.artifactParser.getContextArtifacts(this.contextId);
-      logger10.debug(
+      logger11.debug(
         {
           contextId: this.contextId,
           artifactMapSize: this.artifactMap.size
@@ -3806,7 +4521,7 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
         "Initialized artifact map for streaming"
       );
     } catch (error) {
-      logger10.warn({ error, contextId: this.contextId }, "Failed to initialize artifact map");
+      logger11.warn({ error, contextId: this.contextId }, "Failed to initialize artifact map");
       this.artifactMap = /* @__PURE__ */ new Map();
     }
   }
@@ -3903,9 +4618,13 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
    * Note: Text components are handled separately with incremental streaming
    */
   async streamComponent(component) {
-    const parts = await this.artifactParser.parseObject({
-      dataComponents: [component]
-    }, this.artifactMap, this.agentId);
+    const parts = await this.artifactParser.parseObject(
+      {
+        dataComponents: [component]
+      },
+      this.artifactMap,
+      this.agentId
+    );
     if (!Array.isArray(parts)) {
       console.warn("parseObject returned non-array:", parts);
       return;
@@ -3975,9 +4694,13 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
         const componentKey = component.id;
         const hasBeenStreamed = this.lastStreamedComponents.has(componentKey);
         if (!hasBeenStreamed && this.isComponentComplete(component) && component.name !== "Text") {
-          const parts = await this.artifactParser.parseObject({
-            dataComponents: [component]
-          }, this.artifactMap, this.agentId);
+          const parts = await this.artifactParser.parseObject(
+            {
+              dataComponents: [component]
+            },
+            this.artifactMap,
+            this.agentId
+          );
           for (const part of parts) {
             await this.streamPart(part);
           }
@@ -4042,7 +4765,11 @@ var _IncrementalStreamParser = class _IncrementalStreamParser {
         remainingBuffer: workingBuffer
       };
     }
-    const parts = await this.artifactParser.parseText(workingBuffer, this.artifactMap, this.agentId);
+    const parts = await this.artifactParser.parseText(
+      workingBuffer,
+      this.artifactMap,
+      this.agentId
+    );
     if (parts.length > 0 && parts[parts.length - 1].kind === "text") {
       const lastPart = parts[parts.length - 1];
       const lastText = lastPart.text || "";
@@ -4115,20 +4842,35 @@ var IncrementalStreamParser = _IncrementalStreamParser;
 
 // src/services/ResponseFormatter.ts
 init_logger();
-var logger11 = agentsCore.getLogger("ResponseFormatter");
+var logger12 = agentsCore.getLogger("ResponseFormatter");
 var ResponseFormatter = class {
   constructor(tenantId, artifactParserOptions) {
     __publicField(this, "artifactParser");
     __publicField(this, "agentId");
     this.agentId = artifactParserOptions?.agentId;
     if (artifactParserOptions?.streamRequestId) {
-      const sessionParser = graphSessionManager.getArtifactParser(artifactParserOptions.streamRequestId);
+      const sessionParser = graphSessionManager.getArtifactParser(
+        artifactParserOptions.streamRequestId
+      );
       if (sessionParser) {
         this.artifactParser = sessionParser;
         return;
       }
     }
-    this.artifactParser = new ArtifactParser(tenantId, artifactParserOptions);
+    let sharedArtifactService = null;
+    if (artifactParserOptions?.streamRequestId && typeof graphSessionManager.getArtifactService === "function") {
+      try {
+        sharedArtifactService = graphSessionManager.getArtifactService(
+          artifactParserOptions.streamRequestId
+        );
+      } catch (error) {
+      }
+    }
+    this.artifactParser = new ArtifactParser(tenantId, {
+      ...artifactParserOptions,
+      artifactService: sharedArtifactService
+      // Use shared ArtifactService if available
+    });
   }
   /**
    * Process structured object response and replace artifact markers with actual artifacts
@@ -4141,7 +4883,11 @@ var ResponseFormatter = class {
           "response.type": "object",
           "response.availableArtifacts": artifactMap.size
         });
-        const parts = await this.artifactParser.parseObject(responseObject, artifactMap, this.agentId);
+        const parts = await this.artifactParser.parseObject(
+          responseObject,
+          artifactMap,
+          this.agentId
+        );
         const uniqueArtifacts = this.countUniqueArtifacts(parts);
         span.setAttributes({
           "response.dataPartsCount": parts.length,
@@ -4155,7 +4901,7 @@ var ResponseFormatter = class {
         return { parts };
       } catch (error) {
         agentsCore.setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
-        logger11.error({ error, responseObject }, "Error formatting object response");
+        logger12.error({ error, responseObject }, "Error formatting object response");
         return {
           parts: [{ kind: "data", data: responseObject }]
         };
@@ -4207,7 +4953,7 @@ var ResponseFormatter = class {
         return { parts };
       } catch (error) {
         agentsCore.setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
-        logger11.error({ error, responseText }, "Error formatting response");
+        logger12.error({ error, responseText }, "Error formatting response");
         return { text: responseText };
       } finally {
         span.end();
@@ -4255,7 +5001,7 @@ var ResponseFormatter = class {
 function agentInitializingOp(sessionId, graphId) {
   return {
     type: "agent_initializing",
-    ctx: {
+    details: {
       sessionId,
       graphId
     }
@@ -4264,7 +5010,7 @@ function agentInitializingOp(sessionId, graphId) {
 function completionOp(agentId, iterations) {
   return {
     type: "completion",
-    ctx: {
+    details: {
       agent: agentId,
       iteration: iterations
     }
@@ -4289,11 +5035,11 @@ init_logger();
 
 // src/utils/data-component-schema.ts
 init_logger();
-var logger12 = agentsCore.getLogger("DataComponentSchema");
+var logger13 = agentsCore.getLogger("DataComponentSchema");
 function jsonSchemaToZod(jsonSchema) {
   if (!jsonSchema || typeof jsonSchema !== "object") {
-    logger12.warn({ jsonSchema }, "Invalid JSON schema provided, using string fallback");
-    return z5.z.string();
+    logger13.warn({ jsonSchema }, "Invalid JSON schema provided, using string fallback");
+    return z6.z.string();
   }
   switch (jsonSchema.type) {
     case "object":
@@ -4302,31 +5048,31 @@ function jsonSchemaToZod(jsonSchema) {
         for (const [key, prop] of Object.entries(jsonSchema.properties)) {
           shape[key] = jsonSchemaToZod(prop);
         }
-        return z5.z.object(shape);
+        return z6.z.object(shape);
       }
-      return z5.z.record(z5.z.string(), z5.z.unknown());
+      return z6.z.record(z6.z.string(), z6.z.unknown());
     case "array": {
-      const itemSchema = jsonSchema.items ? jsonSchemaToZod(jsonSchema.items) : z5.z.unknown();
-      return z5.z.array(itemSchema);
+      const itemSchema = jsonSchema.items ? jsonSchemaToZod(jsonSchema.items) : z6.z.unknown();
+      return z6.z.array(itemSchema);
     }
     case "string":
-      return z5.z.string();
+      return z6.z.string();
     case "number":
     case "integer":
-      return z5.z.number();
+      return z6.z.number();
     case "boolean":
-      return z5.z.boolean();
+      return z6.z.boolean();
     case "null":
-      return z5.z.null();
+      return z6.z.null();
     default:
-      logger12.warn(
+      logger13.warn(
         {
           unsupportedType: jsonSchema.type,
           schema: jsonSchema
         },
         "Unsupported JSON schema type, using unknown validation"
       );
-      return z5.z.unknown();
+      return z6.z.unknown();
   }
 }
 
@@ -4554,9 +5300,9 @@ var _ArtifactReferenceSchema = class _ArtifactReferenceSchema {
    * Get the standard Zod schema for artifact reference components
    */
   static getSchema() {
-    return z5.z.object({
-      id: z5.z.string(),
-      name: z5.z.literal("Artifact"),
+    return z6.z.object({
+      id: z6.z.string(),
+      name: z6.z.literal("Artifact"),
       props: jsonSchemaToZod(_ArtifactReferenceSchema.ARTIFACT_PROPS_SCHEMA)
     });
   }
@@ -4598,8 +5344,7 @@ var ArtifactCreateSchema = class {
    */
   static getSchemas(artifactComponents) {
     return artifactComponents.map((component) => {
-      const enhancedSummaryProps = SchemaProcessor.enhanceSchemaWithJMESPathGuidance(component.summaryProps);
-      const enhancedFullProps = SchemaProcessor.enhanceSchemaWithJMESPathGuidance(component.fullProps);
+      const enhancedSchema = component.props ? SchemaProcessor.enhanceSchemaWithJMESPathGuidance(component.props) : { type: "object", properties: {} };
       const propsSchema = {
         type: "object",
         properties: {
@@ -4618,16 +5363,15 @@ var ArtifactCreateSchema = class {
           },
           base_selector: {
             type: "string",
-            description: `JMESPath selector starting with "result." to navigate to ONE specific item. Summary/full props will be relative to this selection. Use filtering to avoid arrays (e.g., "result.items[?type=='guide']"). EXAMPLE: For JSON {"result":{"structuredContent":{"content":[{"type":"document","title":"Guide"}]}}} - WRONG: "result.content[?type=='document']" (skips structuredContent) - RIGHT: "result.structuredContent.content[?type=='document']".`
+            description: `JMESPath selector starting with "result." to navigate to ONE specific item. Details selector will be relative to this selection. Use filtering to avoid arrays (e.g., "result.items[?type=='guide']").`
           },
-          summary_props: enhancedSummaryProps,
-          full_props: enhancedFullProps
+          details_selector: enhancedSchema
         },
         required: ["id", "tool_call_id", "type", "base_selector"]
       };
-      return z5.z.object({
-        id: z5.z.string(),
-        name: z5.z.literal(`ArtifactCreate_${component.name}`),
+      return z6.z.object({
+        id: z6.z.string(),
+        name: z6.z.literal(`ArtifactCreate_${component.name}`),
         props: jsonSchemaToZod(propsSchema)
       });
     });
@@ -4639,8 +5383,7 @@ var ArtifactCreateSchema = class {
    */
   static getDataComponents(tenantId, projectId = "", artifactComponents) {
     return artifactComponents.map((component) => {
-      const enhancedSummaryProps = SchemaProcessor.enhanceSchemaWithJMESPathGuidance(component.summaryProps);
-      const enhancedFullProps = SchemaProcessor.enhanceSchemaWithJMESPathGuidance(component.fullProps);
+      const enhancedSchema = component.props ? SchemaProcessor.enhanceSchemaWithJMESPathGuidance(component.props) : { type: "object", properties: {} };
       const propsSchema = {
         type: "object",
         properties: {
@@ -4659,10 +5402,9 @@ var ArtifactCreateSchema = class {
           },
           base_selector: {
             type: "string",
-            description: `JMESPath selector starting with "result." to navigate to ONE specific item. Summary/full props will be relative to this selection. Use filtering to avoid arrays (e.g., "result.items[?type=='guide']"). EXAMPLE: For JSON {"result":{"structuredContent":{"content":[{"type":"document","title":"Guide"}]}}} - WRONG: "result.content[?type=='document']" (skips structuredContent) - RIGHT: "result.structuredContent.content[?type=='document']".`
+            description: `JMESPath selector starting with "result." to navigate to ONE specific item. Details selector will be relative to this selection. Use filtering to avoid arrays (e.g., "result.items[?type=='guide']").`
           },
-          summary_props: enhancedSummaryProps,
-          full_props: enhancedFullProps
+          details_selector: enhancedSchema
         },
         required: ["id", "tool_call_id", "type", "base_selector"]
       };
@@ -4690,7 +5432,7 @@ function parseEmbeddedJson(data) {
 
 // src/a2a/client.ts
 init_logger();
-var logger13 = agentsCore.getLogger("a2aClient");
+var logger14 = agentsCore.getLogger("a2aClient");
 var DEFAULT_BACKOFF = {
   initialInterval: 500,
   maxInterval: 6e4,
@@ -4896,7 +5638,7 @@ var A2AClient = class {
       try {
         const res = await fn();
         if (attempt > 0) {
-          logger13.info(
+          logger14.info(
             {
               attempts: attempt + 1,
               elapsedTime: Date.now() - start
@@ -4911,7 +5653,7 @@ var A2AClient = class {
         }
         const elapsed = Date.now() - start;
         if (elapsed > maxElapsedTime) {
-          logger13.warn(
+          logger14.warn(
             {
               attempts: attempt + 1,
               elapsedTime: elapsed,
@@ -4932,7 +5674,7 @@ var A2AClient = class {
           retryInterval = initialInterval * attempt ** exponent + Math.random() * 1e3;
         }
         const delayMs = Math.min(retryInterval, maxInterval);
-        logger13.info(
+        logger14.info(
           {
             attempt: attempt + 1,
             delayMs,
@@ -5017,7 +5759,7 @@ var A2AClient = class {
     }
     const rpcResponse = await httpResponse.json();
     if (rpcResponse.id !== requestId2) {
-      logger13.warn(
+      logger14.warn(
         {
           method,
           expectedId: requestId2,
@@ -5216,7 +5958,7 @@ var A2AClient = class {
     try {
       while (true) {
         const { done, value } = await reader.read();
-        logger13.info({ done, value }, "parseA2ASseStream");
+        logger14.info({ done, value }, "parseA2ASseStream");
         if (done) {
           if (eventDataBuffer.trim()) {
             const result = this._processSseEventData(
@@ -5306,7 +6048,7 @@ var A2AClient = class {
 init_conversations();
 init_dbClient();
 init_logger();
-var logger14 = agentsCore.getLogger("relationships Tools");
+var logger15 = agentsCore.getLogger("relationships Tools");
 var generateTransferToolDescription = (config) => {
   return `Hand off the conversation to agent ${config.id}.
 
@@ -5335,7 +6077,7 @@ var createTransferToAgentTool = ({
 }) => {
   return ai.tool({
     description: generateTransferToolDescription(transferConfig),
-    inputSchema: z5__default.default.object({}),
+    inputSchema: z6__default.default.object({}),
     execute: async () => {
       const activeSpan = api.trace.getActiveSpan();
       if (activeSpan) {
@@ -5344,7 +6086,7 @@ var createTransferToAgentTool = ({
           "transfer.to_agent_id": transferConfig.id ?? "unknown"
         });
       }
-      logger14.info(
+      logger15.info(
         {
           transferTo: transferConfig.id ?? "unknown",
           fromAgent: callingAgentId
@@ -5381,7 +6123,7 @@ function createDelegateToAgentTool({
 }) {
   return ai.tool({
     description: generateDelegateToolDescription(delegateConfig.config),
-    inputSchema: z5__default.default.object({ message: z5__default.default.string() }),
+    inputSchema: z6__default.default.object({ message: z6__default.default.string() }),
     execute: async (input, context) => {
       const delegationId = `del_${nanoid.nanoid()}`;
       const activeSpan = api.trace.getActiveSpan();
@@ -5493,7 +6235,7 @@ function createDelegateToAgentTool({
           ...isInternal ? { fromAgentId: callingAgentId } : { fromExternalAgentId: callingAgentId }
         }
       };
-      logger14.info({ messageToSend }, "messageToSend");
+      logger15.info({ messageToSend }, "messageToSend");
       await agentsCore.createMessage(dbClient_default)({
         id: nanoid.nanoid(),
         tenantId,
@@ -5556,7 +6298,7 @@ function createDelegateToAgentTool({
 
 // src/agents/SystemPromptBuilder.ts
 init_logger();
-var logger15 = agentsCore.getLogger("SystemPromptBuilder");
+var logger16 = agentsCore.getLogger("SystemPromptBuilder");
 var SystemPromptBuilder = class {
   constructor(version, versionConfig) {
     this.version = version;
@@ -5572,12 +6314,12 @@ var SystemPromptBuilder = class {
         this.templates.set(name, content);
       }
       this.loaded = true;
-      logger15.debug(
+      logger16.debug(
         { templateCount: this.templates.size, version: this.version },
         `Loaded ${this.templates.size} templates for version ${this.version}`
       );
     } catch (error) {
-      logger15.error({ error }, `Failed to load templates for version ${this.version}`);
+      logger16.error({ error }, `Failed to load templates for version ${this.version}`);
       throw new Error(`Template loading failed: ${error}`);
     }
   }
@@ -5602,68 +6344,6 @@ var SystemPromptBuilder = class {
   }
 };
 
-// templates/v1/shared/artifact.xml?raw
-var artifact_default = "<artifact>\n  <name>{{ARTIFACT_NAME}}</name>\n  <description>{{ARTIFACT_DESCRIPTION}}</description>\n  <task_id>{{TASK_ID}}</task_id>\n  <artifact_id>{{ARTIFACT_ID}}</artifact_id>\n  <tool_call_id>{{TOOL_CALL_ID}}</tool_call_id>\n  <summary_data>{{ARTIFACT_SUMMARY}}</summary_data>\n</artifact> ";
-
-// templates/v1/shared/artifact-retrieval-guidance.xml?raw
-var artifact_retrieval_guidance_default = `ARTIFACT RETRIEVAL: ACCESSING EXISTING ARTIFACT DATA
-
-\u{1F6A8} **CRITICAL: ALWAYS CHECK EXISTING ARTIFACTS FIRST** \u{1F6A8}
-Before creating new artifacts, ALWAYS examine existing artifacts to see if they contain relevant information for the current topic or question.
-
-You CAN and SHOULD retrieve information from existing artifacts to answer user questions.
-Available artifacts contain structured data that you can access in two ways:
-
-1. **SUMMARY DATA**: Read the summary_data directly from available artifacts for basic information
-2. **FULL DATA**: Use the get_artifact tool to retrieve complete artifact data (both summary_data and full_data) when you need detailed information
-
-**REUSE EXISTING ARTIFACTS WHEN POSSIBLE:**
-- Look for artifacts with similar topics, names, or descriptions
-- Check if existing artifacts can answer the current question
-- Use existing artifact data instead of creating duplicates
-- Only create new artifacts if existing ones don't contain the needed information
-- Prioritize reusing relevant existing artifacts over creating new ones
-
-HOW TO USE ARTIFACT DATA:
-- Read summary_data from available artifacts for quick answers
-- Use get_artifact tool when you need comprehensive details
-- Extract specific information to answer user questions accurately
-- Reference artifacts when citing the information source
-- Combine information from multiple existing artifacts when relevant
-
-\u{1F6A8} **MANDATORY CITATION POLICY** \u{1F6A8}
-EVERY piece of information from existing artifacts MUST be properly cited:
-- When referencing information from existing artifacts = MUST cite with artifact reference
-- When discussing artifact data = MUST cite the artifact source  
-- When using artifact information = MUST reference the artifact
-- NO INFORMATION from existing artifacts can be presented without proper citation
-
-CITATION PLACEMENT RULES:
-- ALWAYS place artifact citations AFTER complete thoughts and punctuation
-- Never interrupt a sentence or thought with an artifact citation
-- Complete your sentence or thought, add punctuation, THEN add the citation
-- This maintains natural reading flow and professional presentation
-
-\u2705 CORRECT EXAMPLES:
-- "The API uses OAuth 2.0 authentication. <artifact:create id='auth-doc' ...> This process involves three main steps..."
-- "Based on the documentation, there are several authentication methods available. <artifact:create id='auth-methods' ...> The recommended approach is OAuth 2.0."
-
-\u274C WRONG EXAMPLES:
-- "The API uses <artifact:create id='auth-doc' ...> OAuth 2.0 authentication which involves..."
-- "According to <artifact:create id='auth-doc' ...>, the authentication method is OAuth 2.0."
-
-\u{1F3AF} **KEY PRINCIPLE**: Information from tools \u2192 Complete thought \u2192 Punctuation \u2192 Citation \u2192 Continue
-
-DELEGATION AND ARTIFACTS:
-When you use delegation tools, the response may include artifacts in the parts array. These appear as objects with:
-- kind: "data"
-- data: { artifactId, toolCallId, name, description, type, artifactSummary }
-
-These artifacts become immediately available for you to reference using the artifactId and toolCallId from the response.
-Present delegation results naturally without mentioning the delegation process itself.
-
-IMPORTANT: All agents can retrieve and use information from existing artifacts when the graph has artifact components, regardless of whether the individual agent can create new artifacts.`;
-
 // templates/v1/phase1/system-prompt.xml?raw
 var system_prompt_default = `<system_message>
   <agent_identity>
@@ -5780,6 +6460,68 @@ var thinking_preparation_default = `<thinking_preparation_mode>
 // templates/v1/phase1/tool.xml?raw
 var tool_default = "<tool>\n  <name>{{TOOL_NAME}}</name>\n  <description>{{TOOL_DESCRIPTION}}</description>\n  <parameters>\n    <schema>\n      {{TOOL_PARAMETERS_SCHEMA}}\n    </schema>\n  </parameters>\n  <usage_guidelines>\n    {{TOOL_USAGE_GUIDELINES}}\n  </usage_guidelines>\n</tool> ";
 
+// templates/v1/shared/artifact.xml?raw
+var artifact_default = "<artifact>\n  <name>{{ARTIFACT_NAME}}</name>\n  <description>{{ARTIFACT_DESCRIPTION}}</description>\n  <task_id>{{TASK_ID}}</task_id>\n  <artifact_id>{{ARTIFACT_ID}}</artifact_id>\n  <tool_call_id>{{TOOL_CALL_ID}}</tool_call_id>\n  <summary_data>{{ARTIFACT_SUMMARY}}</summary_data>\n  <!-- NOTE: This shows summary/preview data only. Use get_reference_artifact tool to get complete artifact data if needed. -->\n</artifact> ";
+
+// templates/v1/shared/artifact-retrieval-guidance.xml?raw
+var artifact_retrieval_guidance_default = `ARTIFACT RETRIEVAL: ACCESSING EXISTING ARTIFACT DATA
+
+\u{1F6A8} **CRITICAL: ALWAYS CHECK EXISTING ARTIFACTS FIRST** \u{1F6A8}
+Before creating new artifacts, ALWAYS examine existing artifacts to see if they contain relevant information for the current topic or question.
+
+You CAN and SHOULD retrieve information from existing artifacts to answer user questions.
+Available artifacts contain structured data that you can access in two ways:
+
+1. **SUMMARY DATA**: Read the summary_data directly from available artifacts for basic information
+2. **FULL DATA**: Use the get_artifact tool to retrieve complete artifact data (both summary_data and full_data) when you need detailed information
+
+**REUSE EXISTING ARTIFACTS WHEN POSSIBLE:**
+- Look for artifacts with similar topics, names, or descriptions
+- Check if existing artifacts can answer the current question
+- Use existing artifact data instead of creating duplicates
+- Only create new artifacts if existing ones don't contain the needed information
+- Prioritize reusing relevant existing artifacts over creating new ones
+
+HOW TO USE ARTIFACT DATA:
+- Read summary_data from available artifacts for quick answers
+- Use get_artifact tool when you need comprehensive details
+- Extract specific information to answer user questions accurately
+- Reference artifacts when citing the information source
+- Combine information from multiple existing artifacts when relevant
+
+\u{1F6A8} **MANDATORY CITATION POLICY** \u{1F6A8}
+EVERY piece of information from existing artifacts MUST be properly cited:
+- When referencing information from existing artifacts = MUST cite with artifact reference
+- When discussing artifact data = MUST cite the artifact source  
+- When using artifact information = MUST reference the artifact
+- NO INFORMATION from existing artifacts can be presented without proper citation
+
+CITATION PLACEMENT RULES:
+- ALWAYS place artifact citations AFTER complete thoughts and punctuation
+- Never interrupt a sentence or thought with an artifact citation
+- Complete your sentence or thought, add punctuation, THEN add the citation
+- This maintains natural reading flow and professional presentation
+
+\u2705 CORRECT EXAMPLES:
+- "The API uses OAuth 2.0 authentication. <artifact:create id='auth-doc' ...> This process involves three main steps..."
+- "Based on the documentation, there are several authentication methods available. <artifact:create id='auth-methods' ...> The recommended approach is OAuth 2.0."
+
+\u274C WRONG EXAMPLES:
+- "The API uses <artifact:create id='auth-doc' ...> OAuth 2.0 authentication which involves..."
+- "According to <artifact:create id='auth-doc' ...>, the authentication method is OAuth 2.0."
+
+\u{1F3AF} **KEY PRINCIPLE**: Information from tools \u2192 Complete thought \u2192 Punctuation \u2192 Citation \u2192 Continue
+
+DELEGATION AND ARTIFACTS:
+When you use delegation tools, the response may include artifacts in the parts array. These appear as objects with:
+- kind: "data"
+- data: { artifactId, toolCallId, name, description, type, artifactSummary }
+
+These artifacts become immediately available for you to reference using the artifactId and toolCallId from the response.
+Present delegation results naturally without mentioning the delegation process itself.
+
+IMPORTANT: All agents can retrieve and use information from existing artifacts when the graph has artifact components, regardless of whether the individual agent can create new artifacts.`;
+
 // src/agents/versions/v1/Phase1Config.ts
 init_logger();
 agentsCore.getLogger("Phase1Config");
@@ -5916,8 +6658,8 @@ SELECTOR REQUIREMENTS:
 
 CRITICAL: SELECTOR HIERARCHY
 - base_selector: Points to ONE specific item in the tool result
-- summary_props/full_props: Contain JMESPath selectors RELATIVE to the base selector
-- Example: If base="result.documents[?type=='api']" then summary_props uses "title" not "documents[0].title"
+- details_selector: Contains JMESPath selectors RELATIVE to the base selector
+- Example: If base="result.documents[?type=='api']" then details_selector uses "title" not "documents[0].title"
 
 COMMON FAILURE POINTS (AVOID THESE):
 1. **Array Selection**: result.items (returns array) \u274C
@@ -5949,24 +6691,22 @@ You will create and reference artifacts using inline annotations in your text re
 
 CREATING ARTIFACTS (SERVES AS CITATION):
 Use the artifact:create annotation to extract data from tool results. The creation itself serves as a citation.
-Format: <artifact:create id="unique-id" tool="tool_call_id" type="TypeName" base="selector.path" summary='{"key":"jmespath_selector"}' full='{"key":"jmespath_selector"}' />
+Format: <artifact:create id="unique-id" tool="tool_call_id" type="TypeName" base="selector.path" details='{"key":"jmespath_selector"}' />
 
-\u{1F6A8} CRITICAL: SUMMARY AND FULL PROPS USE JMESPATH SELECTORS, NOT LITERAL VALUES! \u{1F6A8}
+\u{1F6A8} CRITICAL: DETAILS PROPS USE JMESPATH SELECTORS, NOT LITERAL VALUES! \u{1F6A8}
 
 \u274C WRONG - Using literal values:
-summary='{"title":"API Documentation","type":"guide"}'
-full='{"description":"This is a comprehensive guide..."}'
+details='{"title":"API Documentation","type":"guide"}'
 
 \u2705 CORRECT - Using JMESPath selectors (relative to base selector):
-summary='{"title":"metadata.title","doc_type":"document_type"}'
-full='{"description":"content.description","main_text":"content.text","author":"metadata.author"}'
+details='{"title":"metadata.title","doc_type":"document_type","description":"content.description","main_text":"content.text","author":"metadata.author"}'
 
 The selectors extract actual field values from the data structure selected by your base selector.
 
-THE summary AND full PROPERTIES MUST CONTAIN JMESPATH SELECTORS THAT EXTRACT DATA FROM THE TOOL RESULT!
-- summary: Contains JMESPath selectors relative to the base selector
-- full: Contains JMESPath selectors relative to the base selector  
+THE details PROPERTY MUST CONTAIN JMESPATH SELECTORS THAT EXTRACT DATA FROM THE TOOL RESULT!
+- details: Contains JMESPath selectors relative to the base selector that map to artifact schema fields
 - These selectors are evaluated against the tool result to extract the actual values
+- The system automatically determines which fields are preview vs full based on the artifact schema
 - NEVER put literal values like "Inkeep" or "2023" - always use selectors like "metadata.company" or "founded_year"
 
 \u{1F6AB} FORBIDDEN JMESPATH PATTERNS:
@@ -6026,7 +6766,7 @@ Only use artifact:ref when you need to cite the SAME artifact again for a differ
 Format: <artifact:ref id="artifact-id" tool="tool_call_id" />
 
 EXAMPLE TEXT RESPONSE:
-"I found the authentication documentation. <artifact:create id='auth-doc-1' tool='call_xyz789' type='APIDoc' base='result.documents[?type=="auth"]' summary='{"title":"metadata.title","endpoint":"api.endpoint"}' full='{"description":"content.description","parameters":"spec.parameters","examples":"examples.sample_code"}' /> The documentation explains OAuth 2.0 implementation in detail.
+"I found the authentication documentation. <artifact:create id='auth-doc-1' tool='call_xyz789' type='APIDoc' base='result.documents[?type=="auth"]' details='{"title":"metadata.title","endpoint":"api.endpoint","description":"content.description","parameters":"spec.parameters","examples":"examples.sample_code"}' /> The documentation explains OAuth 2.0 implementation in detail.
 
 The process involves three main steps: registration, token exchange, and API calls. As mentioned in the authentication documentation <artifact:ref id='auth-doc-1' tool='call_xyz789' />, you'll need to register your application first."
 
@@ -6082,31 +6822,29 @@ IMPORTANT GUIDELINES:
       return "";
     }
     const typeDescriptions = artifactComponents.map((ac) => {
-      let summarySchema = "No schema defined";
-      let fullSchema = "No schema defined";
-      if (ac.summaryProps?.properties) {
-        const summaryDetails = Object.entries(ac.summaryProps.properties).map(([key, value]) => `${key} (${value.description || value.type || "field"})`).join(", ");
-        summarySchema = `Required: ${summaryDetails}`;
-      }
-      if (ac.fullProps?.properties) {
-        const fullDetails = Object.entries(ac.fullProps.properties).map(([key, value]) => `${key} (${value.description || value.type || "field"})`).join(", ");
-        fullSchema = `Available: ${fullDetails}`;
+      let schemaDescription = "No schema defined";
+      if (ac.props?.properties) {
+        const fieldDetails = Object.entries(ac.props.properties).map(([key, value]) => {
+          const inPreview = value.inPreview ? " [PREVIEW]" : " [FULL]";
+          return `${key} (${value.description || value.type || "field"})${inPreview}`;
+        }).join(", ");
+        schemaDescription = `Fields: ${fieldDetails}`;
       }
       return `  - "${ac.name}": ${ac.description || "No description available"}
-    Summary Props: ${summarySchema}
-    Full Props: ${fullSchema}`;
+    ${schemaDescription}`;
     }).join("\n\n");
     return `
 AVAILABLE ARTIFACT TYPES:
 
 ${typeDescriptions}
 
-\u{1F6A8} CRITICAL: SUMMARY AND FULL PROPS MUST MATCH THE ARTIFACT SCHEMA! \u{1F6A8}
+\u{1F6A8} CRITICAL: DETAILS PROPS MUST MATCH THE ARTIFACT SCHEMA! \u{1F6A8}
 - Only use property names that are defined in the artifact component schema above
 - Do NOT make up arbitrary property names like "founders", "nick_details", "year"  
-- Each artifact type has specific required fields in summaryProps and available fields in fullProps
+- Each artifact type has specific fields defined in its schema
 - Your JMESPath selectors must extract values for these exact schema-defined properties
-- Example: If schema defines "title" and "url", use summary='{"title":"title","url":"url"}' not made-up names
+- Example: If schema defines "title" and "url", use details='{"title":"title","url":"url"}' not made-up names
+- The system will automatically determine which fields are preview vs full based on schema configuration
 
 \u{1F6A8} CRITICAL: USE EXACT ARTIFACT TYPE NAMES IN QUOTES! \u{1F6A8}
 - MUST use the exact type name shown in quotes above
@@ -6117,7 +6855,11 @@ ${typeDescriptions}
   }
   generateArtifactsSection(templates, artifacts, hasArtifactComponents = false, artifactComponents, hasGraphArtifactComponents) {
     const shouldShowReferencingRules = hasGraphArtifactComponents || artifacts.length > 0;
-    const rules = this.getArtifactReferencingRules(hasArtifactComponents, templates, shouldShowReferencingRules);
+    const rules = this.getArtifactReferencingRules(
+      hasArtifactComponents,
+      templates,
+      shouldShowReferencingRules
+    );
     const creationInstructions = this.getArtifactCreationInstructions(
       hasArtifactComponents,
       artifactComponents
@@ -6212,6 +6954,12 @@ ${propertiesXml}
   }
 };
 
+// templates/v1/phase2/data-component.xml?raw
+var data_component_default = "<data-component>\n  <name>{{COMPONENT_NAME}}</name>\n  <description>{{COMPONENT_DESCRIPTION}}</description>\n  <props>\n    <schema>\n      {{COMPONENT_PROPS_SCHEMA}}\n    </schema>\n  </props>\n</data-component> ";
+
+// templates/v1/phase2/data-components.xml?raw
+var data_components_default = '<data_components_section description="These are the data components available for you to use in generating responses. Each component represents a single structured piece of information. You can create multiple instances of the same component type when needed.\n\n***MANDATORY JSON RESPONSE FORMAT - ABSOLUTELY CRITICAL***:\n- WHEN DATA COMPONENTS ARE AVAILABLE, YOU MUST RESPOND IN JSON FORMAT ONLY\n- DO NOT respond with plain text when data components are defined\n- YOUR RESPONSE MUST BE STRUCTURED JSON WITH dataComponents ARRAY\n- THIS IS NON-NEGOTIABLE - JSON FORMAT IS REQUIRED\n\nCRITICAL JSON FORMATTING RULES - MUST FOLLOW EXACTLY:\n1. Each data component must include id, name, and props fields\n2. The id and name should match the exact component definition\n3. The props field contains the actual component data using exact property names from the schema\n4. NEVER omit the id and name fields\n\nCORRECT: [{\\"id\\": \\"component1\\", \\"name\\": \\"Component1\\", \\"props\\": {\\"field1\\": \\"value1\\", \\"field2\\": \\"value2\\"}}, {\\"id\\": \\"component2\\", \\"name\\": \\"Component2\\", \\"props\\": {\\"field3\\": \\"value3\\"}}]\nWRONG: [{\\"field1\\": \\"value1\\", \\"field2\\": \\"value2\\"}, {\\"field3\\": \\"value3\\"}]\n\nAVAILABLE DATA COMPONENTS: {{DATA_COMPONENTS_LIST}}">\n\n{{DATA_COMPONENTS_XML}}\n\n</data_components_section>';
+
 // templates/v1/phase2/system-prompt.xml?raw
 var system_prompt_default2 = `<phase2_system_message>
   <instruction>
@@ -6251,12 +6999,6 @@ var system_prompt_default2 = `<phase2_system_message>
   </requirements>
 </phase2_system_message>`;
 
-// templates/v1/phase2/data-components.xml?raw
-var data_components_default = '<data_components_section description="These are the data components available for you to use in generating responses. Each component represents a single structured piece of information. You can create multiple instances of the same component type when needed.\n\n***MANDATORY JSON RESPONSE FORMAT - ABSOLUTELY CRITICAL***:\n- WHEN DATA COMPONENTS ARE AVAILABLE, YOU MUST RESPOND IN JSON FORMAT ONLY\n- DO NOT respond with plain text when data components are defined\n- YOUR RESPONSE MUST BE STRUCTURED JSON WITH dataComponents ARRAY\n- THIS IS NON-NEGOTIABLE - JSON FORMAT IS REQUIRED\n\nCRITICAL JSON FORMATTING RULES - MUST FOLLOW EXACTLY:\n1. Each data component must include id, name, and props fields\n2. The id and name should match the exact component definition\n3. The props field contains the actual component data using exact property names from the schema\n4. NEVER omit the id and name fields\n\nCORRECT: [{\\"id\\": \\"component1\\", \\"name\\": \\"Component1\\", \\"props\\": {\\"field1\\": \\"value1\\", \\"field2\\": \\"value2\\"}}, {\\"id\\": \\"component2\\", \\"name\\": \\"Component2\\", \\"props\\": {\\"field3\\": \\"value3\\"}}]\nWRONG: [{\\"field1\\": \\"value1\\", \\"field2\\": \\"value2\\"}, {\\"field3\\": \\"value3\\"}]\n\nAVAILABLE DATA COMPONENTS: {{DATA_COMPONENTS_LIST}}">\n\n{{DATA_COMPONENTS_XML}}\n\n</data_components_section>';
-
-// templates/v1/phase2/data-component.xml?raw
-var data_component_default = "<data-component>\n  <name>{{COMPONENT_NAME}}</name>\n  <description>{{COMPONENT_DESCRIPTION}}</description>\n  <props>\n    <schema>\n      {{COMPONENT_PROPS_SCHEMA}}\n    </schema>\n  </props>\n</data-component> ";
-
 // src/agents/versions/v1/Phase2Config.ts
 var Phase2Config = class {
   getArtifactCreationGuidance() {
@@ -6302,17 +7044,15 @@ When the same field names appear at different levels (like 'content', 'title', '
 
 CRITICAL: SELECTOR HIERARCHY
 - base_selector: Points to ONE specific item in the tool result
-- summary_props/full_props: Contain JMESPath selectors RELATIVE to the base selector
-- Example: If base="result.documents[?type=='api']" then summary_props uses "title" not "documents[0].title"
+- details_selector: Contains JMESPath selectors RELATIVE to the base selector  
+- Example: If base="result.documents[?type=='api']" then details_selector uses "title" not "documents[0].title"
 
 \u274C WRONG EXAMPLE:
 {
   "base_selector": "result.content[?title=='Guide']",
-  "summary_props": {
+  "details_selector": {
     "title": "Guide",  // \u274C This is a literal value, not a selector!
-    "url": "result.content[?title=='Guide'].url"  // \u274C This is absolute, not relative!
-  },
-  "full_props": {
+    "url": "result.content[?title=='Guide'].url",  // \u274C This is absolute, not relative!
     "description": "A comprehensive guide",  // \u274C Literal value instead of selector!
     "content": "result.content[?title=='Guide'].content"  // \u274C Absolute path instead of relative!
   }
@@ -6321,11 +7061,9 @@ CRITICAL: SELECTOR HIERARCHY
 \u2705 CORRECT EXAMPLE:
 {
   "base_selector": "result.content[?title=='Guide']",
-  "summary_props": {
+  "details_selector": {
     "title": "title",  // \u2705 Relative selector to get title field
-    "url": "url"       // \u2705 Relative selector to get url field
-  },
-  "full_props": {
+    "url": "url",       // \u2705 Relative selector to get url field  
     "description": "description",    // \u2705 Relative selector
     "content": "content",            // \u2705 Relative selector
     "metadata": "metadata.details"  // \u2705 Relative selector with nesting
@@ -6411,8 +7149,7 @@ EXAMPLE STRUCTURED RESPONSE:
         "tool_call_id": "call_abc123",
         "type": "APIDoc",
         "base_selector": "result.documents[?type=='api']",
-        "summary_props": {"title": "metadata.title", "endpoint": "api.endpoint"},
-        "full_props": {"description": "content.description", "parameters": "spec.parameters", "examples": "examples.sample_code"}
+        "details_selector": {"title": "metadata.title", "endpoint": "api.endpoint", "description": "content.description", "parameters": "spec.parameters", "examples": "examples.sample_code"}
       }
     },
     {
@@ -6492,14 +7229,14 @@ IMPORTANT GUIDELINES:
       return "";
     }
     const componentDescriptions = artifactComponents.map((ac) => {
-      const summaryProps = ac.summaryProps?.properties ? Object.entries(ac.summaryProps.properties).map(([key, value]) => `      - ${key}: ${value.description || "Field from tool result"}`).join("\n") : "      No properties defined";
-      const fullProps = ac.fullProps?.properties ? Object.entries(ac.fullProps.properties).map(([key, value]) => `      - ${key}: ${value.description || "Field from tool result"}`).join("\n") : "      No properties defined";
+      const schemaProps = ac.props?.properties ? Object.entries(ac.props.properties).map(([key, value]) => {
+        const inPreview = value.inPreview ? " [PREVIEW]" : " [FULL]";
+        return `      - ${key}: ${value.description || "Field from tool result"}${inPreview}`;
+      }).join("\n") : "      No properties defined";
       return `  ArtifactCreate_${ac.name}:
     Description: ${ac.description || "Extract and structure data"}
-    Summary Properties:
-${summaryProps}
-    Full Properties:
-${fullProps}`;
+    Schema Properties:
+${schemaProps}`;
     }).join("\n\n");
     return `
 AVAILABLE ARTIFACT TYPES:
@@ -6513,8 +7250,14 @@ ${componentDescriptions}`;
     const dataComponentsDescription = dataComponents.map((dc) => `${dc.name}: ${dc.description}`).join(", ");
     const dataComponentsXml = dataComponents.map((dataComponent) => this.generateDataComponentXml(dataComponent)).join("\n  ");
     let dataComponentsSection = data_components_default;
-    dataComponentsSection = dataComponentsSection.replace("{{DATA_COMPONENTS_LIST}}", dataComponentsDescription);
-    dataComponentsSection = dataComponentsSection.replace("{{DATA_COMPONENTS_XML}}", dataComponentsXml);
+    dataComponentsSection = dataComponentsSection.replace(
+      "{{DATA_COMPONENTS_LIST}}",
+      dataComponentsDescription
+    );
+    dataComponentsSection = dataComponentsSection.replace(
+      "{{DATA_COMPONENTS_XML}}",
+      dataComponentsXml
+    );
     return dataComponentsSection;
   }
   generateDataComponentXml(dataComponent) {
@@ -6586,14 +7329,21 @@ ${artifact_retrieval_guidance_default}
    * Assemble the complete Phase 2 system prompt for structured output generation
    */
   assemblePhase2Prompt(config) {
-    const { corePrompt, dataComponents, artifactComponents, hasArtifactComponents, hasGraphArtifactComponents, artifacts = [] } = config;
+    const {
+      corePrompt,
+      dataComponents,
+      artifactComponents,
+      hasArtifactComponents,
+      hasGraphArtifactComponents,
+      artifacts = []
+    } = config;
     let allDataComponents = [...dataComponents];
     if (hasArtifactComponents && artifactComponents) {
       const artifactCreateComponents = ArtifactCreateSchema.getDataComponents(
         "tenant",
         // placeholder - not used in Phase2
         "",
-        // placeholder - not used in Phase2  
+        // placeholder - not used in Phase2
         artifactComponents
       );
       allDataComponents = [...dataComponents, ...artifactCreateComponents];
@@ -6601,8 +7351,15 @@ ${artifact_retrieval_guidance_default}
     const dataComponentsSection = this.generateDataComponentsSection(allDataComponents);
     const artifactsSection = this.generateArtifactsSection(artifacts);
     const shouldShowReferencingRules = hasGraphArtifactComponents || artifacts.length > 0;
-    const artifactGuidance = this.getStructuredArtifactGuidance(hasArtifactComponents, artifactComponents, shouldShowReferencingRules);
-    const artifactTypes = this.getArtifactCreationInstructions(hasArtifactComponents, artifactComponents);
+    const artifactGuidance = this.getStructuredArtifactGuidance(
+      hasArtifactComponents,
+      artifactComponents,
+      shouldShowReferencingRules
+    );
+    const artifactTypes = this.getArtifactCreationInstructions(
+      hasArtifactComponents,
+      artifactComponents
+    );
     let phase2Prompt = system_prompt_default2;
     phase2Prompt = phase2Prompt.replace("{{CORE_INSTRUCTIONS}}", corePrompt);
     phase2Prompt = phase2Prompt.replace("{{DATA_COMPONENTS_SECTION}}", dataComponentsSection);
@@ -6623,7 +7380,7 @@ function hasToolCallWithPrefix(prefix) {
     return false;
   };
 }
-var logger17 = agentsCore.getLogger("Agent");
+var logger19 = agentsCore.getLogger("Agent");
 var CONSTANTS = {
   MAX_GENERATION_STEPS: 12,
   PHASE_1_TIMEOUT_MS: 27e4,
@@ -6904,7 +7661,10 @@ var Agent = class {
     ]);
   }
   async getMcpTools(sessionId, streamRequestId) {
-    const tools = await Promise.all(this.config.tools?.map((tool3) => this.getMcpTool(tool3)) || []) || [];
+    const mcpTools = this.config.tools?.filter((tool3) => {
+      return tool3.config?.type === "mcp";
+    }) || [];
+    const tools = await Promise.all(mcpTools.map((tool3) => this.getMcpTool(tool3)) || []) || [];
     if (!sessionId) {
       const combinedTools = tools.reduce((acc, tool3) => {
         return Object.assign(acc, tool3);
@@ -6924,14 +7684,14 @@ var Agent = class {
     for (const toolSet of tools) {
       for (const [toolName, originalTool] of Object.entries(toolSet)) {
         if (!isValidTool(originalTool)) {
-          logger17.error({ toolName }, "Invalid MCP tool structure - missing required properties");
+          logger19.error({ toolName }, "Invalid MCP tool structure - missing required properties");
           continue;
         }
         const sessionWrappedTool = ai.tool({
           description: originalTool.description,
           inputSchema: originalTool.inputSchema,
           execute: async (args, { toolCallId }) => {
-            logger17.debug({ toolName, toolCallId }, "MCP Tool Called");
+            logger19.debug({ toolName, toolCallId }, "MCP Tool Called");
             try {
               const rawResult = await originalTool.execute(args, { toolCallId });
               const parsedResult = parseEmbeddedJson(rawResult);
@@ -6945,7 +7705,7 @@ var Agent = class {
               });
               return { result: enhancedResult, toolCallId };
             } catch (error) {
-              logger17.error({ toolName, toolCallId, error }, "MCP tool execution failed");
+              logger19.error({ toolName, toolCallId, error }, "MCP tool execution failed");
               throw error;
             }
           }
@@ -6964,6 +7724,9 @@ var Agent = class {
    * Convert database McpTool to builder MCPToolConfig format
    */
   convertToMCPToolConfig(tool3, agentToolRelationHeaders) {
+    if (tool3.config.type !== "mcp") {
+      throw new Error(`Cannot convert non-MCP tool to MCP config: ${tool3.id}`);
+    }
     return {
       id: tool3.id,
       name: tool3.name,
@@ -7032,6 +7795,9 @@ var Agent = class {
         selectedTools
       );
     } else {
+      if (tool3.config.type !== "mcp") {
+        throw new Error(`Cannot build server config for non-MCP tool: ${tool3.id}`);
+      }
       serverConfig = {
         type: tool3.config.mcp.transport?.type || agentsCore.MCPTransportType.streamableHttp,
         url: tool3.config.mcp.server.url,
@@ -7040,7 +7806,7 @@ var Agent = class {
         headers: agentToolRelationHeaders
       };
     }
-    logger17.info(
+    logger19.info(
       {
         toolName: tool3.name,
         credentialReferenceId,
@@ -7065,7 +7831,7 @@ var Agent = class {
         this.mcpClientCache.set(cacheKey, client);
       } catch (error) {
         this.mcpConnectionLocks.delete(cacheKey);
-        logger17.error(
+        logger19.error(
           {
             toolName: tool3.name,
             agentId: this.config.id,
@@ -7089,7 +7855,7 @@ var Agent = class {
       await client.connect();
       return client;
     } catch (error) {
-      logger17.error(
+      logger19.error(
         {
           toolName: tool3.name,
           agentId: this.config.id,
@@ -7100,39 +7866,110 @@ var Agent = class {
       throw error;
     }
   }
-  getFunctionTools(streamRequestId) {
-    if (!this.config.functionTools) return {};
+  async getFunctionTools(sessionId, streamRequestId) {
     const functionTools = {};
-    for (const funcTool of this.config.functionTools) {
-      const aiTool = ai.tool({
-        description: funcTool.description,
-        inputSchema: funcTool.schema || z5.z.object({}),
-        execute: funcTool.execute
+    try {
+      const toolsForAgent = await agentsCore.getToolsForAgent(dbClient_default)({
+        scopes: {
+          tenantId: this.config.tenantId || "default",
+          projectId: this.config.projectId || "default",
+          graphId: this.config.graphId,
+          agentId: this.config.id
+        }
       });
-      functionTools[funcTool.name] = this.wrapToolWithStreaming(
-        funcTool.name,
-        aiTool,
-        streamRequestId,
-        "tool"
-      );
+      const toolsData = toolsForAgent.data || [];
+      const functionToolDefs = toolsData.filter((tool3) => tool3.tool.config.type === "function");
+      if (functionToolDefs.length === 0) {
+        return functionTools;
+      }
+      const { LocalSandboxExecutor: LocalSandboxExecutor2 } = await Promise.resolve().then(() => (init_LocalSandboxExecutor(), LocalSandboxExecutor_exports));
+      const sandboxExecutor = LocalSandboxExecutor2.getInstance();
+      for (const toolDef of functionToolDefs) {
+        if (toolDef.tool.config?.type === "function") {
+          const functionId = toolDef.tool.functionId;
+          if (!functionId) {
+            logger19.warn({ toolId: toolDef.tool.id }, "Function tool missing functionId reference");
+            continue;
+          }
+          const functionData = await agentsCore.getFunction(dbClient_default)({
+            functionId,
+            scopes: {
+              tenantId: this.config.tenantId || "default",
+              projectId: this.config.projectId || "default"
+            }
+          });
+          if (!functionData) {
+            logger19.warn(
+              { functionId, toolId: toolDef.tool.id },
+              "Function not found in functions table"
+            );
+            continue;
+          }
+          const zodSchema = jsonSchemaToZod(functionData.inputSchema);
+          const aiTool = ai.tool({
+            description: toolDef.tool.description || toolDef.tool.name,
+            inputSchema: zodSchema,
+            execute: async (args, { toolCallId }) => {
+              logger19.debug(
+                { toolName: toolDef.tool.name, toolCallId, args },
+                "Function Tool Called"
+              );
+              try {
+                const result = await sandboxExecutor.executeFunctionTool(toolDef.tool.id, args, {
+                  description: toolDef.tool.description || toolDef.tool.name,
+                  inputSchema: functionData.inputSchema || {},
+                  executeCode: functionData.executeCode,
+                  dependencies: functionData.dependencies || {}
+                });
+                toolSessionManager.recordToolResult(sessionId || "", {
+                  toolCallId,
+                  toolName: toolDef.tool.name,
+                  args,
+                  result,
+                  timestamp: Date.now()
+                });
+                return { result, toolCallId };
+              } catch (error) {
+                logger19.error(
+                  { toolName: toolDef.tool.name, toolCallId, error },
+                  "Function tool execution failed"
+                );
+                throw error;
+              }
+            }
+          });
+          functionTools[toolDef.tool.name] = this.wrapToolWithStreaming(
+            toolDef.tool.name,
+            aiTool,
+            streamRequestId || "",
+            "tool"
+          );
+        }
+      }
+    } catch (error) {
+      logger19.error({ error }, "Failed to load function tools from database");
     }
     return functionTools;
   }
   /**
    * Get resolved context using ContextResolver - will return cached data or fetch fresh data as needed
    */
-  async getResolvedContext(conversationId, requestContext) {
+  async getResolvedContext(conversationId, headers) {
     try {
       if (!this.config.contextConfigId) {
-        logger17.debug({ graphId: this.config.graphId }, "No context config found for graph");
+        logger19.debug({ graphId: this.config.graphId }, "No context config found for graph");
         return null;
       }
       const contextConfig = await agentsCore.getContextConfigById(dbClient_default)({
-        scopes: { tenantId: this.config.tenantId, projectId: this.config.projectId },
+        scopes: {
+          tenantId: this.config.tenantId,
+          projectId: this.config.projectId,
+          graphId: this.config.graphId
+        },
         id: this.config.contextConfigId
       });
       if (!contextConfig) {
-        logger17.warn({ contextConfigId: this.config.contextConfigId }, "Context config not found");
+        logger19.warn({ contextConfigId: this.config.contextConfigId }, "Context config not found");
         return null;
       }
       if (!this.contextResolver) {
@@ -7141,7 +7978,7 @@ var Agent = class {
       const result = await this.contextResolver.resolve(contextConfig, {
         triggerEvent: "invocation",
         conversationId,
-        requestContext: requestContext || {},
+        headers: headers || {},
         tenantId: this.config.tenantId
       });
       const contextWithBuiltins = {
@@ -7149,7 +7986,7 @@ var Agent = class {
         $now: (/* @__PURE__ */ new Date()).toISOString(),
         $env: process.env
       };
-      logger17.debug(
+      logger19.debug(
         {
           conversationId,
           contextConfigId: contextConfig.id,
@@ -7163,7 +8000,7 @@ var Agent = class {
       );
       return contextWithBuiltins;
     } catch (error) {
-      logger17.error(
+      logger19.error(
         {
           conversationId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -7187,7 +8024,7 @@ var Agent = class {
       });
       return graphDefinition?.graphPrompt || void 0;
     } catch (error) {
-      logger17.warn(
+      logger19.warn(
         {
           graphId: this.config.graphId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -7216,7 +8053,7 @@ var Agent = class {
         (agent) => "artifactComponents" in agent && agent.artifactComponents && agent.artifactComponents.length > 0
       );
     } catch (error) {
-      logger17.warn(
+      logger19.warn(
         {
           graphId: this.config.graphId,
           tenantId: this.config.tenantId,
@@ -7245,7 +8082,7 @@ var Agent = class {
           preserveUnresolved: false
         });
       } catch (error) {
-        logger17.error(
+        logger19.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -7292,7 +8129,7 @@ var Agent = class {
           preserveUnresolved: false
         });
       } catch (error) {
-        logger17.error(
+        logger19.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -7304,9 +8141,24 @@ var Agent = class {
     }
     const streamRequestId = runtimeContext?.metadata?.streamRequestId;
     const mcpTools = await this.getMcpTools(void 0, streamRequestId);
-    const functionTools = this.getFunctionTools(streamRequestId);
+    const functionTools = await this.getFunctionTools(streamRequestId || "");
     const relationTools = this.getRelationTools(runtimeContext);
     const allTools = { ...mcpTools, ...functionTools, ...relationTools };
+    logger19.info(
+      {
+        mcpTools: Object.keys(mcpTools),
+        functionTools: Object.keys(functionTools),
+        relationTools: Object.keys(relationTools),
+        allTools: Object.keys(allTools),
+        functionToolsDetails: Object.entries(functionTools).map(([name, tool3]) => ({
+          name,
+          hasExecute: typeof tool3.execute === "function",
+          hasDescription: !!tool3.description,
+          hasInputSchema: !!tool3.inputSchema
+        }))
+      },
+      "Tools loaded for agent"
+    );
     const toolDefinitions = Object.entries(allTools).map(([name, tool3]) => ({
       name,
       description: tool3.description || "",
@@ -7331,7 +8183,7 @@ var Agent = class {
           preserveUnresolved: false
         });
       } catch (error) {
-        logger17.error(
+        logger19.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -7358,23 +8210,29 @@ var Agent = class {
   }
   getArtifactTools() {
     return ai.tool({
-      description: "Call this tool to get the artifact with the given artifactId. Only retrieve this when the description of the artifact is insufficient to understand the artifact and you need to see the actual artifact for more context. Please refrain from using this tool unless absolutely necessary.",
-      inputSchema: z5.z.object({
-        artifactId: z5.z.string().describe("The unique identifier of the artifact to get.")
+      description: "Call this tool to get the complete artifact data with the given artifactId. This retrieves the full artifact content (not just the summary). Only use this when you need the complete artifact data and the summary shown in your context is insufficient.",
+      inputSchema: z6.z.object({
+        artifactId: z6.z.string().describe("The unique identifier of the artifact to get."),
+        toolCallId: z6.z.string().describe("The tool call ID associated with this artifact.")
       }),
-      execute: async ({ artifactId }) => {
-        logger17.info({ artifactId }, "get_artifact executed");
-        const artifact = await agentsCore.getLedgerArtifacts(dbClient_default)({
-          scopes: {
-            tenantId: this.config.tenantId,
-            projectId: this.config.projectId
-          },
-          artifactId
-        });
-        if (!artifact) {
-          throw new Error(`Artifact ${artifactId} not found`);
+      execute: async ({ artifactId, toolCallId }) => {
+        logger19.info({ artifactId, toolCallId }, "get_artifact_full executed");
+        const streamRequestId = this.getStreamRequestId();
+        const artifactService = graphSessionManager.getArtifactService(streamRequestId);
+        if (!artifactService) {
+          throw new Error(`ArtifactService not found for session ${streamRequestId}`);
         }
-        return { artifact: artifact[0] };
+        const artifactData = await artifactService.getArtifactFull(artifactId, toolCallId);
+        if (!artifactData) {
+          throw new Error(`Artifact ${artifactId} with toolCallId ${toolCallId} not found`);
+        }
+        return {
+          artifactId: artifactData.artifactId,
+          name: artifactData.name,
+          description: artifactData.description,
+          type: artifactData.type,
+          data: artifactData.data
+        };
       }
     });
   }
@@ -7382,9 +8240,9 @@ var Agent = class {
   createThinkingCompleteTool() {
     return ai.tool({
       description: "\u{1F6A8} CRITICAL: Call this tool IMMEDIATELY when you have gathered enough information to answer the user. This is MANDATORY - you CANNOT provide text responses in thinking mode, only tool calls. Call thinking_complete as soon as you have sufficient data to generate a structured response.",
-      inputSchema: z5.z.object({
-        complete: z5.z.boolean().describe("ALWAYS set to true - marks end of research phase"),
-        summary: z5.z.string().describe(
+      inputSchema: z6.z.object({
+        complete: z6.z.boolean().describe("ALWAYS set to true - marks end of research phase"),
+        summary: z6.z.string().describe(
           "Brief summary of what information was gathered and why it is sufficient to answer the user"
         )
       }),
@@ -7392,7 +8250,7 @@ var Agent = class {
     });
   }
   // Provide a default tool set that is always available to the agent.
-  async getDefaultTools(sessionId, streamRequestId) {
+  async getDefaultTools(_sessionId, streamRequestId) {
     const defaultTools = {};
     if (await this.graphHasArtifactComponents()) {
       defaultTools.get_reference_artifact = this.getArtifactTools();
@@ -7480,13 +8338,19 @@ var Agent = class {
       if (Array.isArray(obj)) {
         obj.slice(0, 3).forEach((item) => {
           if (item && typeof item === "object") {
-            Object.keys(item).forEach((key) => fields.add(key));
+            Object.keys(item).forEach((key) => {
+              fields.add(key);
+            });
           }
         });
       } else if (obj && typeof obj === "object") {
-        Object.keys(obj).forEach((key) => fields.add(key));
+        Object.keys(obj).forEach((key) => {
+          fields.add(key);
+        });
         Object.values(obj).forEach((value) => {
-          findCommonFields(value, depth + 1).forEach((field) => fields.add(field));
+          findCommonFields(value, depth + 1).forEach((field) => {
+            fields.add(field);
+          });
         });
       }
       return fields;
@@ -7585,8 +8449,7 @@ var Agent = class {
           artifactGuidance: {
             creationFirst: "\u{1F6A8} CRITICAL: Artifacts must be CREATED before they can be referenced. Use ArtifactCreate_[Type] components FIRST, then reference with Artifact components only if citing the SAME artifact again.",
             baseSelector: `\u{1F3AF} CRITICAL: Use base_selector to navigate to ONE specific item. For deeply nested structures with repeated keys, use full paths with specific filtering (e.g., "result.data.content.items[?type=='guide' && status=='active']")`,
-            summaryProps: '\u{1F4DD} Use relative selectors from that item (e.g., "title", "metadata.category", "properties.status")',
-            fullProps: '\u{1F4D6} Use relative selectors for detailed data (e.g., "content.details", "specifications.data", "attributes")',
+            detailsSelector: '\u{1F4DD} Use relative selectors for specific fields (e.g., "title", "metadata.category", "properties.status", "content.details")',
             avoidLiterals: "\u274C NEVER use literal values - always use field selectors to extract from data",
             avoidArrays: "\u2728 ALWAYS filter arrays to single items using [?condition] - NEVER use [*] notation which returns arrays",
             nestedKeys: "\u{1F511} For structures with repeated keys (like result.content.data.content.items.content), use full paths with filtering at each level",
@@ -7613,7 +8476,7 @@ var Agent = class {
       };
       return enhanced;
     } catch (error) {
-      logger17.warn({ error }, "Failed to enhance tool result with structure hints");
+      logger19.warn({ error }, "Failed to enhance tool result with structure hints");
       return result;
     }
   }
@@ -7628,7 +8491,7 @@ var Agent = class {
         }
       });
     } catch (error) {
-      logger17.error(
+      logger19.error(
         { error, graphId: this.config.graphId },
         "Failed to check graph artifact components"
       );
@@ -7671,7 +8534,7 @@ var Agent = class {
                 // Normal prompt with data components
                 this.buildSystemPrompt(runtimeContext, true),
                 // Thinking prompt without data components
-                Promise.resolve(this.getFunctionTools(streamRequestId)),
+                this.getFunctionTools(sessionId, streamRequestId),
                 Promise.resolve(this.getRelationTools(runtimeContext, sessionId)),
                 this.getDefaultTools(sessionId, streamRequestId)
               ]);
@@ -7729,7 +8592,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) {
-          logger17.warn(
+          logger19.warn(
             {
               requestedTimeout: modelSettings.maxDuration * 1e3,
               appliedTimeout: timeoutMs,
@@ -7771,7 +8634,7 @@ var Agent = class {
                     }
                   );
                 } catch (error) {
-                  logger17.debug({ error }, "Failed to track agent reasoning");
+                  logger19.debug({ error }, "Failed to track agent reasoning");
                 }
               }
               if (last && "toolCalls" in last && last.toolCalls) {
@@ -7875,7 +8738,7 @@ var Agent = class {
                     }
                   );
                 } catch (error) {
-                  logger17.debug({ error }, "Failed to track agent reasoning");
+                  logger19.debug({ error }, "Failed to track agent reasoning");
                 }
               }
               if (last && "toolCalls" in last && last.toolCalls) {
@@ -7979,9 +8842,9 @@ ${output}${structureHintsFormatted}`;
               this.config.dataComponents.forEach((dc) => {
                 const propsSchema = jsonSchemaToZod(dc.props);
                 componentSchemas.push(
-                  z5.z.object({
-                    id: z5.z.string(),
-                    name: z5.z.literal(dc.name),
+                  z6.z.object({
+                    id: z6.z.string(),
+                    name: z6.z.literal(dc.name),
                     props: propsSchema
                   })
                 );
@@ -7998,7 +8861,7 @@ ${output}${structureHintsFormatted}`;
             if (componentSchemas.length === 1) {
               dataComponentsSchema = componentSchemas[0];
             } else {
-              dataComponentsSchema = z5.z.union(
+              dataComponentsSchema = z6.z.union(
                 componentSchemas
               );
             }
@@ -8022,8 +8885,8 @@ ${output}${structureHintsFormatted}`;
               const streamResult = ai.streamObject({
                 ...structuredModelSettings,
                 messages: phase2Messages,
-                schema: z5.z.object({
-                  dataComponents: z5.z.array(dataComponentsSchema)
+                schema: z6.z.object({
+                  dataComponents: z6.z.array(dataComponentsSchema)
                 }),
                 experimental_telemetry: {
                   isEnabled: true,
@@ -8091,8 +8954,8 @@ ${output}${structureHintsFormatted}`;
                 withJsonPostProcessing2({
                   ...structuredModelSettings,
                   messages: phase2Messages,
-                  schema: z5.z.object({
-                    dataComponents: z5.z.array(dataComponentsSchema)
+                  schema: z6.z.object({
+                    dataComponents: z6.z.array(dataComponentsSchema)
                   }),
                   experimental_telemetry: {
                     isEnabled: true,
@@ -8167,7 +9030,7 @@ ${output}${structureHintsFormatted}`;
 };
 
 // src/agents/generateTaskHandler.ts
-var logger18 = agentsCore.getLogger("generateTaskHandler");
+var logger20 = agentsCore.getLogger("generateTaskHandler");
 var createTaskHandler = (config, credentialStoreRegistry) => {
   return async (task) => {
     try {
@@ -8220,7 +9083,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
           }
         })
       ]);
-      logger18.info({ toolsForAgent, internalRelations, externalRelations }, "agent stuff");
+      logger20.info({ toolsForAgent, internalRelations, externalRelations }, "agent stuff");
       const enhancedInternalRelations = await Promise.all(
         internalRelations.map(async (relation) => {
           try {
@@ -8249,7 +9112,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
               return { ...relation, description: enhancedDescription };
             }
           } catch (error) {
-            logger18.warn({ agentId: relation.id, error }, "Failed to enhance agent description");
+            logger20.warn({ agentId: relation.id, error }, "Failed to enhance agent description");
           }
           return relation;
         })
@@ -8344,12 +9207,16 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
         },
         credentialStoreRegistry
       );
+      const artifactStreamRequestId = task.context?.metadata?.streamRequestId;
+      if (artifactStreamRequestId && artifactComponents.length > 0) {
+        graphSessionManager.updateArtifactComponents(artifactStreamRequestId, artifactComponents);
+      }
       let contextId = task.context?.conversationId;
       if (!contextId || contextId === "default" || contextId === "") {
         const taskIdMatch = task.id.match(/^task_([^-]+-[^-]+-\d+)-/);
         if (taskIdMatch) {
           contextId = taskIdMatch[1];
-          logger18.info(
+          logger20.info(
             {
               taskId: task.id,
               extractedContextId: contextId,
@@ -8365,7 +9232,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
       const isDelegation = task.context?.metadata?.isDelegation === true;
       agent.setDelegationStatus(isDelegation);
       if (isDelegation) {
-        logger18.info(
+        logger20.info(
           { agentId: config.agentId, taskId: task.id },
           "Delegated agent - streaming disabled"
         );
@@ -8590,7 +9457,7 @@ async function getRegisteredGraph(executionContext) {
 init_dbClient();
 init_logger();
 var app = new zodOpenapi.OpenAPIHono();
-var logger19 = agentsCore.getLogger("agents");
+var logger21 = agentsCore.getLogger("agents");
 app.openapi(
   zodOpenapi.createRoute({
     method: "get",
@@ -8605,14 +9472,14 @@ app.openapi(
         description: "Agent Card for A2A discovery",
         content: {
           "application/json": {
-            schema: z5.z.object({
-              name: z5.z.string(),
-              description: z5.z.string().optional(),
-              url: z5.z.string(),
-              version: z5.z.string(),
-              defaultInputModes: z5.z.array(z5.z.string()),
-              defaultOutputModes: z5.z.array(z5.z.string()),
-              skills: z5.z.array(z5.z.any())
+            schema: z6.z.object({
+              name: z6.z.string(),
+              description: z6.z.string().optional(),
+              url: z6.z.string(),
+              version: z6.z.string(),
+              defaultInputModes: z6.z.array(z6.z.string()),
+              defaultOutputModes: z6.z.array(z6.z.string()),
+              skills: z6.z.array(z6.z.any())
             })
           }
         }
@@ -8628,7 +9495,7 @@ app.openapi(
       tracestate: c.req.header("tracestate"),
       baggage: c.req.header("baggage")
     };
-    logger19.info(
+    logger21.info(
       {
         otelHeaders,
         path: c.req.path,
@@ -8640,7 +9507,7 @@ app.openapi(
     const { tenantId, projectId, graphId, agentId } = executionContext;
     console.dir("executionContext", executionContext);
     if (agentId) {
-      logger19.info(
+      logger21.info(
         {
           message: "getRegisteredAgent (agent-level)",
           tenantId,
@@ -8652,7 +9519,7 @@ app.openapi(
       );
       const credentialStores = c.get("credentialStores");
       const agent = await getRegisteredAgent(executionContext, credentialStores);
-      logger19.info({ agent }, "agent registered: well-known agent.json");
+      logger21.info({ agent }, "agent registered: well-known agent.json");
       if (!agent) {
         throw agentsCore.createApiError({
           code: "not_found",
@@ -8661,7 +9528,7 @@ app.openapi(
       }
       return c.json(agent.agentCard);
     } else {
-      logger19.info(
+      logger21.info(
         {
           message: "getRegisteredGraph (graph-level)",
           tenantId,
@@ -8687,7 +9554,7 @@ app.post("/a2a", async (c) => {
     tracestate: c.req.header("tracestate"),
     baggage: c.req.header("baggage")
   };
-  logger19.info(
+  logger21.info(
     {
       otelHeaders,
       path: c.req.path,
@@ -8698,7 +9565,7 @@ app.post("/a2a", async (c) => {
   const executionContext = agentsCore.getRequestExecutionContext(c);
   const { tenantId, projectId, graphId, agentId } = executionContext;
   if (agentId) {
-    logger19.info(
+    logger21.info(
       {
         message: "a2a (agent-level)",
         tenantId,
@@ -8722,7 +9589,7 @@ app.post("/a2a", async (c) => {
     }
     return a2aHandler(c, agent);
   } else {
-    logger19.info(
+    logger21.info(
       {
         message: "a2a (graph-level)",
         tenantId,
@@ -8778,14 +9645,14 @@ init_dbClient();
 // src/a2a/transfer.ts
 init_dbClient();
 init_logger();
-var logger20 = agentsCore.getLogger("Transfer");
+var logger22 = agentsCore.getLogger("Transfer");
 async function executeTransfer({
   tenantId,
   threadId,
   projectId,
   targetAgentId
 }) {
-  logger20.info({ targetAgent: targetAgentId }, "Executing transfer to agent");
+  logger22.info({ targetAgent: targetAgentId }, "Executing transfer to agent");
   await agentsCore.setActiveAgentForThread(dbClient_default)({
     scopes: { tenantId, projectId },
     threadId,
@@ -9371,7 +10238,7 @@ function createMCPStreamHelper() {
 }
 
 // src/handlers/executionHandler.ts
-var logger21 = agentsCore.getLogger("ExecutionHandler");
+var logger23 = agentsCore.getLogger("ExecutionHandler");
 var ExecutionHandler = class {
   constructor() {
     // Hardcoded error limit - separate from configurable stopWhen
@@ -9392,12 +10259,23 @@ var ExecutionHandler = class {
    * @returns
    */
   async execute(params) {
-    const { executionContext, conversationId, userMessage, initialAgentId, requestId: requestId2, sseHelper } = params;
+    const {
+      executionContext,
+      conversationId,
+      userMessage,
+      initialAgentId,
+      requestId: requestId2,
+      sseHelper,
+      emitOperations
+    } = params;
     const { tenantId, projectId, graphId, apiKey, baseUrl } = executionContext;
     registerStreamHelper(requestId2, sseHelper);
     graphSessionManager.createSession(requestId2, graphId, tenantId, projectId, conversationId);
-    logger21.info(
-      { sessionId: requestId2, graphId, conversationId },
+    if (emitOperations) {
+      graphSessionManager.enableEmitOperations(requestId2);
+    }
+    logger23.info(
+      { sessionId: requestId2, graphId, conversationId, emitOperations },
       "Created GraphSession for message execution"
     );
     let graphConfig = null;
@@ -9411,7 +10289,7 @@ var ExecutionHandler = class {
         );
       }
     } catch (error) {
-      logger21.error(
+      logger23.error(
         {
           error: error instanceof Error ? error.message : "Unknown error",
           stack: error instanceof Error ? error.stack : void 0
@@ -9427,7 +10305,7 @@ var ExecutionHandler = class {
     try {
       await sseHelper.writeOperation(agentInitializingOp(requestId2, graphId));
       const taskId = `task_${conversationId}-${requestId2}`;
-      logger21.info(
+      logger23.info(
         { taskId, currentAgentId, conversationId, requestId: requestId2 },
         "Attempting to create or reuse existing task"
       );
@@ -9451,7 +10329,7 @@ var ExecutionHandler = class {
             agent_id: currentAgentId
           }
         });
-        logger21.info(
+        logger23.info(
           {
             taskId,
             createdTaskMetadata: Array.isArray(task) ? task[0]?.metadata : task?.metadata
@@ -9460,27 +10338,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") {
-          logger21.info(
+          logger23.info(
             { taskId, error: error.message },
             "Task already exists, fetching existing task"
           );
           const existingTask = await agentsCore.getTask(dbClient_default)({ id: taskId });
           if (existingTask) {
             task = existingTask;
-            logger21.info(
+            logger23.info(
               { taskId, existingTask },
               "Successfully reused existing task from race condition"
             );
           } else {
-            logger21.error({ taskId, error }, "Task constraint failed but task not found");
+            logger23.error({ taskId, error }, "Task constraint failed but task not found");
             throw error;
           }
         } else {
-          logger21.error({ taskId, error }, "Failed to create task due to non-constraint error");
+          logger23.error({ taskId, error }, "Failed to create task due to non-constraint error");
           throw error;
         }
       }
-      logger21.debug(
+      logger23.debug(
         {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           executionType: "create_initial_task",
@@ -9498,7 +10376,7 @@ var ExecutionHandler = class {
       const maxTransfers = graphConfig?.stopWhen?.transferCountIs ?? 10;
       while (iterations < maxTransfers) {
         iterations++;
-        logger21.info(
+        logger23.info(
           { iterations, currentAgentId, graphId, conversationId, fromAgentId },
           `Execution loop iteration ${iterations} with agent ${currentAgentId}, transfer from: ${fromAgentId || "none"}`
         );
@@ -9506,10 +10384,10 @@ var ExecutionHandler = class {
           scopes: { tenantId, projectId },
           conversationId
         });
-        logger21.info({ activeAgent }, "activeAgent");
+        logger23.info({ activeAgent }, "activeAgent");
         if (activeAgent && activeAgent.activeAgentId !== currentAgentId) {
           currentAgentId = activeAgent.activeAgentId;
-          logger21.info({ currentAgentId }, `Updated current agent to: ${currentAgentId}`);
+          logger23.info({ currentAgentId }, `Updated current agent to: ${currentAgentId}`);
         }
         const agentBaseUrl = `${baseUrl}/agents`;
         const a2aClient = new A2AClient(agentBaseUrl, {
@@ -9550,13 +10428,13 @@ var ExecutionHandler = class {
         });
         if (!messageResponse?.result) {
           errorCount++;
-          logger21.error(
+          logger23.error(
             { currentAgentId, iterations, errorCount },
             `No response from agent ${currentAgentId} on iteration ${iterations} (error ${errorCount}/${this.MAX_ERRORS})`
           );
           if (errorCount >= this.MAX_ERRORS) {
             const errorMessage2 = `Maximum error limit (${this.MAX_ERRORS}) reached`;
-            logger21.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
+            logger23.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
             await sseHelper.writeOperation(errorOp(errorMessage2, currentAgentId || "system"));
             if (task) {
               await agentsCore.updateTask(dbClient_default)({
@@ -9581,7 +10459,7 @@ var ExecutionHandler = class {
           const transferResponse = messageResponse.result;
           const targetAgentId = transferResponse.artifacts?.[0]?.parts?.[0]?.data?.targetAgentId;
           const transferReason = transferResponse.artifacts?.[0]?.parts?.[1]?.text;
-          logger21.info({ targetAgentId, transferReason }, "transfer response");
+          logger23.info({ targetAgentId, transferReason }, "transfer response");
           currentMessage = `<transfer_context> ${transferReason} </transfer_context>`;
           const { success, targetAgentId: newAgentId } = await executeTransfer({
             projectId,
@@ -9592,7 +10470,7 @@ var ExecutionHandler = class {
           if (success) {
             fromAgentId = currentAgentId;
             currentAgentId = newAgentId;
-            logger21.info(
+            logger23.info(
               {
                 transferFrom: fromAgentId,
                 transferTo: currentAgentId,
@@ -9610,7 +10488,7 @@ var ExecutionHandler = class {
           const graphSessionData = graphSessionManager.getSession(requestId2);
           if (graphSessionData) {
             const sessionSummary = graphSessionData.getSummary();
-            logger21.info(sessionSummary, "GraphSession data after completion");
+            logger23.info(sessionSummary, "GraphSession data after completion");
           }
           let textContent = "";
           for (const part of responseParts) {
@@ -9664,22 +10542,22 @@ var ExecutionHandler = class {
                 }
               });
               const updateTaskEnd = Date.now();
-              logger21.info(
+              logger23.info(
                 { duration: updateTaskEnd - updateTaskStart },
                 "Completed updateTask operation"
               );
               await sseHelper.writeOperation(completionOp(currentAgentId, iterations));
               await sseHelper.complete();
-              logger21.info({}, "Ending GraphSession and cleaning up");
+              logger23.info({}, "Ending GraphSession and cleaning up");
               graphSessionManager.endSession(requestId2);
-              logger21.info({}, "Cleaning up streamHelper");
+              logger23.info({}, "Cleaning up streamHelper");
               unregisterStreamHelper(requestId2);
               let response;
               if (sseHelper instanceof MCPStreamHelper) {
                 const captured = sseHelper.getCapturedResponse();
                 response = captured.text || "No response content";
               }
-              logger21.info({}, "ExecutionHandler returning success");
+              logger23.info({}, "ExecutionHandler returning success");
               return { success: true, iterations, response };
             } catch (error) {
               agentsCore.setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
@@ -9690,13 +10568,13 @@ var ExecutionHandler = class {
           });
         }
         errorCount++;
-        logger21.warn(
+        logger23.warn(
           { iterations, errorCount },
           `No valid response or transfer on iteration ${iterations} (error ${errorCount}/${this.MAX_ERRORS})`
         );
         if (errorCount >= this.MAX_ERRORS) {
           const errorMessage2 = `Maximum error limit (${this.MAX_ERRORS}) reached`;
-          logger21.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
+          logger23.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
           await sseHelper.writeOperation(errorOp(errorMessage2, currentAgentId || "system"));
           if (task) {
             await agentsCore.updateTask(dbClient_default)({
@@ -9717,7 +10595,7 @@ var ExecutionHandler = class {
         }
       }
       const errorMessage = `Maximum transfer limit (${maxTransfers}) reached without completion`;
-      logger21.error({ maxTransfers, iterations }, errorMessage);
+      logger23.error({ maxTransfers, iterations }, errorMessage);
       await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || "system"));
       if (task) {
         await agentsCore.updateTask(dbClient_default)({
@@ -9736,7 +10614,7 @@ var ExecutionHandler = class {
       unregisterStreamHelper(requestId2);
       return { success: false, error: errorMessage, iterations };
     } catch (error) {
-      logger21.error({ error }, "Error in execution handler");
+      logger23.error({ error }, "Error in execution handler");
       const errorMessage = error instanceof Error ? error.message : "Unknown execution error";
       await sseHelper.writeOperation(
         errorOp(`Execution error: ${errorMessage}`, currentAgentId || "system")
@@ -9764,7 +10642,7 @@ var ExecutionHandler = class {
 // src/routes/chat.ts
 init_logger();
 var app2 = new zodOpenapi.OpenAPIHono();
-var logger22 = agentsCore.getLogger("completionsHandler");
+var logger24 = agentsCore.getLogger("completionsHandler");
 var chatCompletionsRoute = zodOpenapi.createRoute({
   method: "post",
   path: "/completions",
@@ -9776,37 +10654,37 @@ var chatCompletionsRoute = zodOpenapi.createRoute({
     body: {
       content: {
         "application/json": {
-          schema: z5.z.object({
-            model: z5.z.string().describe("The model to use for the completion"),
-            messages: z5.z.array(
-              z5.z.object({
-                role: z5.z.enum(["system", "user", "assistant", "function", "tool"]).describe("The role of the message"),
-                content: z5.z.union([
-                  z5.z.string(),
-                  z5.z.array(
-                    z5.z.strictObject({
-                      type: z5.z.string(),
-                      text: z5.z.string().optional()
+          schema: z6.z.object({
+            model: z6.z.string().describe("The model to use for the completion"),
+            messages: z6.z.array(
+              z6.z.object({
+                role: z6.z.enum(["system", "user", "assistant", "function", "tool"]).describe("The role of the message"),
+                content: z6.z.union([
+                  z6.z.string(),
+                  z6.z.array(
+                    z6.z.strictObject({
+                      type: z6.z.string(),
+                      text: z6.z.string().optional()
                     })
                   )
                 ]).describe("The message content"),
-                name: z5.z.string().optional().describe("The name of the message sender")
+                name: z6.z.string().optional().describe("The name of the message sender")
               })
             ).describe("The conversation messages"),
-            temperature: z5.z.number().optional().describe("Controls randomness (0-1)"),
-            top_p: z5.z.number().optional().describe("Controls nucleus sampling"),
-            n: z5.z.number().optional().describe("Number of completions to generate"),
-            stream: z5.z.boolean().optional().describe("Whether to stream the response"),
-            max_tokens: z5.z.number().optional().describe("Maximum tokens to generate"),
-            presence_penalty: z5.z.number().optional().describe("Presence penalty (-2 to 2)"),
-            frequency_penalty: z5.z.number().optional().describe("Frequency penalty (-2 to 2)"),
-            logit_bias: z5.z.record(z5.z.string(), z5.z.number()).optional().describe("Token logit bias"),
-            user: z5.z.string().optional().describe("User identifier"),
-            conversationId: z5.z.string().optional().describe("Conversation ID for multi-turn chat"),
-            tools: z5.z.array(z5.z.string()).optional().describe("Available tools"),
-            runConfig: z5.z.record(z5.z.string(), z5.z.unknown()).optional().describe("Run configuration"),
-            requestContext: z5.z.record(z5.z.string(), z5.z.unknown()).optional().describe(
-              "Context data for template processing (validated against context config schema)"
+            temperature: z6.z.number().optional().describe("Controls randomness (0-1)"),
+            top_p: z6.z.number().optional().describe("Controls nucleus sampling"),
+            n: z6.z.number().optional().describe("Number of completions to generate"),
+            stream: z6.z.boolean().optional().describe("Whether to stream the response"),
+            max_tokens: z6.z.number().optional().describe("Maximum tokens to generate"),
+            presence_penalty: z6.z.number().optional().describe("Presence penalty (-2 to 2)"),
+            frequency_penalty: z6.z.number().optional().describe("Frequency penalty (-2 to 2)"),
+            logit_bias: z6.z.record(z6.z.string(), z6.z.number()).optional().describe("Token logit bias"),
+            user: z6.z.string().optional().describe("User identifier"),
+            conversationId: z6.z.string().optional().describe("Conversation ID for multi-turn chat"),
+            tools: z6.z.array(z6.z.string()).optional().describe("Available tools"),
+            runConfig: z6.z.record(z6.z.string(), z6.z.unknown()).optional().describe("Run configuration"),
+            headers: z6.z.record(z6.z.string(), z6.z.unknown()).optional().describe(
+              "Headers data for template processing (validated against context config schema)"
             )
           })
         }
@@ -9816,14 +10694,14 @@ var chatCompletionsRoute = zodOpenapi.createRoute({
   responses: {
     200: {
       description: "Streaming chat completion response in Server-Sent Events format",
-      headers: z5.z.object({
-        "Content-Type": z5.z.string().default("text/event-stream"),
-        "Cache-Control": z5.z.string().default("no-cache"),
-        Connection: z5.z.string().default("keep-alive")
+      headers: z6.z.object({
+        "Content-Type": z6.z.string().default("text/event-stream"),
+        "Cache-Control": z6.z.string().default("no-cache"),
+        Connection: z6.z.string().default("keep-alive")
       }),
       content: {
         "text/event-stream": {
-          schema: z5.z.string().describe("Server-Sent Events stream with chat completion chunks")
+          schema: z6.z.string().describe("Server-Sent Events stream with chat completion chunks")
         }
       }
     },
@@ -9831,13 +10709,13 @@ var chatCompletionsRoute = zodOpenapi.createRoute({
       description: "Invalid request context or parameters",
       content: {
         "application/json": {
-          schema: z5.z.object({
-            error: z5.z.string(),
-            details: z5.z.array(
-              z5.z.object({
-                field: z5.z.string(),
-                message: z5.z.string(),
-                value: z5.z.unknown().optional()
+          schema: z6.z.object({
+            error: z6.z.string(),
+            details: z6.z.array(
+              z6.z.object({
+                field: z6.z.string(),
+                message: z6.z.string(),
+                value: z6.z.unknown().optional()
               })
             ).optional()
           })
@@ -9848,8 +10726,8 @@ var chatCompletionsRoute = zodOpenapi.createRoute({
       description: "Agent graph or agent not found",
       content: {
         "application/json": {
-          schema: z5.z.object({
-            error: z5.z.string()
+          schema: z6.z.object({
+            error: z6.z.string()
           })
         }
       }
@@ -9858,9 +10736,9 @@ var chatCompletionsRoute = zodOpenapi.createRoute({
       description: "Internal server error",
       content: {
         "application/json": {
-          schema: z5.z.object({
-            error: z5.z.string(),
-            message: z5.z.string()
+          schema: z6.z.object({
+            error: z6.z.string(),
+            message: z6.z.string()
           })
         }
       }
@@ -9882,7 +10760,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
     tracestate: c.req.header("tracestate"),
     baggage: c.req.header("baggage")
   };
-  logger22.info(
+  logger24.info(
     {
       otelHeaders,
       path: c.req.path,
@@ -9964,18 +10842,18 @@ app2.openapi(chatCompletionsRoute, async (c) => {
         message: "Agent not found"
       });
     }
-    const validatedContext = c.get("validatedContext") || body.requestContext || {};
+    const validatedContext = c.get("validatedContext") || body.headers || {};
     const credentialStores = c.get("credentialStores");
     await agentsCore.handleContextResolution({
       tenantId,
       projectId,
       graphId,
       conversationId,
-      requestContext: validatedContext,
+      headers: validatedContext,
       dbClient: dbClient_default,
       credentialStores
     });
-    logger22.info(
+    logger24.info(
       {
         tenantId,
         projectId,
@@ -9984,7 +10862,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
         defaultAgentId,
         activeAgentId: activeAgent?.activeAgentId || "none",
         hasContextConfig: !!agentGraph.contextConfigId,
-        hasRequestContext: !!body.requestContext,
+        hasHeaders: !!body.headers,
         hasValidatedContext: !!validatedContext,
         validatedContextKeys: Object.keys(validatedContext)
       },
@@ -10023,7 +10901,9 @@ app2.openapi(chatCompletionsRoute, async (c) => {
       try {
         const sseHelper = createSSEStreamHelper(stream2, requestId2, timestamp);
         await sseHelper.writeRole();
-        logger22.info({ agentId }, "Starting execution");
+        logger24.info({ agentId }, "Starting execution");
+        const emitOperationsHeader = c.req.header("x-emit-operations");
+        const emitOperations = emitOperationsHeader === "true";
         const executionHandler = new ExecutionHandler();
         const result = await executionHandler.execute({
           executionContext,
@@ -10031,9 +10911,10 @@ app2.openapi(chatCompletionsRoute, async (c) => {
           userMessage,
           initialAgentId: agentId,
           requestId: requestId2,
-          sseHelper
+          sseHelper,
+          emitOperations
         });
-        logger22.info(
+        logger24.info(
           { result },
           `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
         );
@@ -10047,7 +10928,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
         }
         await sseHelper.complete();
       } catch (error) {
-        logger22.error(
+        logger24.error(
           {
             error: error instanceof Error ? error.message : error,
             stack: error instanceof Error ? error.stack : void 0
@@ -10064,12 +10945,12 @@ app2.openapi(chatCompletionsRoute, async (c) => {
           );
           await sseHelper.complete();
         } catch (streamError) {
-          logger22.error({ streamError }, "Failed to write error to stream");
+          logger24.error({ streamError }, "Failed to write error to stream");
         }
       }
     });
   } catch (error) {
-    logger22.error(
+    logger24.error(
       {
         error: error instanceof Error ? error.message : error,
         stack: error instanceof Error ? error.stack : void 0
@@ -10097,7 +10978,7 @@ var chat_default = app2;
 init_dbClient();
 init_logger();
 var app3 = new zodOpenapi.OpenAPIHono();
-var logger23 = agentsCore.getLogger("chatDataStream");
+var logger25 = agentsCore.getLogger("chatDataStream");
 var chatDataStreamRoute = zodOpenapi.createRoute({
   method: "post",
   path: "/chat",
@@ -10128,7 +11009,7 @@ var chatDataStreamRoute = zodOpenapi.createRoute({
             ),
             id: zodOpenapi.z.string().optional(),
             conversationId: zodOpenapi.z.string().optional(),
-            requestContext: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional().describe("Context data for template processing")
+            headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional().describe("Headers data for template processing")
           })
         }
       }
@@ -10201,20 +11082,20 @@ app3.openapi(chatDataStreamRoute, async (c) => {
         message: "Agent not found"
       });
     }
-    const validatedContext = c.get("validatedContext") || body.requestContext || {};
+    const validatedContext = c.get("validatedContext") || body.headers || {};
     const credentialStores = c.get("credentialStores");
     await agentsCore.handleContextResolution({
       tenantId,
       projectId,
       graphId,
       conversationId,
-      requestContext: validatedContext,
+      headers: validatedContext,
       dbClient: dbClient_default,
       credentialStores
     });
     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("") || "";
-    logger23.info({ userText, lastUserMessage }, "userText");
+    logger25.info({ userText, lastUserMessage }, "userText");
     const messageSpan = api.trace.getActiveSpan();
     if (messageSpan) {
       messageSpan.setAttributes({
@@ -10243,6 +11124,8 @@ app3.openapi(chatDataStreamRoute, async (c) => {
       execute: async ({ writer }) => {
         const streamHelper = createVercelStreamHelper(writer);
         try {
+          const emitOperationsHeader = c.req.header("x-emit-operations");
+          const emitOperations = emitOperationsHeader === "true";
           const executionHandler = new ExecutionHandler();
           const result = await executionHandler.execute({
             executionContext,
@@ -10250,13 +11133,14 @@ app3.openapi(chatDataStreamRoute, async (c) => {
             userMessage: userText,
             initialAgentId: agentId,
             requestId: `chatds-${Date.now()}`,
-            sseHelper: streamHelper
+            sseHelper: streamHelper,
+            emitOperations
           });
           if (!result.success) {
             await streamHelper.writeOperation(errorOp("Unable to process request", "system"));
           }
         } catch (err) {
-          logger23.error({ err }, "Streaming error");
+          logger25.error({ err }, "Streaming error");
           await streamHelper.writeOperation(errorOp("Internal server error", "system"));
         } finally {
           if ("cleanup" in streamHelper && typeof streamHelper.cleanup === "function") {
@@ -10277,7 +11161,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
       )
     );
   } catch (error) {
-    logger23.error({ error }, "chatDataStream error");
+    logger25.error({ error }, "chatDataStream error");
     throw agentsCore.createApiError({
       code: "internal_server_error",
       message: "Failed to process chat completion"
@@ -10292,7 +11176,7 @@ init_logger();
 function createMCPSchema(schema) {
   return schema;
 }
-var logger24 = agentsCore.getLogger("mcp");
+var logger26 = agentsCore.getLogger("mcp");
 var _MockResponseSingleton = class _MockResponseSingleton {
   constructor() {
     __publicField(this, "mockRes");
@@ -10347,21 +11231,21 @@ var createSpoofInitMessage = (mcpProtocolVersion) => ({
   id: 0
 });
 var spoofTransportInitialization = async (transport, req, sessionId, mcpProtocolVersion) => {
-  logger24.info({ sessionId }, "Spoofing initialization message to set transport state");
+  logger26.info({ sessionId }, "Spoofing initialization message to set transport state");
   const spoofInitMessage = createSpoofInitMessage(mcpProtocolVersion);
   const mockRes = MockResponseSingleton.getInstance().getMockResponse();
   try {
     await transport.handleRequest(req, mockRes, spoofInitMessage);
-    logger24.info({ sessionId }, "Successfully spoofed initialization");
+    logger26.info({ sessionId }, "Successfully spoofed initialization");
   } catch (spoofError) {
-    logger24.warn({ sessionId, error: spoofError }, "Spoof initialization failed, continuing anyway");
+    logger26.warn({ sessionId, error: spoofError }, "Spoof initialization failed, continuing anyway");
   }
 };
 var validateSession = async (req, res, body, tenantId, projectId, graphId) => {
   const sessionId = req.headers["mcp-session-id"];
-  logger24.info({ sessionId }, "Received MCP session ID");
+  logger26.info({ sessionId }, "Received MCP session ID");
   if (!sessionId) {
-    logger24.info({ body }, "Missing session ID");
+    logger26.info({ body }, "Missing session ID");
     res.writeHead(400).end(
       JSON.stringify({
         jsonrpc: "2.0",
@@ -10387,7 +11271,7 @@ var validateSession = async (req, res, body, tenantId, projectId, graphId) => {
     scopes: { tenantId, projectId },
     conversationId: sessionId
   });
-  logger24.info(
+  logger26.info(
     {
       sessionId,
       conversationFound: !!conversation,
@@ -10398,7 +11282,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) {
-    logger24.info(
+    logger26.info(
       { sessionId, conversationId: conversation?.id },
       "MCP session not found or invalid"
     );
@@ -10459,7 +11343,7 @@ var executeAgentQuery = async (executionContext, conversationId, query, defaultA
     requestId: requestId2,
     sseHelper: mcpStreamHelper
   });
-  logger24.info(
+  logger26.info(
     { result },
     `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
   );
@@ -10483,7 +11367,7 @@ var executeAgentQuery = async (executionContext, conversationId, query, defaultA
     ]
   };
 };
-var getServer = async (requestContext, executionContext, conversationId, credentialStores) => {
+var getServer = async (headers, executionContext, conversationId, credentialStores) => {
   const { tenantId, projectId, graphId } = executionContext;
   setupTracing(conversationId, tenantId, graphId);
   const agentGraph = await agentsCore.getAgentGraphWithDefaultAgent(dbClient_default)({
@@ -10539,18 +11423,18 @@ var getServer = async (requestContext, executionContext, conversationId, credent
           projectId,
           graphId,
           conversationId,
-          requestContext,
+          headers,
           dbClient: dbClient_default,
           credentialStores
         });
-        logger24.info(
+        logger26.info(
           {
             tenantId,
             projectId,
             graphId,
             conversationId,
             hasContextConfig: !!agentGraph.contextConfigId,
-            hasRequestContext: !!requestContext,
+            hasHeaders: !!headers,
             hasValidatedContext: !!resolvedContext
           },
           "parameters"
@@ -10605,7 +11489,7 @@ var validateRequestParameters = (c) => {
 };
 var handleInitializationRequest = async (body, executionContext, validatedContext, req, res, c, credentialStores) => {
   const { tenantId, projectId, graphId } = executionContext;
-  logger24.info({ body }, "Received initialization request");
+  logger26.info({ body }, "Received initialization request");
   const sessionId = agentsCore.getConversationId();
   const agentGraph = await agentsCore.getAgentGraphWithDefaultAgent(dbClient_default)({
     scopes: { tenantId, projectId, graphId }
@@ -10645,7 +11529,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
       }
     }
   });
-  logger24.info(
+  logger26.info(
     { sessionId, conversationId: conversation.id },
     "Created MCP session as conversation"
   );
@@ -10654,9 +11538,9 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
   });
   const server = await getServer(validatedContext, executionContext, sessionId, credentialStores);
   await server.connect(transport);
-  logger24.info({ sessionId }, "Server connected for initialization");
+  logger26.info({ sessionId }, "Server connected for initialization");
   res.setHeader("Mcp-Session-Id", sessionId);
-  logger24.info(
+  logger26.info(
     {
       sessionId,
       bodyMethod: body?.method,
@@ -10665,7 +11549,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
     "About to handle initialization request"
   );
   await transport.handleRequest(req, res, body);
-  logger24.info({ sessionId }, "Successfully handled initialization request");
+  logger26.info({ sessionId }, "Successfully handled initialization request");
   return fetchToNode.toFetchResponse(res);
 };
 var handleExistingSessionRequest = async (body, executionContext, validatedContext, req, res, credentialStores) => {
@@ -10693,8 +11577,8 @@ var handleExistingSessionRequest = async (body, executionContext, validatedConte
     sessionId,
     conversation.metadata?.session_data?.mcpProtocolVersion
   );
-  logger24.info({ sessionId }, "Server connected and transport initialized");
-  logger24.info(
+  logger26.info({ sessionId }, "Server connected and transport initialized");
+  logger26.info(
     {
       sessionId,
       bodyKeys: Object.keys(body || {}),
@@ -10708,9 +11592,9 @@ var handleExistingSessionRequest = async (body, executionContext, validatedConte
   );
   try {
     await transport.handleRequest(req, res, body);
-    logger24.info({ sessionId }, "Successfully handled MCP request");
+    logger26.info({ sessionId }, "Successfully handled MCP request");
   } catch (transportError) {
-    logger24.error(
+    logger26.error(
       {
         sessionId,
         error: transportError,
@@ -10761,13 +11645,13 @@ app4.openapi(
       }
       const { executionContext } = paramValidation;
       const body = c.get("requestBody") || {};
-      logger24.info({ body, bodyKeys: Object.keys(body || {}) }, "Parsed request body");
+      logger26.info({ body, bodyKeys: Object.keys(body || {}) }, "Parsed request body");
       const isInitRequest = body.method === "initialize";
       const { req, res } = fetchToNode.toReqRes(c.req.raw);
       const validatedContext = c.get("validatedContext") || {};
       const credentialStores = c.get("credentialStores");
-      logger24.info({ validatedContext }, "Validated context");
-      logger24.info({ req }, "request");
+      logger26.info({ validatedContext }, "Validated context");
+      logger26.info({ req }, "request");
       if (isInitRequest) {
         return await handleInitializationRequest(
           body,
@@ -10789,7 +11673,7 @@ app4.openapi(
         );
       }
     } catch (e) {
-      logger24.error(
+      logger26.error(
         {
           error: e instanceof Error ? e.message : e,
           stack: e instanceof Error ? e.stack : void 0
@@ -10801,7 +11685,7 @@ app4.openapi(
   }
 );
 app4.get("/", async (c) => {
-  logger24.info({}, "Received GET MCP request");
+  logger26.info({}, "Received GET MCP request");
   return c.json(
     {
       jsonrpc: "2.0",
@@ -10815,7 +11699,7 @@ app4.get("/", async (c) => {
   );
 });
 app4.delete("/", async (c) => {
-  logger24.info({}, "Received DELETE MCP request");
+  logger26.info({}, "Received DELETE MCP request");
   return c.json(
     {
       jsonrpc: "2.0",
@@ -10828,7 +11712,7 @@ app4.delete("/", async (c) => {
 var mcp_default = app4;
 
 // src/app.ts
-var logger25 = agentsCore.getLogger("agents-run-api");
+var logger27 = agentsCore.getLogger("agents-run-api");
 function createExecutionHono(serverConfig, credentialStores) {
   const app6 = new zodOpenapi.OpenAPIHono();
   app6.use("*", otel.otel());
@@ -10844,7 +11728,7 @@ function createExecutionHono(serverConfig, credentialStores) {
         const body = await c.req.json();
         c.set("requestBody", body);
       } catch (error) {
-        logger25.debug({ error }, "Failed to parse JSON body, continuing without parsed body");
+        logger27.debug({ error }, "Failed to parse JSON body, continuing without parsed body");
       }
     }
     return next();
@@ -10895,8 +11779,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 (logger25) {
-          logger25.error(
+        if (logger27) {
+          logger27.error(
             {
               error: err,
               message: errorMessage,
@@ -10908,8 +11792,8 @@ function createExecutionHono(serverConfig, credentialStores) {
           );
         }
       } else {
-        if (logger25) {
-          logger25.error(
+        if (logger27) {
+          logger27.error(
             {
               error: err,
               path: c.req.path,
@@ -10926,8 +11810,8 @@ function createExecutionHono(serverConfig, credentialStores) {
         const response = err.getResponse();
         return response;
       } catch (responseError) {
-        if (logger25) {
-          logger25.error({ error: responseError }, "Error while handling HTTPException response");
+        if (logger27) {
+          logger27.error({ error: responseError }, "Error while handling HTTPException response");
         }
       }
     }
@@ -10961,7 +11845,7 @@ function createExecutionHono(serverConfig, credentialStores) {
   app6.use("*", async (c, next) => {
     const executionContext = c.get("executionContext");
     if (!executionContext) {
-      logger25.debug({}, "Empty execution context");
+      logger27.debug({}, "Empty execution context");
       return next();
     }
     const { tenantId, projectId, graphId } = executionContext;
@@ -10970,7 +11854,7 @@ function createExecutionHono(serverConfig, credentialStores) {
     if (requestBody) {
       conversationId = requestBody.conversationId;
       if (!conversationId) {
-        logger25.debug({ requestBody }, "No conversation ID found in request body");
+        logger27.debug({ requestBody }, "No conversation ID found in request body");
       }
     }
     const entries = Object.fromEntries(
@@ -10985,7 +11869,7 @@ function createExecutionHono(serverConfig, credentialStores) {
       })
     );
     if (!Object.keys(entries).length) {
-      logger25.debug({}, "Empty entries for baggage");
+      logger27.debug({}, "Empty entries for baggage");
       return next();
     }
     const bag = Object.entries(entries).reduce(