@inkeep/agents-run-api 0.0.0-dev-20251212052837 → 0.0.0-dev-20251212193302

package/dist/index.cjs

@@ -33,6 +33,7 @@ var streaming = require('hono/streaming');
 var ai = require('ai');
 var jmespath = require('jmespath');
 var Ajv = require('ajv');
+var zod = require('zod');
 var destr = require('destr');
 var traverse = require('traverse');
 var mcp_js = require('@alcyone-labs/modelcontextprotocol-sdk/server/mcp.js');
@@ -1240,7 +1241,7 @@ var init_chunk_VBDAOXYI = __esm({
       }], ["modifyTime", 12, 136, function(r, e) {
         return k4(r[e[0]], e[1]);
       }, function(r, e, t2) {
-        return z13(r.slice(e, e + t2[1]));
+        return z14(r.slice(e, e + t2[1]));
       }], ["checksum", 8, 148, function(r, e) {
         return "        ";
       }, function(r, e, t2) {
@@ -1282,11 +1283,11 @@ var init_chunk_VBDAOXYI = __esm({
       }], ["accessTime", 12, 476, function(r, e) {
         return k4(r[e[0]], e[1]);
       }, function(r, e, t2) {
-        return z13(r.slice(e, e + t2[1]));
+        return z14(r.slice(e, e + t2[1]));
       }], ["createTime", 12, 488, function(r, e) {
         return k4(r[e[0]], e[1]);
       }, function(r, e, t2) {
-        return z13(r.slice(e, e + t2[1]));
+        return z14(r.slice(e, e + t2[1]));
       }]], $4 = (function(r) {
         var e = r[r.length - 1];
         return e[2] + e[1];
@@ -1323,7 +1324,7 @@ var init_chunk_VBDAOXYI = __esm({
         var e = String.fromCharCode.apply(null, r);
         return parseInt(e.replace(/^0+$/g, ""), 8) || 0;
       }
-      function z13(r) {
+      function z14(r) {
         return r.length == 0 || r[0] == 0 ? null : new Date(1e3 * S3(r));
       }
       function Tr2(r, e, t2) {
@@ -1349,7 +1350,7 @@ var init_chunk_VBDAOXYI = __esm({
       f3.exports.formatTarDateTime = k4;
       f3.exports.parseTarString = A2;
       f3.exports.parseTarNumber = S3;
-      f3.exports.parseTarDateTime = z13;
+      f3.exports.parseTarDateTime = z14;
     });
     er = D((ne3, rr) => {
       u();
@@ -6519,19 +6520,19 @@ async function getConversationScopedArtifacts(params) {
     if (visibleMessageIds.length === 0) {
       return [];
     }
-    const { getLedgerArtifacts: getLedgerArtifacts3 } = await import('@inkeep/agents-core');
+    const { getLedgerArtifacts: getLedgerArtifacts4 } = await import('@inkeep/agents-core');
     const dbClient2 = (await Promise.resolve().then(() => (init_dbClient(), dbClient_exports))).default;
     const visibleTaskIds = visibleMessages.map((msg) => msg.taskId).filter((taskId) => Boolean(taskId));
     const referenceArtifacts = [];
     for (const taskId of visibleTaskIds) {
-      const artifacts = await getLedgerArtifacts3(dbClient2)({
+      const artifacts = await getLedgerArtifacts4(dbClient2)({
         scopes: { tenantId, projectId },
         taskId
       });
       referenceArtifacts.push(...artifacts);
     }
-    const logger28 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
-    logger28.debug(
+    const logger30 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
+    logger30.debug(
       {
         conversationId,
         visibleMessages: visibleMessages.length,
@@ -6543,8 +6544,8 @@ async function getConversationScopedArtifacts(params) {
     );
     return referenceArtifacts;
   } catch (error) {
-    const logger28 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
-    logger28.error(
+    const logger30 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
+    logger30.error(
       {
         error: error instanceof Error ? error.message : "Unknown error",
         conversationId
@@ -6586,14 +6587,14 @@ const execute = ${executeCode}
 })();
 `;
 }
-function parseExecutionResult(stdout, functionId, logger28) {
+function parseExecutionResult(stdout, functionId, logger30) {
   try {
     const outputLines = stdout.split("\n").filter((line) => line.trim());
     const resultLine = outputLines[outputLines.length - 1];
     return JSON.parse(resultLine);
   } catch (parseError) {
-    if (logger28) {
-      logger28.warn(
+    if (logger30) {
+      logger30.warn(
         {
           functionId,
           stdout,
@@ -6609,13 +6610,13 @@ var init_sandbox_utils = __esm({
   "src/tools/sandbox-utils.ts"() {
   }
 });
-var logger15, ExecutionSemaphore, NativeSandboxExecutor;
+var logger17, ExecutionSemaphore, NativeSandboxExecutor;
 var init_NativeSandboxExecutor = __esm({
   "src/tools/NativeSandboxExecutor.ts"() {
     init_execution_limits();
     init_logger();
     init_sandbox_utils();
-    logger15 = agentsCore.getLogger("native-sandbox-executor");
+    logger17 = agentsCore.getLogger("native-sandbox-executor");
     ExecutionSemaphore = class {
       permits;
       waitQueue = [];
@@ -6687,7 +6688,7 @@ var init_NativeSandboxExecutor = __esm({
       getSemaphore(vcpus) {
         const effectiveVcpus = Math.max(1, vcpus || 1);
         if (!this.executionSemaphores.has(effectiveVcpus)) {
-          logger15.debug({ vcpus: effectiveVcpus }, "Creating new execution semaphore");
+          logger17.debug({ vcpus: effectiveVcpus }, "Creating new execution semaphore");
           this.executionSemaphores.set(effectiveVcpus, new ExecutionSemaphore(effectiveVcpus));
         }
         const semaphore = this.executionSemaphores.get(effectiveVcpus);
@@ -6724,7 +6725,7 @@ var init_NativeSandboxExecutor = __esm({
           if (now - sandbox.lastUsed < FUNCTION_TOOL_SANDBOX_POOL_TTL_MS && sandbox.useCount < FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) {
             sandbox.lastUsed = now;
             sandbox.useCount++;
-            logger15.debug(
+            logger17.debug(
               {
                 poolKey,
                 useCount: sandbox.useCount,
@@ -6751,14 +6752,14 @@ var init_NativeSandboxExecutor = __esm({
           useCount: 1,
           dependencies
         };
-        logger15.debug({ poolKey, sandboxDir }, "Added sandbox to pool");
+        logger17.debug({ poolKey, sandboxDir }, "Added sandbox to pool");
       }
       cleanupSandbox(sandboxDir) {
         try {
           s3.rmSync(sandboxDir, { recursive: true, force: true });
-          logger15.debug({ sandboxDir }, "Cleaned up sandbox");
+          logger17.debug({ sandboxDir }, "Cleaned up sandbox");
         } catch (error) {
-          logger15.warn({ sandboxDir, error }, "Failed to clean up sandbox");
+          logger17.warn({ sandboxDir, error }, "Failed to clean up sandbox");
         }
       }
       startPoolCleanup() {
@@ -6775,7 +6776,7 @@ var init_NativeSandboxExecutor = __esm({
             delete this.sandboxPool[key];
           });
           if (keysToDelete.length > 0) {
-            logger15.debug({ cleanedCount: keysToDelete.length }, "Cleaned up expired sandboxes");
+            logger17.debug({ cleanedCount: keysToDelete.length }, "Cleaned up expired sandboxes");
           }
         }, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS);
       }
@@ -6804,7 +6805,7 @@ var init_NativeSandboxExecutor = __esm({
           return hasCjsSyntax ? "cjs" : "esm";
         }
         if (hasEsmSyntax && hasCjsSyntax) {
-          logger15.warn(
+          logger17.warn(
             { executeCode: `${executeCode.substring(0, 100)}...` },
             "Both ESM and CommonJS syntax detected, defaulting to ESM"
           );
@@ -6821,7 +6822,7 @@ var init_NativeSandboxExecutor = __esm({
       async executeFunctionTool(toolId, args2, config) {
         const vcpus = config.sandboxConfig?.vcpus || 1;
         const semaphore = this.getSemaphore(vcpus);
-        logger15.debug(
+        logger17.debug(
           {
             toolId,
             vcpus,
@@ -6839,7 +6840,7 @@ var init_NativeSandboxExecutor = __esm({
       async executeInSandbox_Internal(toolId, args2, config) {
         const dependencies = config.dependencies || {};
         const dependencyHash = this.generateDependencyHash(dependencies);
-        logger15.debug(
+        logger17.debug(
           {
             toolId,
             dependencies,
@@ -6855,7 +6856,7 @@ var init_NativeSandboxExecutor = __esm({
           sandboxDir = o3.join(this.tempDir, `sandbox-${dependencyHash}-${Date.now()}`);
           s3.mkdirSync(sandboxDir, { recursive: true });
           isNewSandbox = true;
-          logger15.debug(
+          logger17.debug(
             {
               toolId,
               dependencyHash,
@@ -6926,15 +6927,15 @@ var init_NativeSandboxExecutor = __esm({
           });
           npm.on("close", (code) => {
             if (code === 0) {
-              logger15.debug({ sandboxDir }, "Dependencies installed successfully");
+              logger17.debug({ sandboxDir }, "Dependencies installed successfully");
               resolve2();
             } else {
-              logger15.error({ sandboxDir, code, stderr }, "Failed to install dependencies");
+              logger17.error({ sandboxDir, code, stderr }, "Failed to install dependencies");
               reject(new Error(`npm install failed with code ${code}: ${stderr}`));
             }
           });
           npm.on("error", (err2) => {
-            logger15.error({ sandboxDir, error: err2 }, "Failed to spawn npm install");
+            logger17.error({ sandboxDir, error: err2 }, "Failed to spawn npm install");
             reject(err2);
           });
         });
@@ -6981,7 +6982,7 @@ var init_NativeSandboxExecutor = __esm({
             stderr += dataStr;
           });
           const timeoutId = setTimeout(() => {
-            logger15.warn({ sandboxDir, timeout }, "Function execution timed out, killing process");
+            logger17.warn({ sandboxDir, timeout }, "Function execution timed out, killing process");
             node.kill("SIGTERM");
             const forceKillTimeout = Math.min(Math.max(timeout / 10, 2e3), 5e3);
             setTimeout(() => {
@@ -6996,7 +6997,7 @@ var init_NativeSandboxExecutor = __esm({
             clearTimeout(timeoutId);
             if (code === 0) {
               try {
-                const result = parseExecutionResult(stdout, "function", logger15);
+                const result = parseExecutionResult(stdout, "function", logger17);
                 if (typeof result === "object" && result !== null && "success" in result) {
                   const parsed = result;
                   if (parsed.success) {
@@ -7008,18 +7009,18 @@ var init_NativeSandboxExecutor = __esm({
                   resolve2(result);
                 }
               } catch (parseError) {
-                logger15.error({ stdout, stderr, parseError }, "Failed to parse function result");
+                logger17.error({ stdout, stderr, parseError }, "Failed to parse function result");
                 reject(new Error(`Invalid function result: ${stdout}`));
               }
             } else {
               const errorMsg = signal ? `Function execution killed by signal ${signal}: ${stderr}` : `Function execution failed with code ${code}: ${stderr}`;
-              logger15.error({ code, signal, stderr }, "Function execution failed");
+              logger17.error({ code, signal, stderr }, "Function execution failed");
               reject(new Error(errorMsg));
             }
           });
           node.on("error", (error) => {
             clearTimeout(timeoutId);
-            logger15.error({ sandboxDir, error }, "Failed to spawn node process");
+            logger17.error({ sandboxDir, error }, "Failed to spawn node process");
             reject(error);
           });
         });
@@ -7027,13 +7028,13 @@ var init_NativeSandboxExecutor = __esm({
     };
   }
 });
-var logger16, VercelSandboxExecutor;
+var logger18, VercelSandboxExecutor;
 var init_VercelSandboxExecutor = __esm({
   "src/tools/VercelSandboxExecutor.ts"() {
     init_execution_limits();
     init_logger();
     init_sandbox_utils();
-    logger16 = agentsCore.getLogger("VercelSandboxExecutor");
+    logger18 = agentsCore.getLogger("VercelSandboxExecutor");
     VercelSandboxExecutor = class _VercelSandboxExecutor {
       static instance;
       config;
@@ -7041,7 +7042,7 @@ var init_VercelSandboxExecutor = __esm({
       cleanupInterval = null;
       constructor(config) {
         this.config = config;
-        logger16.info(
+        logger18.info(
           {
             teamId: config.teamId,
             projectId: config.projectId,
@@ -7078,7 +7079,7 @@ var init_VercelSandboxExecutor = __esm({
         const now = Date.now();
         const age = now - cached.createdAt;
         if (age > FUNCTION_TOOL_SANDBOX_POOL_TTL_MS || cached.useCount >= FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) {
-          logger16.debug(
+          logger18.debug(
             {
               dependencyHash,
               age,
@@ -7091,7 +7092,7 @@ var init_VercelSandboxExecutor = __esm({
           this.removeSandbox(dependencyHash);
           return null;
         }
-        logger16.debug(
+        logger18.debug(
           {
             dependencyHash,
             useCount: cached.useCount,
@@ -7111,7 +7112,7 @@ var init_VercelSandboxExecutor = __esm({
           useCount: 0,
           dependencies
         });
-        logger16.debug(
+        logger18.debug(
           {
             dependencyHash,
             poolSize: this.sandboxPool.size
@@ -7136,9 +7137,9 @@ var init_VercelSandboxExecutor = __esm({
         if (cached) {
           try {
             await cached.sandbox.stop();
-            logger16.debug({ dependencyHash }, "Sandbox stopped");
+            logger18.debug({ dependencyHash }, "Sandbox stopped");
           } catch (error) {
-            logger16.warn({ error, dependencyHash }, "Error stopping sandbox");
+            logger18.warn({ error, dependencyHash }, "Error stopping sandbox");
           }
           this.sandboxPool.delete(dependencyHash);
         }
@@ -7157,7 +7158,7 @@ var init_VercelSandboxExecutor = __esm({
             }
           }
           if (toRemove.length > 0) {
-            logger16.info(
+            logger18.info(
               {
                 count: toRemove.length,
                 poolSize: this.sandboxPool.size
@@ -7178,7 +7179,7 @@ var init_VercelSandboxExecutor = __esm({
           clearInterval(this.cleanupInterval);
           this.cleanupInterval = null;
         }
-        logger16.info(
+        logger18.info(
           {
             poolSize: this.sandboxPool.size
           },
@@ -7215,7 +7216,7 @@ var init_VercelSandboxExecutor = __esm({
         const envLines = [];
         for (const varName of envVarNames) {
           envLines.push(`${varName}=""`);
-          logger16.debug({ varName }, "Adding environment variable placeholder to sandbox");
+          logger18.debug({ varName }, "Adding environment variable placeholder to sandbox");
         }
         return envLines.join("\n");
       }
@@ -7228,7 +7229,7 @@ var init_VercelSandboxExecutor = __esm({
         const dependencies = toolConfig.dependencies || {};
         const dependencyHash = this.generateDependencyHash(dependencies);
         try {
-          logger16.info(
+          logger18.info(
             {
               functionId,
               functionName: toolConfig.name,
@@ -7251,7 +7252,7 @@ var init_VercelSandboxExecutor = __esm({
               },
               runtime: this.config.runtime
             });
-            logger16.info(
+            logger18.info(
               {
                 functionId,
                 sandboxId: sandbox$1.sandboxId,
@@ -7261,7 +7262,7 @@ var init_VercelSandboxExecutor = __esm({
             );
             this.addToPool(dependencyHash, sandbox$1, dependencies);
           } else {
-            logger16.info(
+            logger18.info(
               {
                 functionId,
                 sandboxId: sandbox$1.sandboxId,
@@ -7273,7 +7274,7 @@ var init_VercelSandboxExecutor = __esm({
           this.incrementUseCount(dependencyHash);
           try {
             if (isNewSandbox && toolConfig.dependencies && Object.keys(toolConfig.dependencies).length > 0) {
-              logger16.debug(
+              logger18.debug(
                 {
                   functionId,
                   functionName: toolConfig.name,
@@ -7306,7 +7307,7 @@ var init_VercelSandboxExecutor = __esm({
               if (installCmd.exitCode !== 0) {
                 throw new Error(`Failed to install dependencies: ${installStderr}`);
               }
-              logger16.info(
+              logger18.info(
                 {
                   functionId,
                   dependencyHash
@@ -7329,7 +7330,7 @@ var init_VercelSandboxExecutor = __esm({
                   path: ".env",
                   content: Buffer.from(envFileContent, "utf-8")
                 });
-                logger16.info(
+                logger18.info(
                   {
                     functionId,
                     envVarCount: envVars.size,
@@ -7340,7 +7341,7 @@ var init_VercelSandboxExecutor = __esm({
               }
             }
             await sandbox$1.writeFiles(filesToWrite);
-            logger16.info(
+            logger18.info(
               {
                 functionId,
                 runtime: this.config.runtime === "typescript" ? "tsx" : "node",
@@ -7371,7 +7372,7 @@ var init_VercelSandboxExecutor = __esm({
             }
             const executionTime = Date.now() - startTime;
             if (executeCmd.exitCode !== 0) {
-              logger16.error(
+              logger18.error(
                 {
                   functionId,
                   exitCode: executeCmd.exitCode,
@@ -7386,8 +7387,8 @@ var init_VercelSandboxExecutor = __esm({
                 executionTime
               };
             }
-            const result = parseExecutionResult(executeStdout, functionId, logger16);
-            logger16.info(
+            const result = parseExecutionResult(executeStdout, functionId, logger18);
+            logger18.info(
               {
                 functionId,
                 executionTime
@@ -7407,7 +7408,7 @@ var init_VercelSandboxExecutor = __esm({
         } catch (error) {
           const executionTime = Date.now() - startTime;
           const errorMessage = error instanceof Error ? error.message : String(error);
-          logger16.error(
+          logger18.error(
             {
               functionId,
               error: errorMessage,
@@ -7432,19 +7433,19 @@ var SandboxExecutorFactory_exports = {};
 __export(SandboxExecutorFactory_exports, {
   SandboxExecutorFactory: () => SandboxExecutorFactory
 });
-var logger17, SandboxExecutorFactory;
+var logger19, SandboxExecutorFactory;
 var init_SandboxExecutorFactory = __esm({
   "src/tools/SandboxExecutorFactory.ts"() {
     init_logger();
     init_NativeSandboxExecutor();
     init_VercelSandboxExecutor();
-    logger17 = agentsCore.getLogger("SandboxExecutorFactory");
+    logger19 = agentsCore.getLogger("SandboxExecutorFactory");
     SandboxExecutorFactory = class _SandboxExecutorFactory {
       static instance;
       nativeExecutor = null;
       vercelExecutors = /* @__PURE__ */ new Map();
       constructor() {
-        logger17.info({}, "SandboxExecutorFactory initialized");
+        logger19.info({}, "SandboxExecutorFactory initialized");
       }
       /**
        * Get singleton instance of SandboxExecutorFactory
@@ -7477,7 +7478,7 @@ var init_SandboxExecutorFactory = __esm({
       async executeInNativeSandbox(functionId, args2, config) {
         if (!this.nativeExecutor) {
           this.nativeExecutor = NativeSandboxExecutor.getInstance();
-          logger17.info({}, "Native sandbox executor created");
+          logger19.info({}, "Native sandbox executor created");
         }
         return this.nativeExecutor.executeFunctionTool(functionId, args2, config);
       }
@@ -7490,7 +7491,7 @@ var init_SandboxExecutorFactory = __esm({
         if (!this.vercelExecutors.has(configKey)) {
           const executor2 = VercelSandboxExecutor.getInstance(vercelConfig);
           this.vercelExecutors.set(configKey, executor2);
-          logger17.info(
+          logger19.info(
             {
               teamId: vercelConfig.teamId,
               projectId: vercelConfig.projectId
@@ -7512,13 +7513,13 @@ var init_SandboxExecutorFactory = __esm({
        * Clean up all sandbox executors
        */
       async cleanup() {
-        logger17.info({}, "Cleaning up sandbox executors");
+        logger19.info({}, "Cleaning up sandbox executors");
         this.nativeExecutor = null;
         for (const [key, executor] of this.vercelExecutors.entries()) {
           await executor.cleanup();
           this.vercelExecutors.delete(key);
         }
-        logger17.info({}, "Sandbox executor cleanup completed");
+        logger19.info({}, "Sandbox executor cleanup completed");
       }
     };
   }
@@ -9236,7 +9237,7 @@ var ArtifactService = class _ArtifactService {
     const summaryValidation = validateAgainstSchema(summaryData, previewSchema);
     const fullValidation = validateAgainstSchema(fullData, fullSchema);
     if (!summaryValidation.hasRequiredFields) {
-      const error = new Error(
+      new Error(
         `Cannot save artifact: Missing required fields [${summaryValidation.missingRequired.join(", ")}] for '${artifactType}' schema. Required: [${summaryValidation.missingRequired.join(", ")}]. Found: [${summaryValidation.actualFields.join(", ")}]. Consider using a different artifact component type that matches your data structure.`
       );
       logger6.error(
@@ -9247,9 +9248,13 @@ var ArtifactService = class _ArtifactService {
           actualFields: summaryValidation.actualFields,
           schemaExpected: previewSchema?.properties ? Object.keys(previewSchema.properties) : []
         },
-        "Blocking artifact save due to missing required fields"
+        "Artifact creation failed due to missing required fields - continuing with generation"
       );
-      throw error;
+      return {
+        summary: summaryValidation,
+        full: fullValidation,
+        schemaFound: !!previewSchema
+      };
     }
     if (!summaryValidation.hasExpectedFields || summaryValidation.extraFields.length > 0) {
       logger6.warn(
@@ -9399,7 +9404,7 @@ var ArtifactService = class _ArtifactService {
    * Used by AgentSession to save artifacts after name/description generation
    */
   async saveArtifact(artifact) {
-    let summaryData = artifact.data;
+    let summaryData = artifact.summaryData || artifact.data;
     let fullData = artifact.data;
     if (this.context.artifactComponents) {
       const artifactComponent = this.context.artifactComponents.find(
@@ -9987,7 +9992,6 @@ var AgentSession = class {
    * Send data operation to stream when emit operations is enabled
    */
   async sendDataOperation(event) {
-    console.log("sendDataOperation called with event", Date.now());
     try {
       const streamHelper = getStreamHelper(this.sessionId);
       if (streamHelper) {
@@ -10038,6 +10042,8 @@ var AgentSession = class {
         return `Task completed: ${event.data.targetSubAgent} \u2192 ${event.data.fromSubAgent}`;
       case "artifact_saved":
         return `Artifact saved: ${event.data.artifactType || "unknown type"}`;
+      case "compression":
+        return `Compressed ${event.data.messageCount} messages and ${event.data.artifactCount} artifacts (${event.data.reason})`;
       default:
         return `${event.eventType} event`;
     }
@@ -10920,17 +10926,59 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
             (event) => event.eventType === "tool_result" && event.data && "toolCallId" in event.data && event.data.toolCallId === artifactData.metadata?.toolCallId
           );
           const toolContext = toolCallEvent ? {
-            toolName: toolCallEvent.data.toolName,
             args: toolCallEvent.data.args
           } : null;
-          const prompt = `Name this artifact (max 50 chars) and describe it (max 150 chars).
+          let existingNames = [];
+          try {
+            if (artifactData.tenantId && artifactData.projectId && artifactData.taskId) {
+              const existingArtifacts = await agentsCore.getLedgerArtifacts(dbClient_default)({
+                scopes: { tenantId: artifactData.tenantId, projectId: artifactData.projectId },
+                taskId: artifactData.taskId
+              });
+              existingNames = existingArtifacts.map((a2) => a2.name).filter(Boolean);
+            }
+          } catch (error) {
+            logger8.warn(
+              {
+                sessionId: this.sessionId,
+                artifactId: artifactData.artifactId,
+                error: error instanceof Error ? error.message : "Unknown error"
+              },
+              "Failed to fetch existing artifact names for context"
+            );
+          }
+          const toolName = artifactData.metadata?.toolName || "unknown";
+          const toolCallId = artifactData.metadata?.toolCallId || "unknown";
+          const prompt = `Create a unique name and description for this tool result artifact.
+
+CRITICAL: Your name must be different from these existing artifacts: ${existingNames.length > 0 ? existingNames.join(", ") : "None yet"}
 
-Tool Context: ${toolContext ? JSON.stringify(toolContext, null, 2) : "No tool context"}
-Context: ${conversationHistory?.slice(-200) || "Processing"}
+Tool Context: ${toolContext ? JSON.stringify(toolContext.args, null, 2) : "No args"}
+Context: ${conversationHistory?.slice(-200) || "No context"}
 Type: ${artifactData.artifactType || "data"}
-Data: ${JSON.stringify(artifactData.data || artifactData.summaryData, null, 2)}
+Data: ${JSON.stringify(artifactData.data || artifactData.summaryData || {}, null, 2)}
+
+Requirements:
+- Name: Max 50 chars, be extremely specific to THIS EXACT tool execution
+- Description: Max 150 chars, describe what THIS SPECIFIC tool call returned  
+- Focus on the unique aspects of this particular tool execution result
+- Be descriptive about the actual content returned, not just the tool type
+
+BAD Examples (too generic):
+- "Search Results"
+- "Tool Results" 
+- "${toolName} Results"
+- "Data from ${toolName}"
+- "Tool Output"
+- "Search Data"
+
+GOOD Examples:
+- "GitHub API Rate Limits & Auth Methods"
+- "React Component Props Documentation"
+- "Database Schema for User Tables"
+- "Pricing Tiers with Enterprise Features"
 
-Make it specific and relevant.`;
+Make the name extremely specific to what this tool call actually returned, not generic.`;
           let modelToUse = this.statusUpdateState?.summarizerModel;
           if (!modelToUse?.model?.trim()) {
             if (!this.statusUpdateState?.baseModel?.model?.trim()) {
@@ -10984,9 +11032,10 @@ Make it specific and relevant.`;
           }
           let result;
           if (!modelToUse) {
+            const toolCallSuffix = artifactData.metadata?.toolCallId?.slice(-8) || Date.now().toString().slice(-8);
             result = {
-              name: `Artifact ${artifactData.artifactId.substring(0, 8)}`,
-              description: `${artifactData.artifactType || "Data"} from ${artifactData.metadata?.toolCallId || "tool results"}`
+              name: `${artifactData.artifactType || "Artifact"} ${toolCallSuffix}`,
+              description: `${artifactData.artifactType || "Data"} from ${artifactData.metadata?.toolName || "tool"} (${artifactData.metadata?.toolCallId || "tool results"})`
             };
           } else {
             const model = agentsCore.ModelFactory.createModel(modelToUse);
@@ -11081,6 +11130,21 @@ Make it specific and relevant.`;
             );
             result = object;
           }
+          if (existingNames.includes(result.name)) {
+            const toolCallSuffix = toolCallId.slice(-8);
+            const originalName = result.name;
+            result.name = result.name.length + toolCallSuffix.length + 1 <= 50 ? `${result.name} ${toolCallSuffix}` : `${result.name.substring(0, 50 - toolCallSuffix.length - 1)} ${toolCallSuffix}`;
+            logger8.info(
+              {
+                sessionId: this.sessionId,
+                artifactId: artifactData.artifactId,
+                originalName,
+                uniqueName: result.name,
+                reason: "Name conflict resolved with toolCallId suffix"
+              },
+              "Updated artifact name for uniqueness"
+            );
+          }
           try {
             if (!this.artifactService) {
               throw new Error("ArtifactService is not initialized");
@@ -11091,6 +11155,7 @@ Make it specific and relevant.`;
               description: result.description,
               type: artifactData.artifactType || "source",
               data: artifactData.data || {},
+              summaryData: artifactData.summaryData,
               metadata: artifactData.metadata || {},
               toolCallId: artifactData.toolCallId
             });
@@ -11106,7 +11171,13 @@ Make it specific and relevant.`;
               {
                 sessionId: this.sessionId,
                 artifactId: artifactData.artifactId,
-                error: saveError instanceof Error ? saveError.message : "Unknown error"
+                error: saveError instanceof Error ? saveError.message : "Unknown error",
+                errorName: saveError instanceof Error ? saveError.name : void 0,
+                errorCause: saveError instanceof Error ? saveError.cause : void 0,
+                errorCode: saveError?.code || saveError?.errno || void 0,
+                artifactType: artifactData.artifactType,
+                dataKeys: artifactData.data ? Object.keys(artifactData.data) : [],
+                metadataKeys: artifactData.metadata ? Object.keys(artifactData.metadata) : []
               },
               "Main artifact save failed, will attempt fallback"
             );
@@ -11127,6 +11198,7 @@ Make it specific and relevant.`;
                   description: `${artifactData.artifactType || "Data"} from ${artifactData.metadata?.toolName || "tool results"}`,
                   type: artifactData.artifactType || "source",
                   data: artifactData.data || {},
+                  summaryData: artifactData.summaryData,
                   metadata: artifactData.metadata || {},
                   toolCallId: artifactData.toolCallId
                 });
@@ -11145,7 +11217,13 @@ Make it specific and relevant.`;
                   {
                     sessionId: this.sessionId,
                     artifactId: artifactData.artifactId,
-                    error: fallbackError instanceof Error ? fallbackError.message : "Unknown error"
+                    error: fallbackError instanceof Error ? fallbackError.message : "Unknown error",
+                    errorName: fallbackError instanceof Error ? fallbackError.name : void 0,
+                    errorCause: fallbackError instanceof Error ? fallbackError.cause : void 0,
+                    errorCode: fallbackError?.code || fallbackError?.errno || void 0,
+                    artifactType: artifactData.artifactType,
+                    dataKeys: artifactData.data ? Object.keys(artifactData.data) : [],
+                    metadataKeys: artifactData.metadata ? Object.keys(artifactData.metadata) : []
                   },
                   "Failed to save artifact even with fallback"
                 );
@@ -11791,9 +11869,660 @@ ${chunk}`;
   }
 };
 
+// src/services/MidGenerationCompressor.ts
+init_logger();
+
+// src/tools/distill-conversation-tool.ts
+init_logger();
+var logger10 = agentsCore.getLogger("distill-conversation-tool");
+var ConversationSummarySchema = zod.z.object({
+  type: zod.z.literal("conversation_summary_v1"),
+  session_id: zod.z.string().nullable().optional(),
+  high_level: zod.z.string().describe("1-3 sentences capturing what was discovered and learned"),
+  user_intent: zod.z.string().describe("Current main goal or what the user wants to accomplish"),
+  decisions: zod.z.array(zod.z.string()).describe("Concrete decisions made about approach or implementation (\u22645 items)"),
+  open_questions: zod.z.array(zod.z.string()).describe("Unresolved questions about the subject matter (\u22645 items)"),
+  next_steps: zod.z.object({
+    for_agent: zod.z.array(zod.z.string()).describe(
+      "Content-focused actions: what to discover, analyze, or present. Don't get trapped in an infinite loop of tool calls. You have already done a lot of work that is why you are being compressed. Don't encourage too much more work."
+    ),
+    for_user: zod.z.array(zod.z.string()).describe("Actions for user based on discovered content")
+  }),
+  related_artifacts: zod.z.array(
+    zod.z.object({
+      id: zod.z.string().describe("Artifact ID"),
+      name: zod.z.string().describe("Human-readable name describing the content"),
+      tool_name: zod.z.string().describe("Tool that generated this artifact (e.g. search-inkeep-docs)"),
+      tool_call_id: zod.z.string().describe("Specific tool call ID for precise referencing"),
+      content_type: zod.z.string().describe("Type of content (e.g. search_results, api_response, documentation)"),
+      key_findings: zod.z.array(zod.z.string()).describe("2-3 most important findings from this specific artifact")
+    })
+  ).optional().describe("Artifacts containing detailed findings with citation info")
+});
+async function distillConversation(params) {
+  const { messages, conversationId, currentSummary, summarizerModel, toolCallToArtifactMap } = params;
+  try {
+    const modelToUse = summarizerModel;
+    if (!modelToUse?.model?.trim()) {
+      throw new Error("Summarizer model is required");
+    }
+    const model = agentsCore.ModelFactory.createModel(modelToUse);
+    const existingSummaryContext = currentSummary ? `**Current summary:**
+
+\`\`\`json
+${JSON.stringify(currentSummary, null, 2)}
+\`\`\`` : "**Current summary:** None (first distillation)";
+    const formattedMessages = messages.map((msg) => {
+      const parts2 = [];
+      if (typeof msg.content === "string") {
+        parts2.push(msg.content);
+      } else if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === "text") {
+            parts2.push(block.text);
+          } else if (block.type === "tool-call") {
+            parts2.push(
+              `[TOOL CALL] ${block.toolName}(${JSON.stringify(block.input)}) [ID: ${block.toolCallId}]`
+            );
+          } else if (block.type === "tool-result") {
+            const artifactId = toolCallToArtifactMap?.[block.toolCallId];
+            const artifactInfo = artifactId ? `
+[ARTIFACT CREATED: ${artifactId}]` : "";
+            parts2.push(
+              `[TOOL RESULT] ${block.toolName} [ID: ${block.toolCallId}]${artifactInfo}
+Result: ${JSON.stringify(block.result)}`
+            );
+          }
+        }
+      } else if (msg.content?.text) {
+        parts2.push(msg.content.text);
+      }
+      return parts2.length > 0 ? `${msg.role || "system"}: ${parts2.join("\n")}` : "";
+    }).filter((line) => line.trim().length > 0).join("\n\n");
+    logger10.debug(
+      {
+        conversationId,
+        messageCount: messages.length,
+        formattedLength: formattedMessages.length,
+        sampleMessages: messages.slice(0, 2).map((m4) => ({ role: m4.role, contentType: typeof m4.content, hasContent: !!m4.content }))
+      },
+      "Formatting messages for distillation"
+    );
+    const prompt = `You are a conversation summarization assistant. Your job is to create or update a compact, structured summary that captures VALUABLE CONTENT and FINDINGS, not just operational details.
+
+${existingSummaryContext}
+
+**Messages to summarize:**
+
+\`\`\`text
+${formattedMessages}
+\`\`\`
+
+Create/update a summary using this exact JSON schema:
+
+\`\`\`json
+{
+  "type": "conversation_summary_v1",
+  "session_id": "<conversationId>",
+  "high_level": "<1\u20133 sentences capturing what was discovered and learned>",
+  "user_intent": "<current main goal>",
+  "decisions": ["<concrete decisions made>"],
+  "open_questions": ["<unresolved issues>"],
+  "next_steps": {
+    "for_agent": ["<what agent should do>"],
+    "for_user": ["<what user should do>"]
+  },
+  "related_artifacts": [
+    {
+      "id": "<artifact_id>",
+      "name": "<descriptive name>",
+      "tool_name": "<tool_name>",
+      "tool_call_id": "<tool_call_id>",
+      "content_type": "<search_results|api_response|documentation>",
+      "key_findings": ["<important finding 1>", "<important finding 2>"]
+    }
+  ]
+}
+\`\`\`
+
+**CRITICAL RULES - FOCUS ON CONTENT NOT OPERATIONS:**
+\u{1F3AF} **EXTRACT VALUABLE FINDINGS**: Capture the actual information discovered, data retrieved, insights gained
+\u{1F3AF} **IGNORE OPERATIONAL DETAILS**: Don't mention "tool was used", "artifact was created", "messages were compressed"
+\u{1F3AF} **PRESERVE SUBSTANCE**: Include specific facts, features, capabilities, configurations, results found
+\u{1F3AF} **BUILD KNOWLEDGE**: When updating existing summary, ADD new discoveries to existing knowledge
+\u{1F3AF} **BE CONCRETE**: Use specific details from tool results, not generic descriptions
+\u{1F3AF} **BE CONCISE**: Keep ALL fields brief - you are compressing to save context, not writing a report
+\u{1F3AF} **LIMIT NEXT STEPS**: Agent has already done substantial work - suggest minimal follow-up actions only
+
+**Examples:**
+\u274C BAD: "Assistant used search tool and created artifacts"
+\u2705 GOOD: "Inkeep supports streaming structured objects, OpenAI-compatible APIs, analytics logging, and Zendesk integration"
+
+\u274C BAD: "Tool calls were made to gather information"  
+\u2705 GOOD: "Platform includes 10 feature categories: chat widgets, knowledge base, analytics, integrations, theming options"
+
+**Focus on WHAT WAS LEARNED, not HOW IT WAS LEARNED**
+
+Return **only** valid JSON.`;
+    const { object: summary } = await ai.generateObject({
+      model,
+      prompt,
+      schema: ConversationSummarySchema
+    });
+    summary.session_id = conversationId;
+    logger10.info(
+      {
+        conversationId,
+        messageCount: messages.length,
+        artifactsCount: summary.related_artifacts?.length || 0,
+        decisionsCount: summary.decisions.length
+      },
+      "Successfully distilled conversation"
+    );
+    return summary;
+  } catch (error) {
+    logger10.error(
+      {
+        conversationId,
+        messageCount: messages.length,
+        error: error instanceof Error ? error.message : "Unknown error"
+      },
+      "Failed to distill conversation"
+    );
+    return {
+      type: "conversation_summary_v1",
+      session_id: conversationId,
+      high_level: "Ongoing conversation session",
+      user_intent: "Continue working on current task",
+      related_artifacts: [],
+      decisions: [],
+      open_questions: ["Review recent work and determine next steps"],
+      next_steps: {
+        for_agent: ["Continue with current task"],
+        for_user: ["Provide additional guidance if needed"]
+      }
+    };
+  }
+}
+
+// src/services/MidGenerationCompressor.ts
+var logger11 = agentsCore.getLogger("MidGenerationCompressor");
+function getCompressionConfigFromEnv() {
+  return {
+    hardLimit: parseInt(process.env.AGENTS_COMPRESSION_HARD_LIMIT || "120000"),
+    safetyBuffer: parseInt(process.env.AGENTS_COMPRESSION_SAFETY_BUFFER || "20000"),
+    enabled: process.env.AGENTS_COMPRESSION_ENABLED !== "false"
+    // Default enabled
+  };
+}
+var MidGenerationCompressor = class {
+  // Track cumulative summary across compression cycles
+  constructor(sessionId, conversationId, tenantId, projectId, config, summarizerModel, baseModel) {
+    this.sessionId = sessionId;
+    this.conversationId = conversationId;
+    this.tenantId = tenantId;
+    this.projectId = projectId;
+    this.config = config;
+    this.summarizerModel = summarizerModel;
+    this.baseModel = baseModel;
+  }
+  shouldCompress = false;
+  processedToolCalls = /* @__PURE__ */ new Set();
+  // Track already compressed tool call IDs
+  lastProcessedMessageIndex = 0;
+  // Track where we left off in message processing
+  cumulativeSummary = null;
+  /**
+   * Get the hard limit for compression decisions
+   */
+  getHardLimit() {
+    return this.config.hardLimit;
+  }
+  /**
+   * Estimate tokens (4 chars = 1 token)
+   */
+  estimateTokens(content) {
+    const text = typeof content === "string" ? content : JSON.stringify(content);
+    return Math.ceil(text.length / 4);
+  }
+  /**
+   * Calculate total context size
+   */
+  calculateContextSize(messages) {
+    const messageTokens = messages.reduce((total, msg) => {
+      let msgTokens = 0;
+      if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === "text") {
+            msgTokens += this.estimateTokens(block.text || "");
+          } else if (block.type === "tool-call") {
+            msgTokens += this.estimateTokens(
+              JSON.stringify({
+                toolCallId: block.toolCallId,
+                toolName: block.toolName,
+                input: block.input
+              })
+            );
+          } else if (block.type === "tool-result") {
+            msgTokens += this.estimateTokens(
+              JSON.stringify({
+                toolCallId: block.toolCallId,
+                toolName: block.toolName,
+                output: block.output
+              })
+            );
+          }
+        }
+      } else if (typeof msg.content === "string") {
+        msgTokens += this.estimateTokens(msg.content);
+      } else if (msg.content) {
+        msgTokens += this.estimateTokens(JSON.stringify(msg.content));
+      }
+      return total + msgTokens;
+    }, 0);
+    return messageTokens;
+  }
+  /**
+   * Manual compression request from LLM tool
+   */
+  requestManualCompression(reason) {
+    this.shouldCompress = true;
+    logger11.info(
+      {
+        sessionId: this.sessionId,
+        reason: reason || "Manual request from LLM"
+      },
+      "Manual compression requested"
+    );
+  }
+  /**
+   * Check if compression is needed (either automatic or manual)
+   */
+  isCompressionNeeded(messages) {
+    if (this.shouldCompress) return true;
+    const contextSize = this.calculateContextSize(messages);
+    const remaining = this.config.hardLimit - contextSize;
+    return remaining <= this.config.safetyBuffer;
+  }
+  /**
+   * Perform compression: save all tool results as artifacts and create summary
+   */
+  async compress(messages) {
+    const contextSizeBefore = this.calculateContextSize(messages);
+    logger11.info(
+      {
+        sessionId: this.sessionId,
+        messageCount: messages.length,
+        contextSize: contextSizeBefore
+      },
+      "COMPRESSION: Starting compression"
+    );
+    const toolResultCount = messages.reduce((count, msg) => {
+      if (Array.isArray(msg.content)) {
+        return count + msg.content.filter((block) => block.type === "tool-result").length;
+      }
+      return count;
+    }, 0);
+    logger11.debug({ toolResultCount }, "Tool results found for compression");
+    const toolCallToArtifactMap = await this.saveToolResultsAsArtifacts(messages);
+    const summary = await this.createConversationSummary(messages, toolCallToArtifactMap);
+    const contextSizeAfter = this.estimateTokens(JSON.stringify(summary));
+    const session = agentSessionManager.getSession(this.sessionId);
+    if (session) {
+      const wasManualRequest = this.shouldCompress;
+      session.recordEvent("compression", this.sessionId, {
+        reason: wasManualRequest ? "manual" : "automatic",
+        messageCount: messages.length,
+        artifactCount: Object.keys(toolCallToArtifactMap).length,
+        contextSizeBefore,
+        contextSizeAfter,
+        compressionType: "mid_generation"
+      });
+    }
+    this.shouldCompress = false;
+    logger11.info(
+      {
+        sessionId: this.sessionId,
+        artifactsCreated: Object.keys(toolCallToArtifactMap).length,
+        messageCount: messages.length,
+        contextSizeBefore,
+        contextSizeAfter,
+        artifactIds: Object.values(toolCallToArtifactMap)
+      },
+      "COMPRESSION: Compression completed successfully"
+    );
+    return { artifactIds: Object.values(toolCallToArtifactMap), summary };
+  }
+  /**
+   * 1. Save NEW tool results as artifacts (only process messages since last compression)
+   */
+  async saveToolResultsAsArtifacts(messages) {
+    const session = agentSessionManager.getSession(this.sessionId);
+    if (!session) {
+      throw new Error(`No session found: ${this.sessionId}`);
+    }
+    const toolCallToArtifactMap = {};
+    const newMessages = messages.slice(this.lastProcessedMessageIndex);
+    logger11.debug(
+      {
+        totalMessages: messages.length,
+        newMessages: newMessages.length,
+        startIndex: this.lastProcessedMessageIndex
+      },
+      "Starting compression artifact processing"
+    );
+    for (const message of newMessages) {
+      if (Array.isArray(message.content)) {
+        for (const block of message.content) {
+          if (block.type === "tool-result") {
+            if (block.toolName === "get_reference_artifact" || block.toolName === "thinking_complete") {
+              logger11.debug(
+                {
+                  toolCallId: block.toolCallId,
+                  toolName: block.toolName
+                },
+                "Skipping special tool - not creating artifacts"
+              );
+              this.processedToolCalls.add(block.toolCallId);
+              continue;
+            }
+            if (this.processedToolCalls.has(block.toolCallId)) {
+              logger11.debug(
+                {
+                  toolCallId: block.toolCallId,
+                  toolName: block.toolName
+                },
+                "Skipping already processed tool call"
+              );
+              continue;
+            }
+            const artifactId = `compress_${block.toolName || "tool"}_${block.toolCallId || Date.now()}_${crypto2.randomUUID().slice(0, 8)}`;
+            logger11.debug(
+              {
+                artifactId,
+                toolName: block.toolName,
+                toolCallId: block.toolCallId
+              },
+              "Saving compression artifact"
+            );
+            let toolInput = null;
+            if (Array.isArray(message.content)) {
+              const toolCall = message.content.find(
+                (b3) => b3.type === "tool-call" && b3.toolCallId === block.toolCallId
+              );
+              toolInput = toolCall?.input;
+            }
+            const cleanToolResult = this.removeStructureHints(block.output);
+            const toolResultData = {
+              toolName: block.toolName,
+              toolInput,
+              toolResult: cleanToolResult,
+              compressedAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            if (this.isEmpty(toolResultData)) {
+              logger11.debug(
+                {
+                  toolName: block.toolName,
+                  toolCallId: block.toolCallId
+                },
+                "Skipping empty tool result"
+              );
+              continue;
+            }
+            const artifactData = {
+              artifactId,
+              taskId: `task_${this.conversationId}-${this.sessionId}`,
+              toolCallId: block.toolCallId,
+              artifactType: "tool_result",
+              pendingGeneration: true,
+              // Triggers LLM-generated name/description
+              tenantId: this.tenantId,
+              projectId: this.projectId,
+              contextId: this.conversationId,
+              subAgentId: this.sessionId,
+              metadata: {
+                toolCallId: block.toolCallId,
+                toolName: block.toolName,
+                compressionReason: "mid_generation_context_limit"
+              },
+              // Pass data in the format expected by ArtifactSavedData interface
+              summaryData: {
+                toolName: block.toolName,
+                note: "Compressed tool result - see full data for details"
+              },
+              data: toolResultData
+              // Full tool result data
+            };
+            const fullData = artifactData.data;
+            const hasFullData = fullData && typeof fullData === "object" && Object.keys(fullData).length > 0 && // Check if toolResult specifically has content
+            fullData.toolResult && (typeof fullData.toolResult !== "object" || Object.keys(fullData.toolResult).length > 0);
+            if (!hasFullData) {
+              logger11.debug(
+                {
+                  artifactId,
+                  toolName: block.toolName,
+                  toolCallId: block.toolCallId
+                },
+                "Skipping empty compression artifact"
+              );
+              continue;
+            }
+            session.recordEvent("artifact_saved", this.sessionId, artifactData);
+            this.processedToolCalls.add(block.toolCallId);
+            toolCallToArtifactMap[block.toolCallId] = artifactId;
+          }
+        }
+      }
+    }
+    this.lastProcessedMessageIndex = messages.length;
+    logger11.debug(
+      {
+        totalArtifactsCreated: Object.keys(toolCallToArtifactMap).length,
+        newMessageIndex: this.lastProcessedMessageIndex
+      },
+      "Compression artifact processing completed"
+    );
+    return toolCallToArtifactMap;
+  }
+  /**
+   * 3. Create conversation summary with artifact references
+   */
+  async createConversationSummary(messages, toolCallToArtifactMap) {
+    const textMessages = this.extractTextMessages(messages, toolCallToArtifactMap);
+    logger11.debug(
+      {
+        sessionId: this.sessionId,
+        messageCount: messages.length,
+        textMessageCount: textMessages.length,
+        artifactCount: Object.keys(toolCallToArtifactMap).length,
+        sampleMessages: messages.slice(0, 2).map((m4) => ({
+          role: m4.role,
+          contentType: typeof m4.content,
+          contentPreview: typeof m4.content === "string" ? m4.content.substring(0, 100) : "array/object"
+        }))
+      },
+      "Starting distillation with debug info"
+    );
+    const summary = await distillConversation({
+      messages,
+      conversationId: this.conversationId,
+      currentSummary: this.cumulativeSummary,
+      // Pass existing summary for cumulative building
+      summarizerModel: this.summarizerModel,
+      toolCallToArtifactMap
+      // Pass mapping for message formatting
+    });
+    this.cumulativeSummary = summary;
+    logger11.debug(
+      {
+        sessionId: this.sessionId,
+        summaryGenerated: !!summary,
+        summaryHighLevel: summary?.high_level,
+        artifactsCount: summary?.related_artifacts?.length || 0
+      },
+      "Distillation completed"
+    );
+    return {
+      text_messages: textMessages,
+      summary
+    };
+  }
+  /**
+   * Extract text messages and convert tool calls to descriptive text
+   * Avoids API tool-call/tool-result pairing issues while preserving context
+   */
+  extractTextMessages(messages, toolCallToArtifactMap) {
+    const textMessages = [];
+    const toolCallPairs = /* @__PURE__ */ new Map();
+    for (const message of messages) {
+      if (Array.isArray(message.content)) {
+        for (const block of message.content) {
+          if (block.type === "tool-call") {
+            if (!toolCallPairs.has(block.toolCallId)) {
+              toolCallPairs.set(block.toolCallId, { call: block, result: null });
+            } else {
+              toolCallPairs.get(block.toolCallId).call = block;
+            }
+          } else if (block.type === "tool-result") {
+            if (!toolCallPairs.has(block.toolCallId)) {
+              toolCallPairs.set(block.toolCallId, { call: null, result: block });
+            } else {
+              toolCallPairs.get(block.toolCallId).result = block;
+            }
+          }
+        }
+      }
+    }
+    for (const message of messages) {
+      if (message.role === "assistant" && typeof message.content === "string") {
+        textMessages.push({
+          role: message.role,
+          content: message.content
+        });
+      } else if (message.role === "assistant" && Array.isArray(message.content)) {
+        const textParts = [];
+        const toolCallsInMessage = /* @__PURE__ */ new Set();
+        const preservedBlocks = [];
+        for (const block of message.content) {
+          if (block.type === "text") {
+            textParts.push(block.text);
+          } else if (block.type === "tool-call" && block.toolName === "thinking_complete") ; else if (block.type === "tool-call") {
+            toolCallsInMessage.add(block.toolCallId);
+          }
+        }
+        for (const toolCallId of toolCallsInMessage) {
+          const pair = toolCallPairs.get(toolCallId);
+          const artifactId = toolCallToArtifactMap[toolCallId];
+          if (pair?.call) {
+            const args2 = JSON.stringify(pair.call.input);
+            const artifactText = artifactId ? ` Results compressed into artifact: ${artifactId}.` : " Results were compressed but not saved.";
+            textParts.push(`I called ${pair.call.toolName}(${args2}).${artifactText}`);
+          }
+        }
+        if (preservedBlocks.length > 0 && textParts.length > 0) {
+          const content = [...preservedBlocks];
+          if (textParts.length > 0) {
+            content.push({ type: "text", text: textParts.join("\n\n") });
+          }
+          textMessages.push({
+            role: message.role,
+            content
+          });
+        } else if (preservedBlocks.length > 0) {
+          textMessages.push({
+            role: message.role,
+            content: preservedBlocks
+          });
+        } else if (textParts.length > 0) {
+          textMessages.push({
+            role: message.role,
+            content: textParts.join("\n\n")
+          });
+        }
+      }
+    }
+    return textMessages;
+  }
+  // Removed focus hint helper methods - no longer needed since tool results are in formatted messages
+  /**
+   * Check if tool result data is effectively empty
+   */
+  isEmpty(toolResultData) {
+    if (!toolResultData || typeof toolResultData !== "object") {
+      return true;
+    }
+    const { toolResult } = toolResultData;
+    if (!toolResult) {
+      return true;
+    }
+    if (typeof toolResult === "object" && !Array.isArray(toolResult)) {
+      const keys = Object.keys(toolResult);
+      if (keys.length === 0) {
+        return true;
+      }
+      return keys.every((key) => {
+        const value = toolResult[key];
+        if (value === null || value === void 0 || value === "") {
+          return true;
+        }
+        if (Array.isArray(value) && value.length === 0) {
+          return true;
+        }
+        if (typeof value === "object" && Object.keys(value).length === 0) {
+          return true;
+        }
+        return false;
+      });
+    }
+    if (Array.isArray(toolResult) && toolResult.length === 0) {
+      return true;
+    }
+    if (typeof toolResult === "string" && toolResult.trim() === "") {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Recursively remove _structureHints from an object
+   */
+  removeStructureHints(obj) {
+    if (obj === null || obj === void 0) {
+      return obj;
+    }
+    if (Array.isArray(obj)) {
+      return obj.map((item) => this.removeStructureHints(item));
+    }
+    if (typeof obj === "object") {
+      const cleaned = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (key !== "_structureHints") {
+          cleaned[key] = this.removeStructureHints(value);
+        }
+      }
+      return cleaned;
+    }
+    return obj;
+  }
+  /**
+   * Get current state for debugging
+   */
+  getState() {
+    return {
+      shouldCompress: this.shouldCompress,
+      config: this.config
+    };
+  }
+  /**
+   * Get the current compression summary
+   */
+  getCompressionSummary() {
+    return this.cumulativeSummary;
+  }
+};
+
 // src/services/PendingToolApprovalManager.ts
 init_logger();
-var logger10 = agentsCore.getLogger("PendingToolApprovalManager");
+var logger12 = agentsCore.getLogger("PendingToolApprovalManager");
 var APPROVAL_CLEANUP_INTERVAL_MS = 2 * 60 * 1e3;
 var APPROVAL_TIMEOUT_MS = 10 * 60 * 1e3;
 var PendingToolApprovalManager = class _PendingToolApprovalManager {
@@ -11832,7 +12561,7 @@ var PendingToolApprovalManager = class _PendingToolApprovalManager {
         timeoutId
       };
       this.pendingApprovals.set(toolCallId, approval);
-      logger10.info(
+      logger12.info(
         {
           toolCallId,
           toolName,
@@ -11849,10 +12578,10 @@ var PendingToolApprovalManager = class _PendingToolApprovalManager {
   approveToolCall(toolCallId) {
     const approval = this.pendingApprovals.get(toolCallId);
     if (!approval) {
-      logger10.warn({ toolCallId }, "Tool approval not found or already processed");
+      logger12.warn({ toolCallId }, "Tool approval not found or already processed");
       return false;
     }
-    logger10.info(
+    logger12.info(
       {
         toolCallId,
         toolName: approval.toolName,
@@ -11871,10 +12600,10 @@ var PendingToolApprovalManager = class _PendingToolApprovalManager {
   denyToolCall(toolCallId, reason) {
     const approval = this.pendingApprovals.get(toolCallId);
     if (!approval) {
-      logger10.warn({ toolCallId }, "Tool approval not found or already processed");
+      logger12.warn({ toolCallId }, "Tool approval not found or already processed");
       return false;
     }
-    logger10.info(
+    logger12.info(
       {
         toolCallId,
         toolName: approval.toolName,
@@ -11906,7 +12635,7 @@ var PendingToolApprovalManager = class _PendingToolApprovalManager {
       }
     }
     if (cleanedUp > 0) {
-      logger10.info({ cleanedUp }, "Cleaned up expired tool approvals");
+      logger12.info({ cleanedUp }, "Cleaned up expired tool approvals");
     }
   }
   /**
@@ -11930,7 +12659,7 @@ var pendingToolApprovalManager = PendingToolApprovalManager.getInstance();
 
 // src/services/ResponseFormatter.ts
 init_logger();
-var logger11 = agentsCore.getLogger("ResponseFormatter");
+var logger13 = agentsCore.getLogger("ResponseFormatter");
 var ResponseFormatter = class {
   artifactParser;
   subAgentId;
@@ -11989,7 +12718,7 @@ var ResponseFormatter = class {
         return { parts: parts2 };
       } catch (error) {
         agentsCore.setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
-        logger11.error({ error, responseObject }, "Error formatting object response");
+        logger13.error({ error, responseObject }, "Error formatting object response");
         return {
           parts: [{ kind: "data", data: responseObject }]
         };
@@ -12045,7 +12774,7 @@ var ResponseFormatter = class {
         return { parts: parts2 };
       } catch (error) {
         agentsCore.setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
-        logger11.error({ error, responseText }, "Error formatting response");
+        logger13.error({ error, responseText }, "Error formatting response");
         return { text: responseText };
       } finally {
         span.end();
@@ -12484,7 +13213,7 @@ function parseEmbeddedJson(data) {
 
 // src/a2a/client.ts
 init_logger();
-var logger12 = agentsCore.getLogger("a2aClient");
+var logger14 = agentsCore.getLogger("a2aClient");
 var DEFAULT_BACKOFF = {
   initialInterval: 500,
   maxInterval: 6e4,
@@ -12691,7 +13420,7 @@ var A2AClient = class {
       try {
         const res = await fn2();
         if (attempt > 0) {
-          logger12.info(
+          logger14.info(
             {
               attempts: attempt + 1,
               elapsedTime: Date.now() - start2
@@ -12706,7 +13435,7 @@ var A2AClient = class {
         }
         const elapsed = Date.now() - start2;
         if (elapsed > maxElapsedTime) {
-          logger12.warn(
+          logger14.warn(
             {
               attempts: attempt + 1,
               elapsedTime: elapsed,
@@ -12727,7 +13456,7 @@ var A2AClient = class {
           retryInterval = initialInterval * attempt ** exponent + Math.random() * 1e3;
         }
         const delayMs = Math.min(retryInterval, maxInterval);
-        logger12.info(
+        logger14.info(
           {
             attempt: attempt + 1,
             delayMs,
@@ -12818,7 +13547,7 @@ var A2AClient = class {
       });
     }
     if (rpcResponse.id !== requestId2) {
-      logger12.warn(
+      logger14.warn(
         {
           method,
           expectedId: requestId2,
@@ -13015,7 +13744,7 @@ var A2AClient = class {
     try {
       while (true) {
         const { done, value } = await reader.read();
-        logger12.info({ done, value }, "parseA2ASseStream");
+        logger14.info({ done, value }, "parseA2ASseStream");
         if (done) {
           if (eventDataBuffer.trim()) {
             const result = this._processSseEventData(
@@ -13106,7 +13835,7 @@ init_execution_limits();
 init_conversations();
 init_dbClient();
 init_logger();
-var logger13 = agentsCore.getLogger("relationships Tools");
+var logger15 = agentsCore.getLogger("relationships Tools");
 var A2A_RETRY_STATUS_CODES = ["429", "500", "502", "503", "504"];
 var generateTransferToolDescription = (config) => {
   let toolsSection = "";
@@ -13131,9 +13860,9 @@ Can Delegate To:
 ${delegateList}`;
   }
   if (config.tools && config.tools.length > 0) {
-    const toolDescriptions = config.tools.map((tool3) => {
-      const toolsList = tool3.availableTools?.map((t2) => `  - ${t2.name}: ${t2.description || "No description available"}`).join("\n") || "";
-      return `MCP Server: ${tool3.name}
+    const toolDescriptions = config.tools.map((tool4) => {
+      const toolsList = tool4.availableTools?.map((t2) => `  - ${t2.name}: ${t2.description || "No description available"}`).join("\n") || "";
+      return `MCP Server: ${tool4.name}
 ${toolsList}`;
     }).join("\n\n");
     toolsSection = `
@@ -13159,9 +13888,9 @@ var generateDelegateToolDescription = (delegateRelation) => {
   if (delegateRelation.type === "internal" && "tools" in config) {
     const agentConfig = config;
     if (agentConfig.tools && agentConfig.tools.length > 0) {
-      const toolDescriptions = agentConfig.tools.map((tool3) => {
-        const toolsList = tool3.availableTools?.map((t2) => `  - ${t2.name}: ${t2.description || "No description available"}`).join("\n") || "";
-        return `MCP Server: ${tool3.name}
+      const toolDescriptions = agentConfig.tools.map((tool4) => {
+        const toolsList = tool4.availableTools?.map((t2) => `  - ${t2.name}: ${t2.description || "No description available"}`).join("\n") || "";
+        return `MCP Server: ${tool4.name}
 ${toolsList}`;
       }).join("\n\n");
       toolsSection = `
@@ -13217,7 +13946,7 @@ var createTransferToAgentTool = ({
           [agentsCore.SPAN_KEYS.TRANSFER_TO_SUB_AGENT_ID]: transferConfig.id ?? "unknown"
         });
       }
-      logger13.info(
+      logger15.info(
         {
           transferTo: transferConfig.id ?? "unknown",
           fromSubAgent: callingAgentId
@@ -13238,7 +13967,7 @@ var createTransferToAgentTool = ({
         fromSubAgentId: callingAgentId
         // Include the calling agent ID for tracking
       };
-      logger13.info(
+      logger15.info(
         {
           transferResult,
           transferResultKeys: Object.keys(transferResult)
@@ -13385,7 +14114,7 @@ function createDelegateToAgentTool({
           ...isInternal ? { fromSubAgentId: callingAgentId } : { fromExternalAgentId: callingAgentId }
         }
       };
-      logger13.info({ messageToSend }, "messageToSend");
+      logger15.info({ messageToSend }, "messageToSend");
       await agentsCore.createMessage(dbClient_default)({
         id: agentsCore.generateId(),
         tenantId,
@@ -13448,7 +14177,7 @@ function createDelegateToAgentTool({
 
 // src/agents/SystemPromptBuilder.ts
 init_logger();
-var logger14 = agentsCore.getLogger("SystemPromptBuilder");
+var logger16 = agentsCore.getLogger("SystemPromptBuilder");
 var SystemPromptBuilder = class {
   constructor(version, versionConfig) {
     this.version = version;
@@ -13464,12 +14193,12 @@ var SystemPromptBuilder = class {
         this.templates.set(name2, content);
       }
       this.loaded = true;
-      logger14.debug(
+      logger16.debug(
         { templateCount: this.templates.size, version: this.version },
         `Loaded ${this.templates.size} templates for version ${this.version}`
       );
     } catch (error) {
-      logger14.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}`);
     }
   }
@@ -13860,6 +14589,8 @@ 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" details='{"key":"jmespath_selector"}' />
 
+\u26A0\uFE0F IMPORTANT: Do not create artifacts from get_reference_artifact tool results - these are already compressed artifacts being retrieved. Only create artifacts from original research and analysis tools.
+
 \u{1F6A8} CRITICAL: DETAILS PROPS USE JMESPATH SELECTORS, NOT LITERAL VALUES! \u{1F6A8}
 
 \u274C WRONG - Using literal values:
@@ -14078,27 +14809,27 @@ ${creationInstructions}
     if (tools.length === 0) {
       return '<available_tools description="No tools are currently available"></available_tools>';
     }
-    const toolsXml = tools.map((tool3) => this.generateToolXml(templates, tool3)).join("\n  ");
+    const toolsXml = tools.map((tool4) => this.generateToolXml(templates, tool4)).join("\n  ");
     return `<available_tools description="These are the tools available for you to use to accomplish tasks">
   ${toolsXml}
 </available_tools>`;
   }
-  generateToolXml(templates, tool3) {
+  generateToolXml(templates, tool4) {
     const toolTemplate = templates.get("tool");
     if (!toolTemplate) {
       throw new Error("Tool template not loaded");
     }
     let toolXml = toolTemplate;
-    toolXml = toolXml.replace("{{TOOL_NAME}}", tool3.name);
+    toolXml = toolXml.replace("{{TOOL_NAME}}", tool4.name);
     toolXml = toolXml.replace(
       "{{TOOL_DESCRIPTION}}",
-      tool3.description || "No description available"
+      tool4.description || "No description available"
     );
     toolXml = toolXml.replace(
       "{{TOOL_USAGE_GUIDELINES}}",
-      tool3.usageGuidelines || "Use this tool when appropriate."
+      tool4.usageGuidelines || "Use this tool when appropriate."
     );
-    const parametersXml = this.generateParametersXml(tool3.inputSchema);
+    const parametersXml = this.generateParametersXml(tool4.inputSchema);
     toolXml = toolXml.replace("{{TOOL_PARAMETERS_SCHEMA}}", parametersXml);
     return toolXml;
   }
@@ -14281,6 +15012,8 @@ CREATING ARTIFACTS (SERVES AS CITATION):
 Use the appropriate ArtifactCreate_[Type] component to extract and structure data from tool results.
 The creation itself serves as a citation - no additional reference needed.
 
+\u26A0\uFE0F IMPORTANT: Do not create artifacts from get_reference_artifact tool results - these are already compressed artifacts being retrieved. Only create artifacts from original research and analysis tools.
+
 \u{1F6AB} FORBIDDEN JMESPATH PATTERNS:
 \u274C NEVER: [?title~'.*text.*'] (regex patterns with ~ operator)
 \u274C NEVER: [?field~'pattern.*'] (any ~ operator usage)
@@ -14560,7 +15293,7 @@ function hasToolCallWithPrefix(prefix) {
     return false;
   };
 }
-var logger18 = agentsCore.getLogger("Agent");
+var logger20 = agentsCore.getLogger("Agent");
 function validateModel(modelString, modelType) {
   if (!modelString?.trim()) {
     throw new Error(
@@ -14569,8 +15302,8 @@ function validateModel(modelString, modelType) {
   }
   return modelString.trim();
 }
-function isValidTool(tool3) {
-  return tool3 && typeof tool3 === "object" && typeof tool3.description === "string" && tool3.inputSchema && typeof tool3.execute === "function";
+function isValidTool(tool4) {
+  return tool4 && typeof tool4 === "object" && typeof tool4.description === "string" && tool4.inputSchema && typeof tool4.execute === "function";
 }
 var Agent = class {
   config;
@@ -14586,6 +15319,7 @@ var Agent = class {
   credentialStoreRegistry;
   mcpClientCache = /* @__PURE__ */ new Map();
   mcpConnectionLocks = /* @__PURE__ */ new Map();
+  currentCompressor = null;
   constructor(config, credentialStoreRegistry) {
     this.artifactComponents = config.artifactComponents || [];
     let processedDataComponents = config.dataComponents || [];
@@ -14671,17 +15405,17 @@ var Agent = class {
   }
   #getRelationshipIdForTool(toolName, toolType) {
     if (toolType === "mcp") {
-      const matchingTool = this.config.tools?.find((tool3) => {
-        if (tool3.config?.type !== "mcp") {
+      const matchingTool = this.config.tools?.find((tool4) => {
+        if (tool4.config?.type !== "mcp") {
           return false;
         }
-        if (tool3.availableTools?.some((available) => available.name === toolName)) {
+        if (tool4.availableTools?.some((available) => available.name === toolName)) {
           return true;
         }
-        if (tool3.config.mcp.activeTools?.includes(toolName)) {
+        if (tool4.config.mcp.activeTools?.includes(toolName)) {
           return true;
         }
-        return tool3.name === toolName;
+        return tool4.name === toolName;
       });
       return matchingTool?.relationshipId;
     }
@@ -14735,9 +15469,59 @@ var Agent = class {
       providerOptions: baseConfig.providerOptions
     };
   }
+  /**
+   * Get the model settings for summarization/distillation
+   * Falls back to base model if summarizer not configured
+   */
+  getSummarizerModel() {
+    if (!this.config.models) {
+      throw new Error(
+        "Model configuration is required. Please configure models at the project level."
+      );
+    }
+    const summarizerConfig = this.config.models.summarizer;
+    const baseConfig = this.config.models.base;
+    if (summarizerConfig) {
+      return {
+        model: validateModel(summarizerConfig.model, "Summarizer"),
+        providerOptions: summarizerConfig.providerOptions
+      };
+    }
+    if (!baseConfig) {
+      throw new Error(
+        "Base model configuration is required for summarizer fallback. Please configure models at the project level."
+      );
+    }
+    return {
+      model: validateModel(baseConfig.model, "Base (fallback for summarizer)"),
+      providerOptions: baseConfig.providerOptions
+    };
+  }
   setConversationId(conversationId) {
     this.conversationId = conversationId;
   }
+  /**
+   * Simple compression fallback: drop oldest messages to fit under token limit
+   */
+  simpleCompression(messages, targetTokens) {
+    if (messages.length === 0) return messages;
+    const estimateTokens = (msg) => {
+      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      return Math.ceil(content.length / 4);
+    };
+    let totalTokens = messages.reduce((sum, msg) => sum + estimateTokens(msg), 0);
+    if (totalTokens <= targetTokens) {
+      return messages;
+    }
+    const result = [...messages];
+    while (totalTokens > targetTokens && result.length > 1) {
+      const dropped = result.shift();
+      if (dropped) {
+        totalTokens -= estimateTokens(dropped);
+      }
+    }
+    return result;
+  }
   /**
    * Set delegation status for this agent instance
    */
@@ -14773,14 +15557,21 @@ var Agent = class {
         const toolCallId = context?.toolCallId || generateToolId();
         const activeSpan = api.trace.getActiveSpan();
         if (activeSpan) {
-          activeSpan.setAttributes({
+          const attributes = {
             "conversation.id": this.conversationId,
             "tool.purpose": toolDefinition.description || "No description provided",
             "ai.toolType": toolType || "unknown",
             "subAgent.name": this.config.name || "unknown",
             "subAgent.id": this.config.id || "unknown",
             "agent.id": this.config.agentId || "unknown"
-          });
+          };
+          if (options?.mcpServerId) {
+            attributes["ai.toolCall.mcpServerId"] = options.mcpServerId;
+          }
+          if (options?.mcpServerName) {
+            attributes["ai.toolCall.mcpServerName"] = options.mcpServerName;
+          }
+          activeSpan.setAttributes(attributes);
         }
         const isInternalTool = toolName.includes("save_tool_result") || toolName.includes("thinking_complete") || toolName.startsWith("transfer_to_");
         const needsApproval = options?.needsApproval || false;
@@ -14833,7 +15624,7 @@ var Agent = class {
               };
               await agentsCore.createMessage(dbClient_default)(messagePayload);
             } catch (error) {
-              logger18.warn(
+              logger20.warn(
                 { error, toolName, toolCallId, conversationId: toolResultConversationId },
                 "Failed to store tool result in conversation history"
               );
@@ -14921,10 +15712,10 @@ var Agent = class {
     ]);
   }
   async getMcpTools(sessionId, streamRequestId) {
-    const mcpTools = this.config.tools?.filter((tool3) => {
-      return tool3.config?.type === "mcp";
+    const mcpTools = this.config.tools?.filter((tool4) => {
+      return tool4.config?.type === "mcp";
     }) || [];
-    const tools = await Promise.all(mcpTools.map((tool3) => this.getMcpTool(tool3)) || []) || [];
+    const tools = await Promise.all(mcpTools.map((tool4) => this.getMcpTool(tool4)) || []) || [];
     if (!sessionId) {
       const wrappedTools2 = {};
       for (const toolSet of tools) {
@@ -14939,7 +15730,11 @@ var Agent = class {
             enhancedTool,
             streamRequestId,
             "mcp",
-            { needsApproval }
+            {
+              needsApproval,
+              mcpServerId: toolSet.mcpServerId,
+              mcpServerName: toolSet.mcpServerName
+            }
           );
         }
       }
@@ -14949,11 +15744,11 @@ var Agent = class {
     for (const toolResult of tools) {
       for (const [toolName, originalTool] of Object.entries(toolResult.tools)) {
         if (!isValidTool(originalTool)) {
-          logger18.error({ toolName }, "Invalid MCP tool structure - missing required properties");
+          logger20.error({ toolName }, "Invalid MCP tool structure - missing required properties");
           continue;
         }
         const needsApproval = toolResult.toolPolicies?.[toolName]?.needsApproval || false;
-        logger18.debug(
+        logger20.debug(
           {
             toolName,
             toolPolicies: toolResult.toolPolicies,
@@ -14967,7 +15762,7 @@ var Agent = class {
           inputSchema: originalTool.inputSchema,
           execute: async (args2, { toolCallId }) => {
             if (needsApproval) {
-              logger18.info(
+              logger20.info(
                 { toolName, toolCallId, args: args2 },
                 "Tool requires approval - waiting for user response"
               );
@@ -15013,7 +15808,7 @@ var Agent = class {
                     }
                   },
                   (denialSpan) => {
-                    logger18.info(
+                    logger20.info(
                       { toolName, toolCallId, reason: approvalResult.reason },
                       "Tool execution denied by user"
                     );
@@ -15034,18 +15829,18 @@ var Agent = class {
                   }
                 },
                 (approvedSpan) => {
-                  logger18.info({ toolName, toolCallId }, "Tool approved, continuing with execution");
+                  logger20.info({ toolName, toolCallId }, "Tool approved, continuing with execution");
                   approvedSpan.setStatus({ code: api.SpanStatusCode.OK });
                   approvedSpan.end();
                 }
               );
             }
-            logger18.debug({ toolName, toolCallId }, "MCP Tool Called");
+            logger20.debug({ toolName, toolCallId }, "MCP Tool Called");
             try {
               const rawResult = await originalTool.execute(args2, { toolCallId });
               if (rawResult && typeof rawResult === "object" && rawResult.isError) {
                 const errorMessage = rawResult.content?.[0]?.text || "MCP tool returned an error";
-                logger18.error(
+                logger20.error(
                   { toolName, toolCallId, errorMessage, rawResult },
                   "MCP tool returned error status"
                 );
@@ -15096,7 +15891,7 @@ var Agent = class {
               });
               return { result: enhancedResult, toolCallId };
             } catch (error) {
-              logger18.error({ toolName, toolCallId, error }, "MCP tool execution failed");
+              logger20.error({ toolName, toolCallId, error }, "MCP tool execution failed");
               throw error;
             }
           }
@@ -15106,7 +15901,11 @@ var Agent = class {
           sessionWrappedTool,
           streamRequestId,
           "mcp",
-          { needsApproval }
+          {
+            needsApproval,
+            mcpServerId: toolResult.mcpServerId,
+            mcpServerName: toolResult.mcpServerName
+          }
         );
       }
     }
@@ -15115,28 +15914,28 @@ 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}`);
+  convertToMCPToolConfig(tool4, agentToolRelationHeaders) {
+    if (tool4.config.type !== "mcp") {
+      throw new Error(`Cannot convert non-MCP tool to MCP config: ${tool4.id}`);
     }
     return {
-      id: tool3.id,
-      name: tool3.name,
-      description: tool3.name,
+      id: tool4.id,
+      name: tool4.name,
+      description: tool4.name,
       // Use name as description fallback
-      serverUrl: tool3.config.mcp.server.url,
-      activeTools: tool3.config.mcp.activeTools,
-      mcpType: tool3.config.mcp.server.url.includes("api.nango.dev") ? agentsCore.MCPServerType.nango : agentsCore.MCPServerType.generic,
-      transport: tool3.config.mcp.transport,
+      serverUrl: tool4.config.mcp.server.url,
+      activeTools: tool4.config.mcp.activeTools,
+      mcpType: tool4.config.mcp.server.url.includes("api.nango.dev") ? agentsCore.MCPServerType.nango : agentsCore.MCPServerType.generic,
+      transport: tool4.config.mcp.transport,
       headers: {
-        ...tool3.headers,
+        ...tool4.headers,
         ...agentToolRelationHeaders
       }
     };
   }
-  async getMcpTool(tool3) {
-    const cacheKey = `${this.config.tenantId}-${this.config.projectId}-${tool3.id}-${tool3.credentialReferenceId || "no-cred"}`;
-    const credentialReferenceId = tool3.credentialReferenceId;
+  async getMcpTool(tool4) {
+    const cacheKey = `${this.config.tenantId}-${this.config.projectId}-${tool4.id}-${tool4.credentialReferenceId || "no-cred"}`;
+    const credentialReferenceId = tool4.credentialReferenceId;
     const toolsForAgent = await agentsCore.getToolsForAgent(dbClient_default)({
       scopes: {
         tenantId: this.config.tenantId,
@@ -15145,12 +15944,12 @@ var Agent = class {
         subAgentId: this.config.id
       }
     });
-    const toolRelation = toolsForAgent.data.find((t2) => t2.toolId === tool3.id);
+    const toolRelation = toolsForAgent.data.find((t2) => t2.toolId === tool4.id);
     const agentToolRelationHeaders = toolRelation?.headers || void 0;
     const selectedTools = toolRelation?.selectedTools || void 0;
     const toolPolicies = toolRelation?.toolPolicies || {};
     let serverConfig;
-    const isUserScoped = tool3.credentialScope === "user";
+    const isUserScoped = tool4.credentialScope === "user";
     const userId = this.config.userId;
     if (isUserScoped && userId && this.credentialStuffer) {
       const userCredentialReference = await agentsCore.getUserScopedCredentialReference(dbClient_default)({
@@ -15158,7 +15957,7 @@ var Agent = class {
           tenantId: this.config.tenantId,
           projectId: this.config.projectId
         },
-        toolId: tool3.id,
+        toolId: tool4.id,
         userId
       });
       if (userCredentialReference) {
@@ -15173,13 +15972,13 @@ var Agent = class {
             contextConfigId: this.config.contextConfigId || void 0,
             conversationId: this.conversationId || void 0
           },
-          this.convertToMCPToolConfig(tool3, agentToolRelationHeaders),
+          this.convertToMCPToolConfig(tool4, agentToolRelationHeaders),
           storeReference,
           selectedTools
         );
       } else {
-        logger18.warn(
-          { toolId: tool3.id, userId },
+        logger20.warn(
+          { toolId: tool4.id, userId },
           "User-scoped tool has no credential connected for this user"
         );
         serverConfig = await this.credentialStuffer.buildMcpServerConfig(
@@ -15189,7 +15988,7 @@ var Agent = class {
             contextConfigId: this.config.contextConfigId || void 0,
             conversationId: this.conversationId || void 0
           },
-          this.convertToMCPToolConfig(tool3, agentToolRelationHeaders),
+          this.convertToMCPToolConfig(tool4, agentToolRelationHeaders),
           void 0,
           selectedTools
         );
@@ -15216,7 +16015,7 @@ var Agent = class {
           contextConfigId: this.config.contextConfigId || void 0,
           conversationId: this.conversationId || void 0
         },
-        this.convertToMCPToolConfig(tool3, agentToolRelationHeaders),
+        this.convertToMCPToolConfig(tool4, agentToolRelationHeaders),
         storeReference,
         selectedTools
       );
@@ -15228,18 +16027,18 @@ var Agent = class {
           contextConfigId: this.config.contextConfigId || void 0,
           conversationId: this.conversationId || void 0
         },
-        this.convertToMCPToolConfig(tool3, agentToolRelationHeaders),
+        this.convertToMCPToolConfig(tool4, agentToolRelationHeaders),
         void 0,
         selectedTools
       );
     } else {
-      if (tool3.config.type !== "mcp") {
-        throw new Error(`Cannot build server config for non-MCP tool: ${tool3.id}`);
+      if (tool4.config.type !== "mcp") {
+        throw new Error(`Cannot build server config for non-MCP tool: ${tool4.id}`);
       }
       serverConfig = {
-        type: tool3.config.mcp.transport?.type || agentsCore.MCPTransportType.streamableHttp,
-        url: tool3.config.mcp.server.url,
-        activeTools: tool3.config.mcp.activeTools,
+        type: tool4.config.mcp.transport?.type || agentsCore.MCPTransportType.streamableHttp,
+        url: tool4.config.mcp.server.url,
+        activeTools: tool4.config.mcp.activeTools,
         selectedTools,
         headers: agentToolRelationHeaders
       };
@@ -15257,12 +16056,12 @@ var Agent = class {
       }
       serverConfig.url = urlObj.toString();
     }
-    logger18.info(
+    logger20.info(
       {
-        toolName: tool3.name,
+        toolName: tool4.name,
         credentialReferenceId,
         transportType: serverConfig.type,
-        headers: tool3.headers
+        headers: tool4.headers
       },
       "Built MCP server config with credentials"
     );
@@ -15274,7 +16073,7 @@ var Agent = class {
     if (!client) {
       let connectionPromise = this.mcpConnectionLocks.get(cacheKey);
       if (!connectionPromise) {
-        connectionPromise = this.createMcpConnection(tool3, serverConfig);
+        connectionPromise = this.createMcpConnection(tool4, serverConfig);
         this.mcpConnectionLocks.set(cacheKey, connectionPromise);
       }
       try {
@@ -15282,9 +16081,9 @@ var Agent = class {
         this.mcpClientCache.set(cacheKey, client);
       } catch (error) {
         this.mcpConnectionLocks.delete(cacheKey);
-        logger18.error(
+        logger20.error(
           {
-            toolName: tool3.name,
+            toolName: tool4.name,
             subAgentId: this.config.id,
             cacheKey,
             error: error instanceof Error ? error.message : String(error)
@@ -15302,13 +16101,13 @@ var Agent = class {
           "ai.toolCall",
           {
             attributes: {
-              "ai.toolCall.name": tool3.name,
+              "ai.toolCall.name": tool4.name,
               "ai.toolCall.args": JSON.stringify({ operation: "mcp_tool_discovery" }),
               "ai.toolCall.result": JSON.stringify({
                 status: "no_tools_available",
                 message: `MCP server has 0 effective tools. Double check the selected tools in your agent and the active tools in the MCP server configuration.`,
-                serverUrl: tool3.config.type === "mcp" ? tool3.config.mcp.server.url : "unknown",
-                originalToolName: tool3.name
+                serverUrl: tool4.config.type === "mcp" ? tool4.config.mcp.server.url : "unknown",
+                originalToolName: tool4.name
               }),
               "ai.toolType": "mcp",
               "subAgent.name": this.config.name || "unknown",
@@ -15320,14 +16119,14 @@ var Agent = class {
             }
           },
           (span) => {
-            agentsCore.setSpanWithError(span, new Error(`0 effective tools available for ${tool3.name}`));
+            agentsCore.setSpanWithError(span, new Error(`0 effective tools available for ${tool4.name}`));
             agentSessionManager.recordEvent(streamRequestId, "error", this.config.id, {
               message: `MCP server has 0 effective tools. Double check the selected tools in your graph and the active tools in the MCP server configuration.`,
               code: "no_tools_available",
               severity: "error",
               context: {
-                toolName: tool3.name,
-                serverUrl: tool3.config.type === "mcp" ? tool3.config.mcp.server.url : "unknown",
+                toolName: tool4.name,
+                serverUrl: tool4.config.type === "mcp" ? tool4.config.mcp.server.url : "unknown",
                 operation: "mcp_tool_discovery"
               }
             });
@@ -15336,20 +16135,20 @@ var Agent = class {
         );
       }
     }
-    return { tools, toolPolicies };
+    return { tools, toolPolicies, mcpServerId: tool4.id, mcpServerName: tool4.name };
   }
-  async createMcpConnection(tool3, serverConfig) {
+  async createMcpConnection(tool4, serverConfig) {
     const client = new agentsCore.McpClient({
-      name: tool3.name,
+      name: tool4.name,
       server: serverConfig
     });
     try {
       await client.connect();
       return client;
     } catch (error) {
-      logger18.error(
+      logger20.error(
         {
-          toolName: tool3.name,
+          toolName: tool4.name,
           subAgentId: this.config.id,
           error: error instanceof Error ? error.message : String(error)
         },
@@ -15389,7 +16188,7 @@ var Agent = class {
       for (const functionToolDef of functionToolsData) {
         const functionId = functionToolDef.functionId;
         if (!functionId) {
-          logger18.warn(
+          logger20.warn(
             { functionToolId: functionToolDef.id },
             "Function tool missing functionId reference"
           );
@@ -15403,7 +16202,7 @@ var Agent = class {
           }
         });
         if (!functionData) {
-          logger18.warn(
+          logger20.warn(
             { functionId, functionToolId: functionToolDef.id },
             "Function not found in functions table"
           );
@@ -15414,7 +16213,7 @@ var Agent = class {
           description: functionToolDef.description || functionToolDef.name,
           inputSchema: zodSchema,
           execute: async (args2, { toolCallId }) => {
-            logger18.debug(
+            logger20.debug(
               { toolName: functionToolDef.name, toolCallId, args: args2 },
               "Function Tool Called"
             );
@@ -15441,7 +16240,7 @@ var Agent = class {
               });
               return { result, toolCallId };
             } catch (error) {
-              logger18.error(
+              logger20.error(
                 {
                   toolName: functionToolDef.name,
                   toolCallId,
@@ -15461,7 +16260,7 @@ var Agent = class {
         );
       }
     } catch (error) {
-      logger18.error({ error }, "Failed to load function tools from database");
+      logger20.error({ error }, "Failed to load function tools from database");
     }
     return functionTools;
   }
@@ -15471,7 +16270,7 @@ var Agent = class {
   async getResolvedContext(conversationId, headers2) {
     try {
       if (!this.config.contextConfigId) {
-        logger18.debug({ agentId: this.config.agentId }, "No context config found for agent");
+        logger20.debug({ agentId: this.config.agentId }, "No context config found for agent");
         return null;
       }
       const contextConfig = await agentsCore.getContextConfigById(dbClient_default)({
@@ -15483,7 +16282,7 @@ var Agent = class {
         id: this.config.contextConfigId
       });
       if (!contextConfig) {
-        logger18.warn({ contextConfigId: this.config.contextConfigId }, "Context config not found");
+        logger20.warn({ contextConfigId: this.config.contextConfigId }, "Context config not found");
         return null;
       }
       if (!this.contextResolver) {
@@ -15499,7 +16298,7 @@ var Agent = class {
         ...result.resolvedContext,
         $env: process.env
       };
-      logger18.debug(
+      logger20.debug(
         {
           conversationId,
           contextConfigId: contextConfig.id,
@@ -15513,7 +16312,7 @@ var Agent = class {
       );
       return contextWithBuiltins;
     } catch (error) {
-      logger18.error(
+      logger20.error(
         {
           conversationId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -15537,7 +16336,7 @@ var Agent = class {
       });
       return agentDefinition?.prompt || void 0;
     } catch (error) {
-      logger18.warn(
+      logger20.warn(
         {
           agentId: this.config.agentId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -15566,7 +16365,7 @@ var Agent = class {
         (subAgent) => "artifactComponents" in subAgent && subAgent.artifactComponents && subAgent.artifactComponents.length > 0
       );
     } catch (error) {
-      logger18.warn(
+      logger20.warn(
         {
           agentId: this.config.agentId,
           tenantId: this.config.tenantId,
@@ -15584,7 +16383,8 @@ var Agent = class {
    */
   async buildPhase2SystemPrompt(runtimeContext) {
     const phase2Config = new Phase2Config();
-    const hasAgentArtifactComponents = await this.hasAgentArtifactComponents();
+    const compressionConfig = getCompressionConfigFromEnv();
+    const hasAgentArtifactComponents = await this.hasAgentArtifactComponents() || compressionConfig.enabled;
     const conversationId = runtimeContext?.metadata?.conversationId || runtimeContext?.contextId;
     const resolvedContext = conversationId ? await this.getResolvedContext(conversationId) : null;
     let processedPrompt = this.config.prompt || "";
@@ -15595,7 +16395,7 @@ var Agent = class {
           preserveUnresolved: false
         });
       } catch (error) {
-        logger18.error(
+        logger20.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -15642,7 +16442,7 @@ var Agent = class {
           preserveUnresolved: false
         });
       } catch (error) {
-        logger18.error(
+        logger20.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -15657,25 +16457,25 @@ var Agent = class {
     const functionTools = await this.getFunctionTools(streamRequestId || "");
     const relationTools = this.getRelationTools(runtimeContext);
     const allTools = { ...mcpTools, ...functionTools, ...relationTools };
-    logger18.info(
+    logger20.info(
       {
         mcpTools: Object.keys(mcpTools),
         functionTools: Object.keys(functionTools),
         relationTools: Object.keys(relationTools),
         allTools: Object.keys(allTools),
-        functionToolsDetails: Object.entries(functionTools).map(([name2, tool3]) => ({
+        functionToolsDetails: Object.entries(functionTools).map(([name2, tool4]) => ({
           name: name2,
-          hasExecute: typeof tool3.execute === "function",
-          hasDescription: !!tool3.description,
-          hasInputSchema: !!tool3.inputSchema
+          hasExecute: typeof tool4.execute === "function",
+          hasDescription: !!tool4.description,
+          hasInputSchema: !!tool4.inputSchema
         }))
       },
       "Tools loaded for agent"
     );
-    const toolDefinitions = Object.entries(allTools).map(([name2, tool3]) => ({
+    const toolDefinitions = Object.entries(allTools).map(([name2, tool4]) => ({
       name: name2,
-      description: tool3.description || "",
-      inputSchema: tool3.inputSchema || tool3.parameters || {},
+      description: tool4.description || "",
+      inputSchema: tool4.inputSchema || tool4.parameters || {},
       usageGuidelines: name2.startsWith("transfer_to_") || name2.startsWith("delegate_to_") ? `Use this tool to ${name2.startsWith("transfer_to_") ? "transfer" : "delegate"} to another agent when appropriate.` : "Use this tool when appropriate for the task at hand."
     }));
     const { getConversationScopedArtifacts: getConversationScopedArtifacts2 } = await Promise.resolve().then(() => (init_conversations(), conversations_exports));
@@ -15696,7 +16496,7 @@ var Agent = class {
           preserveUnresolved: false
         });
       } catch (error) {
-        logger18.error(
+        logger20.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -15706,7 +16506,8 @@ var Agent = class {
       }
     }
     const shouldIncludeArtifactComponents = !excludeDataComponents;
-    const hasAgentArtifactComponents = await this.hasAgentArtifactComponents();
+    const compressionConfig = getCompressionConfigFromEnv();
+    const hasAgentArtifactComponents = await this.hasAgentArtifactComponents() || compressionConfig.enabled;
     const config = {
       corePrompt: processedPrompt,
       prompt,
@@ -15729,7 +16530,7 @@ var Agent = class {
         toolCallId: zodOpenapi.z.string().describe("The tool call ID associated with this artifact.")
       }),
       execute: async ({ artifactId, toolCallId }) => {
-        logger18.info({ artifactId, toolCallId }, "get_artifact_full executed");
+        logger20.info({ artifactId, toolCallId }, "get_artifact_full executed");
         const streamRequestId = this.getStreamRequestId();
         const artifactService = agentSessionManager.getArtifactService(streamRequestId);
         if (!artifactService) {
@@ -15765,7 +16566,8 @@ var Agent = class {
   // Provide a default tool set that is always available to the agent.
   async getDefaultTools(streamRequestId) {
     const defaultTools = {};
-    if (await this.agentHasArtifactComponents()) {
+    const compressionConfig = getCompressionConfigFromEnv();
+    if (await this.agentHasArtifactComponents() || compressionConfig.enabled) {
       defaultTools.get_reference_artifact = this.getArtifactTools();
     }
     const hasStructuredOutput = this.config.dataComponents && this.config.dataComponents.length > 0;
@@ -15780,6 +16582,37 @@ var Agent = class {
         );
       }
     }
+    logger20.info(
+      { agentId: this.config.id, streamRequestId },
+      "Adding compress_context tool to defaultTools"
+    );
+    defaultTools.compress_context = ai.tool({
+      description: "Manually compress the current conversation context to save space. Use when shifting topics, completing major tasks, or when context feels cluttered.",
+      inputSchema: zodOpenapi.z.object({
+        reason: zodOpenapi.z.string().describe(
+          'Why you are requesting compression (e.g., "shifting from research to coding", "completed analysis phase")'
+        )
+      }),
+      execute: async ({ reason }) => {
+        logger20.info(
+          {
+            agentId: this.config.id,
+            streamRequestId,
+            reason
+          },
+          "Manual compression requested by LLM"
+        );
+        if (this.currentCompressor) {
+          this.currentCompressor.requestManualCompression(reason);
+        }
+        return {
+          status: "compression_requested",
+          reason,
+          message: "Context compression will be applied on the next generation step. Previous work has been summarized and saved as artifacts."
+        };
+      }
+    });
+    logger20.info("getDefaultTools returning tools:", Object.keys(defaultTools).join(", "));
     return defaultTools;
   }
   getStreamRequestId() {
@@ -16025,7 +16858,7 @@ ${output}`;
       };
       return enhanced;
     } catch (error) {
-      logger18.warn({ error }, "Failed to enhance tool result with structure hints");
+      logger20.warn({ error }, "Failed to enhance tool result with structure hints");
       return result;
     }
   }
@@ -16040,7 +16873,7 @@ ${output}`;
         }
       });
     } catch (error) {
-      logger18.error(
+      logger20.error(
         { error, agentId: this.config.agentId },
         "Failed to check agent artifact components"
       );
@@ -16157,7 +16990,7 @@ ${output}`;
           const configuredTimeout = modelSettings.maxDuration ? Math.min(modelSettings.maxDuration * 1e3, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS) : shouldStreamPhase1 ? LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING : LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING;
           const timeoutMs = Math.min(configuredTimeout, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS);
           if (modelSettings.maxDuration && modelSettings.maxDuration * 1e3 > LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS) {
-            logger18.warn(
+            logger20.warn(
               {
                 requestedTimeout: modelSettings.maxDuration * 1e3,
                 appliedTimeout: timeoutMs,
@@ -16176,6 +17009,18 @@ ${output}`;
             role: "user",
             content: userMessage
           });
+          const originalMessageCount = messages.length;
+          const compressionConfig = getCompressionConfigFromEnv();
+          const compressor = compressionConfig.enabled ? new MidGenerationCompressor(
+            sessionId,
+            contextId,
+            this.config.tenantId,
+            this.config.projectId,
+            compressionConfig,
+            this.getSummarizerModel(),
+            primaryModelSettings
+          ) : null;
+          this.currentCompressor = compressor;
           if (shouldStreamPhase1) {
             const streamConfig = {
               ...modelSettings,
@@ -16186,6 +17031,87 @@ ${output}`;
               ...streamConfig,
               messages,
               tools: sanitizedTools,
+              prepareStep: async ({ messages: stepMessages }) => {
+                if (!compressor) {
+                  return {};
+                }
+                const compressionNeeded = compressor.isCompressionNeeded(stepMessages);
+                if (compressionNeeded) {
+                  logger20.info(
+                    {
+                      compressorState: compressor.getState()
+                    },
+                    "Triggering layered mid-generation compression"
+                  );
+                  try {
+                    const originalMessages = stepMessages.slice(0, originalMessageCount);
+                    const generatedMessages = stepMessages.slice(originalMessageCount);
+                    if (generatedMessages.length > 0) {
+                      const compressionResult = await compressor.compress(generatedMessages);
+                      const finalMessages = [...originalMessages];
+                      if (compressionResult.summary.text_messages && compressionResult.summary.text_messages.length > 0) {
+                        finalMessages.push(...compressionResult.summary.text_messages);
+                      }
+                      const summaryMessage = JSON.stringify({
+                        high_level: compressionResult.summary?.summary?.high_level,
+                        user_intent: compressionResult.summary?.summary?.user_intent,
+                        decisions: compressionResult.summary?.summary?.decisions,
+                        open_questions: compressionResult.summary?.summary?.open_questions,
+                        next_steps: compressionResult.summary?.summary?.next_steps,
+                        related_artifacts: compressionResult?.summary?.summary?.related_artifacts
+                      });
+                      finalMessages.push({
+                        role: "user",
+                        content: `Based on your research, here's what you've discovered: ${summaryMessage}
+
+Now please provide your answer to my original question using this context.`
+                      });
+                      logger20.info(
+                        {
+                          originalTotal: stepMessages.length,
+                          compressed: finalMessages.length,
+                          originalKept: originalMessages.length,
+                          generatedCompressed: generatedMessages.length
+                        },
+                        "Generated content compression completed"
+                      );
+                      logger20.info({ summaryMessage }, "Summary message");
+                      return { messages: finalMessages };
+                    }
+                    return {};
+                  } catch (error) {
+                    logger20.error(
+                      {
+                        error: error instanceof Error ? error.message : String(error),
+                        stack: error instanceof Error ? error.stack : void 0
+                      },
+                      "Smart compression failed, falling back to simple compression"
+                    );
+                    try {
+                      const targetSize = Math.floor(compressor.getHardLimit() * 0.5);
+                      const fallbackMessages = this.simpleCompression(stepMessages, targetSize);
+                      logger20.info(
+                        {
+                          originalCount: stepMessages.length,
+                          compressedCount: fallbackMessages.length,
+                          compressionType: "simple_fallback"
+                        },
+                        "Simple compression fallback completed"
+                      );
+                      return { messages: fallbackMessages };
+                    } catch (fallbackError) {
+                      logger20.error(
+                        {
+                          error: fallbackError instanceof Error ? fallbackError.message : String(fallbackError)
+                        },
+                        "Fallback compression also failed, continuing without compression"
+                      );
+                      return {};
+                    }
+                  }
+                }
+                return {};
+              },
               stopWhen: async ({ steps }) => {
                 const last = steps.at(-1);
                 if (last && "text" in last && last.text) {
@@ -16199,7 +17125,7 @@ ${output}`;
                       }
                     );
                   } catch (error) {
-                    logger18.debug({ error }, "Failed to track agent reasoning");
+                    logger20.debug({ error }, "Failed to track agent reasoning");
                   }
                 }
                 if (last && last["content"] && last["content"].length > 0) {
@@ -16321,6 +17247,87 @@ ${output}`;
               ...genConfig,
               messages,
               tools: sanitizedTools,
+              prepareStep: async ({ messages: stepMessages }) => {
+                if (!compressor) {
+                  return {};
+                }
+                const compressionNeeded = compressor.isCompressionNeeded(stepMessages);
+                if (compressionNeeded) {
+                  logger20.info(
+                    {
+                      compressorState: compressor.getState()
+                    },
+                    "Triggering layered mid-generation compression"
+                  );
+                  try {
+                    const originalMessages = stepMessages.slice(0, originalMessageCount);
+                    const generatedMessages = stepMessages.slice(originalMessageCount);
+                    if (generatedMessages.length > 0) {
+                      const compressionResult = await compressor.compress(generatedMessages);
+                      const finalMessages = [...originalMessages];
+                      if (compressionResult.summary.text_messages && compressionResult.summary.text_messages.length > 0) {
+                        finalMessages.push(...compressionResult.summary.text_messages);
+                      }
+                      const summaryMessage = JSON.stringify({
+                        high_level: compressionResult.summary?.summary?.high_level,
+                        user_intent: compressionResult.summary?.summary?.user_intent,
+                        decisions: compressionResult.summary?.summary?.decisions,
+                        open_questions: compressionResult.summary?.summary?.open_questions,
+                        next_steps: compressionResult.summary?.summary?.next_steps,
+                        related_artifacts: compressionResult?.summary?.summary?.related_artifacts
+                      });
+                      finalMessages.push({
+                        role: "user",
+                        content: `Based on your research, here's what you've discovered: ${summaryMessage}
+
+Now please provide your answer to my original question using this context.`
+                      });
+                      logger20.info(
+                        {
+                          originalTotal: stepMessages.length,
+                          compressed: finalMessages.length,
+                          originalKept: originalMessages.length,
+                          generatedCompressed: generatedMessages.length
+                        },
+                        "Generated content compression completed"
+                      );
+                      logger20.info({ summaryMessage }, "Summary message");
+                      return { messages: finalMessages };
+                    }
+                    return {};
+                  } catch (error) {
+                    logger20.error(
+                      {
+                        error: error instanceof Error ? error.message : String(error),
+                        stack: error instanceof Error ? error.stack : void 0
+                      },
+                      "Smart compression failed, falling back to simple compression"
+                    );
+                    try {
+                      const targetSize = Math.floor(compressor.getHardLimit() * 0.5);
+                      const fallbackMessages = this.simpleCompression(stepMessages, targetSize);
+                      logger20.info(
+                        {
+                          originalCount: stepMessages.length,
+                          compressedCount: fallbackMessages.length,
+                          compressionType: "simple_fallback"
+                        },
+                        "Simple compression fallback completed"
+                      );
+                      return { messages: fallbackMessages };
+                    } catch (fallbackError) {
+                      logger20.error(
+                        {
+                          error: fallbackError instanceof Error ? fallbackError.message : String(fallbackError)
+                        },
+                        "Fallback compression also failed, continuing without compression"
+                      );
+                      return {};
+                    }
+                  }
+                }
+                return {};
+              },
               stopWhen: async ({ steps }) => {
                 const last = steps.at(-1);
                 if (last && "text" in last && last.text) {
@@ -16334,7 +17341,7 @@ ${output}`;
                       }
                     );
                   } catch (error) {
-                    logger18.debug({ error }, "Failed to track agent reasoning");
+                    logger20.debug({ error }, "Failed to track agent reasoning");
                   }
                 }
                 if (steps.length >= 2) {
@@ -16372,7 +17379,22 @@ ${output}`;
             const thinkingCompleteCall = response.steps?.flatMap((s4) => s4.toolCalls || [])?.find((tc) => tc.toolName === "thinking_complete");
             if (thinkingCompleteCall) {
               const reasoningFlow = [];
-              if (response.steps) {
+              const compressionSummary = this.currentCompressor?.getCompressionSummary();
+              if (compressionSummary) {
+                const summaryContent = JSON.stringify(compressionSummary, null, 2);
+                reasoningFlow.push({
+                  role: "assistant",
+                  content: `## Research Summary (Compressed)
+
+Based on tool executions, here's the comprehensive summary:
+
+\`\`\`json
+${summaryContent}
+\`\`\`
+
+This summary represents all tool execution results in compressed form. Full details are preserved in artifacts.`
+                });
+              } else if (response.steps) {
                 response.steps.forEach((step) => {
                   if (step.toolCalls && step.toolResults) {
                     step.toolCalls.forEach((call, index) => {
@@ -16481,7 +17503,7 @@ ${output}${structureHintsFormatted}`;
                 LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS
               );
               if (structuredModelSettings.maxDuration && structuredModelSettings.maxDuration * 1e3 > LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS) {
-                logger18.warn(
+                logger20.warn(
                   {
                     requestedTimeout: structuredModelSettings.maxDuration * 1e3,
                     appliedTimeout: phase2TimeoutMs,
@@ -16504,6 +17526,12 @@ ${output}${structureHintsFormatted}`;
                 }
                 phase2Messages.push({ role: "user", content: userMessage });
                 phase2Messages.push(...reasoningFlow);
+                if (reasoningFlow.length > 0 && reasoningFlow[reasoningFlow.length - 1]?.role === "assistant") {
+                  phase2Messages.push({
+                    role: "user",
+                    content: "Continue with the structured response."
+                  });
+                }
                 const streamResult = ai.streamObject({
                   ...structuredModelSettings,
                   messages: phase2Messages,
@@ -16574,6 +17602,12 @@ ${output}${structureHintsFormatted}`;
                 }
                 phase2Messages.push({ role: "user", content: userMessage });
                 phase2Messages.push(...reasoningFlow);
+                if (reasoningFlow.length > 0 && reasoningFlow[reasoningFlow.length - 1]?.role === "assistant") {
+                  phase2Messages.push({
+                    role: "user",
+                    content: "Continue with the structured response."
+                  });
+                }
                 const structuredResponse = await ai.generateObject(
                   withJsonPostProcessing2({
                     ...structuredModelSettings,
@@ -16644,8 +17678,10 @@ ${output}${structureHintsFormatted}`;
               generationType
             });
           }
+          this.currentCompressor = null;
           return formattedResponse;
         } catch (error) {
+          this.currentCompressor = null;
           const errorToThrow = error instanceof Error ? error : new Error(String(error));
           agentsCore.setSpanWithError(span, errorToThrow);
           span.end();
@@ -16657,7 +17693,7 @@ ${output}${structureHintsFormatted}`;
 };
 
 // src/agents/generateTaskHandler.ts
-var logger19 = agentsCore.getLogger("generateTaskHandler");
+var logger21 = agentsCore.getLogger("generateTaskHandler");
 var createTaskHandler = (config, credentialStoreRegistry) => {
   return async (task) => {
     try {
@@ -16775,7 +17811,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
               return { ...relation, description: enhancedDescription };
             }
           } catch (error) {
-            logger19.warn({ subAgentId: relation.id, error }, "Failed to enhance agent description");
+            logger21.warn({ subAgentId: relation.id, error }, "Failed to enhance agent description");
           }
           return relation;
         })
@@ -16833,7 +17869,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
               };
             }
           } catch (error) {
-            logger19.warn(
+            logger21.warn(
               { targetAgentId: relation.targetAgentId, error },
               "Failed to enhance team agent description"
             );
@@ -16855,7 +17891,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
           );
           if (item.selectedTools && item.selectedTools.length > 0) {
             const selectedToolsSet = new Set(item.selectedTools);
-            mcpTool.availableTools = mcpTool.availableTools?.filter((tool3) => selectedToolsSet.has(tool3.name)) || [];
+            mcpTool.availableTools = mcpTool.availableTools?.filter((tool4) => selectedToolsSet.has(tool4.name)) || [];
           }
           return mcpTool;
         })
@@ -16922,7 +17958,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
                 targetTransferRelations = transferRel;
                 targetDelegateRelations = delegateRel;
               } catch (err2) {
-                logger19.info(
+                logger21.info(
                   {
                     agentId: relation.id,
                     error: err2?.message || "Unknown error"
@@ -16942,7 +17978,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
                   if (item.selectedTools && item.selectedTools.length > 0) {
                     const selectedToolsSet = new Set(item.selectedTools);
                     mcpTool.availableTools = mcpTool.availableTools?.filter(
-                      (tool3) => selectedToolsSet.has(tool3.name)
+                      (tool4) => selectedToolsSet.has(tool4.name)
                     ) || [];
                   }
                   return mcpTool;
@@ -17063,7 +18099,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
         const taskIdMatch = task.id.match(/^task_([^-]+-[^-]+-\d+)-/);
         if (taskIdMatch) {
           contextId = taskIdMatch[1];
-          logger19.info(
+          logger21.info(
             {
               taskId: task.id,
               extractedContextId: contextId,
@@ -17081,7 +18117,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
       agent.setDelegationStatus(isDelegation);
       agent.setDelegationId(delegationId);
       if (isDelegation) {
-        logger19.info(
+        logger21.info(
           { subAgentId: config.subAgentId, taskId: task.id, delegationId },
           "Delegated agent - streaming disabled"
         );
@@ -17118,7 +18154,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
             const toolResult = allToolResults.find(
               (result) => result.toolCallId === toolCall.toolCallId
             );
-            logger19.info(
+            logger21.info(
               {
                 toolCallName: toolCall.toolName,
                 toolCallId: toolCall.toolCallId,
@@ -17135,7 +18171,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
             const transferReason = responseText || allThoughts[allThoughts.length - 1]?.text || "Agent requested transfer. No reason provided.";
             if (toolResult?.output && isValidTransferResult(toolResult.output)) {
               const transferResult = toolResult.output;
-              logger19.info(
+              logger21.info(
                 {
                   validationPassed: true,
                   transferResult,
@@ -17152,7 +18188,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
                 reason: transferReason,
                 original_message: userMessage
               };
-              logger19.info(
+              logger21.info(
                 {
                   artifactData,
                   artifactDataKeys: Object.keys(artifactData)
@@ -17177,7 +18213,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
                 ]
               };
             }
-            logger19.warn(
+            logger21.warn(
               {
                 hasToolResult: !!toolResult,
                 hasOutput: !!toolResult?.output,
@@ -17271,7 +18307,7 @@ var createTaskHandlerConfig = async (params) => {
 // src/data/agents.ts
 init_logger();
 init_dbClient();
-var logger20 = agentsCore.getLogger("agents");
+var logger22 = agentsCore.getLogger("agents");
 function createAgentCard({
   dbAgent,
   baseUrl
@@ -17382,7 +18418,7 @@ async function getRegisteredAgent(params) {
     const agent = await agentsCore.getAgentWithDefaultSubAgent(dbClient_default)({
       scopes: { tenantId, projectId, agentId }
     });
-    logger20.info({ agent }, "agent with default sub agent");
+    logger22.info({ agent }, "agent with default sub agent");
     if (!agent || !agent.defaultSubAgent) {
       return null;
     }
@@ -17416,7 +18452,7 @@ async function getRegisteredAgent(params) {
 init_dbClient();
 init_logger();
 var app = new zodOpenapi.OpenAPIHono();
-var logger21 = agentsCore.getLogger("agents");
+var logger23 = agentsCore.getLogger("agents");
 app.openapi(
   zodOpenapi.createRoute({
     method: "get",
@@ -17454,7 +18490,7 @@ app.openapi(
       tracestate: c2.req.header("tracestate"),
       baggage: c2.req.header("baggage")
     };
-    logger21.info(
+    logger23.info(
       {
         otelHeaders,
         path: c2.req.path,
@@ -17464,8 +18500,8 @@ app.openapi(
     );
     const executionContext = agentsCore.getRequestExecutionContext(c2);
     const { tenantId, projectId, agentId, subAgentId } = executionContext;
-    logger21.info({ executionContext }, "executionContext");
-    logger21.info(
+    logger23.info({ executionContext }, "executionContext");
+    logger23.info(
       {
         message: "getRegisteredAgent (agent-level)",
         tenantId,
@@ -17482,7 +18518,7 @@ app.openapi(
       credentialStoreRegistry: credentialStores,
       sandboxConfig
     });
-    logger21.info({ agent }, "agent registered: well-known agent.json");
+    logger23.info({ agent }, "agent registered: well-known agent.json");
     if (!agent) {
       throw agentsCore.createApiError({
         code: "not_found",
@@ -17498,7 +18534,7 @@ app.post("/a2a", async (c2) => {
     tracestate: c2.req.header("tracestate"),
     baggage: c2.req.header("baggage")
   };
-  logger21.info(
+  logger23.info(
     {
       otelHeaders,
       path: c2.req.path,
@@ -17509,7 +18545,7 @@ app.post("/a2a", async (c2) => {
   const executionContext = agentsCore.getRequestExecutionContext(c2);
   const { tenantId, projectId, agentId, subAgentId } = executionContext;
   if (subAgentId) {
-    logger21.info(
+    logger23.info(
       {
         message: "a2a (agent-level)",
         tenantId,
@@ -17538,7 +18574,7 @@ app.post("/a2a", async (c2) => {
     }
     return a2aHandler(c2, agent2);
   }
-  logger21.info(
+  logger23.info(
     {
       message: "a2a (agent-level)",
       tenantId,
@@ -17623,14 +18659,14 @@ function extractTransferData(task) {
 }
 
 // src/a2a/transfer.ts
-var logger22 = agentsCore.getLogger("Transfer");
+var logger24 = agentsCore.getLogger("Transfer");
 async function executeTransfer({
   tenantId,
   threadId,
   projectId,
   targetSubAgentId
 }) {
-  logger22.info(
+  logger24.info(
     {
       targetAgent: targetSubAgentId,
       threadId,
@@ -17645,12 +18681,12 @@ async function executeTransfer({
       threadId,
       subAgentId: targetSubAgentId
     });
-    logger22.info(
+    logger24.info(
       { targetAgent: targetSubAgentId, threadId },
       "Successfully updated active_sub_agent_id in database"
     );
   } catch (error) {
-    logger22.error(
+    logger24.error(
       { error, targetAgent: targetSubAgentId, threadId },
       "Failed to update active_sub_agent_id"
     );
@@ -18222,7 +19258,7 @@ function createBufferingStreamHelper() {
 var createMCPStreamHelper = createBufferingStreamHelper;
 
 // src/handlers/executionHandler.ts
-var logger23 = agentsCore.getLogger("ExecutionHandler");
+var logger25 = agentsCore.getLogger("ExecutionHandler");
 var ExecutionHandler = class {
   MAX_ERRORS = AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS;
   /**
@@ -18255,7 +19291,7 @@ var ExecutionHandler = class {
     if (emitOperations) {
       agentSessionManager.enableEmitOperations(requestId2);
     }
-    logger23.info(
+    logger25.info(
       { sessionId: requestId2, agentId, conversationId, emitOperations },
       "Created AgentSession for message execution"
     );
@@ -18288,7 +19324,7 @@ var ExecutionHandler = class {
             );
           }
         } catch (modelError) {
-          logger23.warn(
+          logger25.warn(
             {
               error: modelError instanceof Error ? modelError.message : "Unknown error",
               agentId
@@ -18303,7 +19339,7 @@ var ExecutionHandler = class {
         }
       }
     } catch (error) {
-      logger23.error(
+      logger25.error(
         {
           error: error instanceof Error ? error.message : "Unknown error",
           stack: error instanceof Error ? error.stack : void 0
@@ -18319,7 +19355,7 @@ var ExecutionHandler = class {
     try {
       await sseHelper.writeOperation(agentInitializingOp(requestId2, agentId));
       const taskId = `task_${conversationId}-${requestId2}`;
-      logger23.info(
+      logger25.info(
         { taskId, currentAgentId, conversationId, requestId: requestId2 },
         "Attempting to create or reuse existing task"
       );
@@ -18343,7 +19379,7 @@ var ExecutionHandler = class {
             sub_agent_id: currentAgentId
           }
         });
-        logger23.info(
+        logger25.info(
           {
             taskId,
             createdTaskMetadata: Array.isArray(task) ? task[0]?.metadata : task?.metadata
@@ -18352,27 +19388,27 @@ var ExecutionHandler = class {
         );
       } catch (error) {
         if (error?.cause?.code === "23505") {
-          logger23.info(
+          logger25.info(
             { taskId, error: error.message },
             "Task already exists, fetching existing task"
           );
           const existingTask = await agentsCore.getTask(dbClient_default)({ id: taskId });
           if (existingTask) {
             task = existingTask;
-            logger23.info(
+            logger25.info(
               { taskId, existingTask },
               "Successfully reused existing task from race condition"
             );
           } else {
-            logger23.error({ taskId, error }, "Task constraint failed but task not found");
+            logger25.error({ taskId, error }, "Task constraint failed but task not found");
             throw error;
           }
         } else {
-          logger23.error({ taskId, error }, "Failed to create task due to non-constraint error");
+          logger25.error({ taskId, error }, "Failed to create task due to non-constraint error");
           throw error;
         }
       }
-      logger23.debug(
+      logger25.debug(
         {
           timestamp: /* @__PURE__ */ new Date(),
           executionType: "create_initial_task",
@@ -18391,7 +19427,7 @@ var ExecutionHandler = class {
       const maxTransfers = agentConfig?.stopWhen?.transferCountIs ?? agentsCore.AGENT_EXECUTION_TRANSFER_COUNT_DEFAULT;
       while (iterations < maxTransfers) {
         iterations++;
-        logger23.info(
+        logger25.info(
           { iterations, currentAgentId, agentId, conversationId, fromSubAgentId },
           `Execution loop iteration ${iterations} with agent ${currentAgentId}, transfer from: ${fromSubAgentId || "none"}`
         );
@@ -18399,10 +19435,10 @@ var ExecutionHandler = class {
           scopes: { tenantId, projectId },
           conversationId
         });
-        logger23.info({ activeAgent }, "activeAgent");
+        logger25.info({ activeAgent }, "activeAgent");
         if (activeAgent && activeAgent.activeSubAgentId !== currentAgentId) {
           currentAgentId = activeAgent.activeSubAgentId;
-          logger23.info({ currentAgentId }, `Updated current agent to: ${currentAgentId}`);
+          logger25.info({ currentAgentId }, `Updated current agent to: ${currentAgentId}`);
         }
         const agentBaseUrl = `${baseUrl}/agents`;
         const a2aClient = new A2AClient(agentBaseUrl, {
@@ -18443,13 +19479,13 @@ var ExecutionHandler = class {
         });
         if (!messageResponse?.result) {
           errorCount++;
-          logger23.error(
+          logger25.error(
             { currentAgentId, iterations, errorCount },
             `No response from agent ${currentAgentId} on iteration ${iterations} (error ${errorCount}/${this.MAX_ERRORS})`
           );
           if (errorCount >= this.MAX_ERRORS) {
             const errorMessage2 = `Maximum error limit (${this.MAX_ERRORS}) reached`;
-            logger23.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
+            logger25.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
             await sseHelper.writeOperation(errorOp(errorMessage2, currentAgentId || "system"));
             if (task) {
               await agentsCore.updateTask(dbClient_default)({
@@ -18473,7 +19509,7 @@ var ExecutionHandler = class {
         if (isTransferTask(messageResponse.result)) {
           const transferData = extractTransferData(messageResponse.result);
           if (!transferData) {
-            logger23.error(
+            logger25.error(
               { result: messageResponse.result },
               "Transfer detected but no transfer data found"
             );
@@ -18482,7 +19518,7 @@ var ExecutionHandler = class {
           const { targetSubAgentId, fromSubAgentId: transferFromAgent } = transferData;
           const firstArtifact = messageResponse.result.artifacts[0];
           const transferReason = firstArtifact?.parts[1]?.kind === "text" ? firstArtifact.parts[1].text : "Transfer initiated";
-          logger23.info({ targetSubAgentId, transferReason, transferFromAgent }, "Transfer response");
+          logger25.info({ targetSubAgentId, transferReason, transferFromAgent }, "Transfer response");
           await agentsCore.createMessage(dbClient_default)({
             id: agentsCore.generateId(),
             tenantId,
@@ -18513,7 +19549,7 @@ var ExecutionHandler = class {
           if (success) {
             fromSubAgentId = currentAgentId;
             currentAgentId = newAgentId;
-            logger23.info(
+            logger25.info(
               {
                 transferFrom: fromSubAgentId,
                 transferTo: currentAgentId,
@@ -18527,7 +19563,7 @@ var ExecutionHandler = class {
         let responseParts = [];
         if (messageResponse.result.streamedContent?.parts) {
           responseParts = messageResponse.result.streamedContent.parts;
-          logger23.info(
+          logger25.info(
             { partsCount: responseParts.length },
             "Using streamed content for conversation history"
           );
@@ -18535,7 +19571,7 @@ var ExecutionHandler = class {
           responseParts = messageResponse.result.artifacts?.flatMap(
             (artifact) => artifact.parts || []
           ) || [];
-          logger23.info(
+          logger25.info(
             { partsCount: responseParts.length },
             "Using artifacts for conversation history (fallback)"
           );
@@ -18544,7 +19580,7 @@ var ExecutionHandler = class {
           const agentSessionData = agentSessionManager.getSession(requestId2);
           if (agentSessionData) {
             const sessionSummary = agentSessionData.getSummary();
-            logger23.info(sessionSummary, "AgentSession data after completion");
+            logger25.info(sessionSummary, "AgentSession data after completion");
           }
           let textContent = "";
           for (const part of responseParts) {
@@ -18598,22 +19634,22 @@ var ExecutionHandler = class {
                 }
               });
               const updateTaskEnd = Date.now();
-              logger23.info(
+              logger25.info(
                 { duration: updateTaskEnd - updateTaskStart },
                 "Completed updateTask operation"
               );
               await sseHelper.writeOperation(completionOp(currentAgentId, iterations));
               await sseHelper.complete();
-              logger23.info({}, "Ending AgentSession and cleaning up");
+              logger25.info({}, "Ending AgentSession and cleaning up");
               await agentSessionManager.endSession(requestId2);
-              logger23.info({}, "Cleaning up streamHelper");
+              logger25.info({}, "Cleaning up streamHelper");
               unregisterStreamHelper(requestId2);
               let response;
               if (sseHelper instanceof BufferingStreamHelper) {
                 const captured = sseHelper.getCapturedResponse();
                 response = captured.text || "No response content";
               }
-              logger23.info({}, "ExecutionHandler returning success");
+              logger25.info({}, "ExecutionHandler returning success");
               return { success: true, iterations, response };
             } catch (error) {
               agentsCore.setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
@@ -18624,13 +19660,13 @@ var ExecutionHandler = class {
           });
         }
         errorCount++;
-        logger23.warn(
+        logger25.warn(
           { iterations, errorCount },
           `No valid response or transfer on iteration ${iterations} (error ${errorCount}/${this.MAX_ERRORS})`
         );
         if (errorCount >= this.MAX_ERRORS) {
           const errorMessage2 = `Maximum error limit (${this.MAX_ERRORS}) reached`;
-          logger23.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
+          logger25.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
           await sseHelper.writeOperation(errorOp(errorMessage2, currentAgentId || "system"));
           if (task) {
             await agentsCore.updateTask(dbClient_default)({
@@ -18651,7 +19687,7 @@ var ExecutionHandler = class {
         }
       }
       const errorMessage = `Maximum transfer limit (${maxTransfers}) reached without completion`;
-      logger23.error({ maxTransfers, iterations }, errorMessage);
+      logger25.error({ maxTransfers, iterations }, errorMessage);
       await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || "system"));
       if (task) {
         await agentsCore.updateTask(dbClient_default)({
@@ -18670,7 +19706,7 @@ var ExecutionHandler = class {
       unregisterStreamHelper(requestId2);
       return { success: false, error: errorMessage, iterations };
     } catch (error) {
-      logger23.error({ error }, "Error in execution handler");
+      logger25.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")
@@ -18698,7 +19734,7 @@ var ExecutionHandler = class {
 // src/routes/chat.ts
 init_logger();
 var app2 = new zodOpenapi.OpenAPIHono();
-var logger24 = agentsCore.getLogger("completionsHandler");
+var logger26 = agentsCore.getLogger("completionsHandler");
 var chatCompletionsRoute = zodOpenapi.createRoute({
   method: "post",
   path: "/completions",
@@ -18816,7 +19852,7 @@ app2.openapi(chatCompletionsRoute, async (c2) => {
     tracestate: c2.req.header("tracestate"),
     baggage: c2.req.header("baggage")
   };
-  logger24.info(
+  logger26.info(
     {
       otelHeaders,
       path: c2.req.path,
@@ -18925,7 +19961,7 @@ app2.openapi(chatCompletionsRoute, async (c2) => {
         dbClient: dbClient_default,
         credentialStores
       });
-      logger24.info(
+      logger26.info(
         {
           tenantId,
           projectId,
@@ -18973,7 +20009,7 @@ app2.openapi(chatCompletionsRoute, async (c2) => {
         try {
           const sseHelper = createSSEStreamHelper(stream2, requestId2, timestamp);
           await sseHelper.writeRole();
-          logger24.info({ subAgentId }, "Starting execution");
+          logger26.info({ subAgentId }, "Starting execution");
           const emitOperationsHeader = c2.req.header("x-emit-operations");
           const emitOperations = emitOperationsHeader === "true";
           const executionHandler = new ExecutionHandler();
@@ -18986,7 +20022,7 @@ app2.openapi(chatCompletionsRoute, async (c2) => {
             sseHelper,
             emitOperations
           });
-          logger24.info(
+          logger26.info(
             { result },
             `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
           );
@@ -19000,7 +20036,7 @@ app2.openapi(chatCompletionsRoute, async (c2) => {
           }
           await sseHelper.complete();
         } catch (error) {
-          logger24.error(
+          logger26.error(
             {
               error: error instanceof Error ? error.message : error,
               stack: error instanceof Error ? error.stack : void 0
@@ -19017,13 +20053,13 @@ app2.openapi(chatCompletionsRoute, async (c2) => {
             );
             await sseHelper.complete();
           } catch (streamError) {
-            logger24.error({ streamError }, "Failed to write error to stream");
+            logger26.error({ streamError }, "Failed to write error to stream");
           }
         }
       });
     });
   } catch (error) {
-    logger24.error(
+    logger26.error(
       {
         error: error instanceof Error ? error.message : error,
         stack: error instanceof Error ? error.stack : void 0
@@ -19051,7 +20087,7 @@ var chat_default = app2;
 init_dbClient();
 init_logger();
 var app3 = new zodOpenapi.OpenAPIHono();
-var logger25 = agentsCore.getLogger("chatDataStream");
+var logger27 = agentsCore.getLogger("chatDataStream");
 var chatDataStreamRoute = zodOpenapi.createRoute({
   method: "post",
   path: "/chat",
@@ -19178,7 +20214,7 @@ app3.openapi(chatDataStreamRoute, async (c2) => {
       });
       const lastUserMessage = body2.messages.filter((m4) => m4.role === "user").slice(-1)[0];
       const userText = typeof lastUserMessage?.content === "string" ? lastUserMessage.content : lastUserMessage?.parts?.map((p4) => p4.text).join("") || "";
-      logger25.info({ userText, lastUserMessage }, "userText");
+      logger27.info({ userText, lastUserMessage }, "userText");
       const messageSpan = api.trace.getActiveSpan();
       if (messageSpan) {
         messageSpan.setAttributes({
@@ -19261,7 +20297,7 @@ app3.openapi(chatDataStreamRoute, async (c2) => {
               await streamHelper.writeOperation(errorOp("Unable to process request", "system"));
             }
           } catch (err2) {
-            logger25.error({ err: err2 }, "Streaming error");
+            logger27.error({ err: err2 }, "Streaming error");
             await streamHelper.writeOperation(errorOp("Internal server error", "system"));
           } finally {
             if ("cleanup" in streamHelper && typeof streamHelper.cleanup === "function") {
@@ -19283,7 +20319,7 @@ app3.openapi(chatDataStreamRoute, async (c2) => {
       );
     });
   } catch (error) {
-    logger25.error(
+    logger27.error(
       {
         error,
         errorMessage: error instanceof Error ? error.message : String(error),
@@ -19372,7 +20408,7 @@ app3.openapi(toolApprovalRoute, async (c2) => {
       const { tenantId, projectId } = executionContext;
       const requestBody = await c2.req.json();
       const { conversationId, toolCallId, approved, reason } = requestBody;
-      logger25.info(
+      logger27.info(
         {
           conversationId,
           toolCallId,
@@ -19401,7 +20437,7 @@ app3.openapi(toolApprovalRoute, async (c2) => {
         span.setStatus({ code: 1, message: "Tool call not found" });
         return c2.json({ error: "Tool call not found or already processed" }, 404);
       }
-      logger25.info({ conversationId, toolCallId, approved }, "Tool approval processed successfully");
+      logger27.info({ conversationId, toolCallId, approved }, "Tool approval processed successfully");
       span.setStatus({ code: 1, message: "Success" });
       return c2.json({
         success: true,
@@ -19409,7 +20445,7 @@ app3.openapi(toolApprovalRoute, async (c2) => {
       });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      logger25.error(
+      logger27.error(
         {
           error: errorMessage,
           stack: error instanceof Error ? error.stack : void 0
@@ -19434,7 +20470,7 @@ var chatDataStream_default = app3;
 // src/routes/mcp.ts
 init_dbClient();
 init_logger();
-var logger26 = agentsCore.getLogger("mcp");
+var logger28 = agentsCore.getLogger("mcp");
 var MockResponseSingleton = class _MockResponseSingleton {
   static instance;
   mockRes;
@@ -19488,21 +20524,21 @@ var createSpoofInitMessage = (mcpProtocolVersion) => ({
   id: 0
 });
 var spoofTransportInitialization = async (transport, req, sessionId, mcpProtocolVersion) => {
-  logger26.info({ sessionId }, "Spoofing initialization message to set transport state");
+  logger28.info({ sessionId }, "Spoofing initialization message to set transport state");
   const spoofInitMessage = createSpoofInitMessage(mcpProtocolVersion);
   const mockRes = MockResponseSingleton.getInstance().getMockResponse();
   try {
     await transport.handleRequest(req, mockRes, spoofInitMessage);
-    logger26.info({ sessionId }, "Successfully spoofed initialization");
+    logger28.info({ sessionId }, "Successfully spoofed initialization");
   } catch (spoofError) {
-    logger26.warn({ sessionId, error: spoofError }, "Spoof initialization failed, continuing anyway");
+    logger28.warn({ sessionId, error: spoofError }, "Spoof initialization failed, continuing anyway");
   }
 };
 var validateSession = async (req, res, body2, tenantId, projectId, agentId) => {
   const sessionId = req.headers["mcp-session-id"];
-  logger26.info({ sessionId }, "Received MCP session ID");
+  logger28.info({ sessionId }, "Received MCP session ID");
   if (!sessionId) {
-    logger26.info({ body: body2 }, "Missing session ID");
+    logger28.info({ body: body2 }, "Missing session ID");
     res.writeHead(400).end(
       JSON.stringify({
         jsonrpc: "2.0",
@@ -19529,7 +20565,7 @@ var validateSession = async (req, res, body2, tenantId, projectId, agentId) => {
     scopes: { tenantId, projectId },
     conversationId: sessionId
   });
-  logger26.info(
+  logger28.info(
     {
       sessionId,
       conversationFound: !!conversation,
@@ -19540,7 +20576,7 @@ var validateSession = async (req, res, body2, tenantId, projectId, agentId) => {
     "Conversation lookup result"
   );
   if (!conversation || conversation.metadata?.sessionData?.sessionType !== "mcp" || conversation.metadata?.sessionData?.agentId !== agentId) {
-    logger26.info(
+    logger28.info(
       { sessionId, conversationId: conversation?.id },
       "MCP session not found or invalid"
     );
@@ -19601,7 +20637,7 @@ var executeAgentQuery = async (executionContext, conversationId, query, defaultS
     requestId: requestId2,
     sseHelper: mcpStreamHelper
   });
-  logger26.info(
+  logger28.info(
     { result },
     `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
   );
@@ -19685,7 +20721,7 @@ var getServer = async (headers2, executionContext, conversationId, credentialSto
           dbClient: dbClient_default,
           credentialStores
         });
-        logger26.info(
+        logger28.info(
           {
             tenantId,
             projectId,
@@ -19747,7 +20783,7 @@ var validateRequestParameters = (c2) => {
 };
 var handleInitializationRequest = async (body2, executionContext, validatedContext, req, res, c2, credentialStores) => {
   const { tenantId, projectId, agentId } = executionContext;
-  logger26.info({ body: body2 }, "Received initialization request");
+  logger28.info({ body: body2 }, "Received initialization request");
   const sessionId = agentsCore.getConversationId();
   const activeSpan = api.trace.getActiveSpan();
   if (activeSpan) {
@@ -19803,7 +20839,7 @@ var handleInitializationRequest = async (body2, executionContext, validatedConte
         }
       }
     });
-    logger26.info(
+    logger28.info(
       { sessionId, conversationId: conversation.id },
       "Created MCP session as conversation"
     );
@@ -19812,9 +20848,9 @@ var handleInitializationRequest = async (body2, executionContext, validatedConte
     });
     const server = await getServer(validatedContext, executionContext, sessionId, credentialStores);
     await server.connect(transport);
-    logger26.info({ sessionId }, "Server connected for initialization");
+    logger28.info({ sessionId }, "Server connected for initialization");
     res.setHeader("Mcp-Session-Id", sessionId);
-    logger26.info(
+    logger28.info(
       {
         sessionId,
         bodyMethod: body2?.method,
@@ -19823,7 +20859,7 @@ var handleInitializationRequest = async (body2, executionContext, validatedConte
       "About to handle initialization request"
     );
     await transport.handleRequest(req, res, body2);
-    logger26.info({ sessionId }, "Successfully handled initialization request");
+    logger28.info({ sessionId }, "Successfully handled initialization request");
     return fetchToNode.toFetchResponse(res);
   });
 };
@@ -19850,8 +20886,8 @@ var handleExistingSessionRequest = async (body2, executionContext, validatedCont
     sessionId,
     conversation.metadata?.session_data?.mcpProtocolVersion
   );
-  logger26.info({ sessionId }, "Server connected and transport initialized");
-  logger26.info(
+  logger28.info({ sessionId }, "Server connected and transport initialized");
+  logger28.info(
     {
       sessionId,
       bodyKeys: Object.keys(body2 || {}),
@@ -19865,9 +20901,9 @@ var handleExistingSessionRequest = async (body2, executionContext, validatedCont
   );
   try {
     await transport.handleRequest(req, res, body2);
-    logger26.info({ sessionId }, "Successfully handled MCP request");
+    logger28.info({ sessionId }, "Successfully handled MCP request");
   } catch (transportError) {
-    logger26.error(
+    logger28.error(
       {
         sessionId,
         error: transportError,
@@ -19918,13 +20954,13 @@ app4.openapi(
       }
       const { executionContext } = paramValidation;
       const body2 = c2.get("requestBody") || {};
-      logger26.info({ body: body2, bodyKeys: Object.keys(body2 || {}) }, "Parsed request body");
+      logger28.info({ body: body2, bodyKeys: Object.keys(body2 || {}) }, "Parsed request body");
       const isInitRequest = body2.method === "initialize";
       const { req, res } = fetchToNode.toReqRes(c2.req.raw);
       const validatedContext = c2.get("validatedContext") || {};
       const credentialStores = c2.get("credentialStores");
-      logger26.info({ validatedContext }, "Validated context");
-      logger26.info({ req }, "request");
+      logger28.info({ validatedContext }, "Validated context");
+      logger28.info({ req }, "request");
       if (isInitRequest) {
         return await handleInitializationRequest(
           body2,
@@ -19945,7 +20981,7 @@ app4.openapi(
         credentialStores
       );
     } catch (e) {
-      logger26.error(
+      logger28.error(
         {
           error: e instanceof Error ? e.message : e,
           stack: e instanceof Error ? e.stack : void 0
@@ -19957,7 +20993,7 @@ app4.openapi(
   }
 );
 app4.get("/", async (c2) => {
-  logger26.info({}, "Received GET MCP request");
+  logger28.info({}, "Received GET MCP request");
   return c2.json(
     {
       jsonrpc: "2.0",
@@ -19971,7 +21007,7 @@ app4.get("/", async (c2) => {
   );
 });
 app4.delete("/", async (c2) => {
-  logger26.info({}, "Received DELETE MCP request");
+  logger28.info({}, "Received DELETE MCP request");
   return c2.json(
     {
       jsonrpc: "2.0",
@@ -19984,7 +21020,7 @@ app4.delete("/", async (c2) => {
 var mcp_default = app4;
 
 // src/app.ts
-var logger27 = agentsCore.getLogger("agents-run-api");
+var logger29 = agentsCore.getLogger("agents-run-api");
 function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
   const app6 = new zodOpenapi.OpenAPIHono();
   app6.use("*", otel.otel());
@@ -20003,7 +21039,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
         const body2 = await c2.req.json();
         c2.set("requestBody", body2);
       } catch (error) {
-        logger27.debug({ error }, "Failed to parse JSON body, continuing without parsed body");
+        logger29.debug({ error }, "Failed to parse JSON body, continuing without parsed body");
       }
     }
     return next();
@@ -20054,8 +21090,8 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
       if (!isExpectedError) {
         const errorMessage = err2 instanceof Error ? err2.message : String(err2);
         const errorStack = err2 instanceof Error ? err2.stack : void 0;
-        if (logger27) {
-          logger27.error(
+        if (logger29) {
+          logger29.error(
             {
               error: err2,
               message: errorMessage,
@@ -20067,8 +21103,8 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
           );
         }
       } else {
-        if (logger27) {
-          logger27.error(
+        if (logger29) {
+          logger29.error(
             {
               error: err2,
               path: c2.req.path,
@@ -20085,8 +21121,8 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
         const response = err2.getResponse();
         return response;
       } catch (responseError) {
-        if (logger27) {
-          logger27.error({ error: responseError }, "Error while handling HTTPException response");
+        if (logger29) {
+          logger29.error({ error: responseError }, "Error while handling HTTPException response");
         }
       }
     }
@@ -20120,7 +21156,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
   app6.use("*", async (c2, next) => {
     const executionContext = c2.get("executionContext");
     if (!executionContext) {
-      logger27.debug({}, "Empty execution context");
+      logger29.debug({}, "Empty execution context");
       return next();
     }
     const { tenantId, projectId, agentId } = executionContext;
@@ -20129,7 +21165,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
     if (requestBody) {
       conversationId = requestBody.conversationId;
       if (!conversationId) {
-        logger27.debug({ requestBody }, "No conversation ID found in request body");
+        logger29.debug({ requestBody }, "No conversation ID found in request body");
       }
     }
     const entries = Object.fromEntries(
@@ -20144,7 +21180,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
       })
     );
     if (!Object.keys(entries).length) {
-      logger27.debug({}, "Empty entries for baggage");
+      logger29.debug({}, "Empty entries for baggage");
       return next();
     }
     const bag = Object.entries(entries).reduce(