@inkeep/agents-run-api 0.37.2 → 0.38.1

package/dist/index.js

@@ -1,12 +1,12 @@
-import { flushBatchProcessor } from './chunk-QOUOKHYQ.js';
-import { getFormattedConversationHistory, createDefaultConversationHistoryConfig, saveA2AMessageResponse } from './chunk-BQB27EXW.js';
-import { dbClient_default } from './chunk-W6UIBREL.js';
-import { env } from './chunk-CDYXP4BN.js';
+import { defaultSDK, flushBatchProcessor } from './chunk-UC2EPLSW.js';
+import { getFormattedConversationHistory, createDefaultConversationHistoryConfig, saveA2AMessageResponse } from './chunk-KCJWSIDZ.js';
+import { dbClient_default } from './chunk-EVOISBFH.js';
+import { env } from './chunk-KBZIYCPJ.js';
 import { getLogger } from './chunk-A2S7GSHL.js';
-import { SESSION_CLEANUP_INTERVAL_MS, AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS, SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS, STREAM_MAX_LIFETIME_MS, STREAM_BUFFER_MAX_SIZE_BYTES, STREAM_TEXT_GAP_THRESHOLD_MS, ARTIFACT_GENERATION_MAX_RETRIES, ARTIFACT_SESSION_MAX_PENDING, STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS, STATUS_UPDATE_DEFAULT_NUM_EVENTS, ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES, AGENT_EXECUTION_MAX_GENERATION_STEPS, FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS, ARTIFACT_GENERATION_BACKOFF_INITIAL_MS, ARTIFACT_GENERATION_BACKOFF_MAX_MS, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING, LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS, DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS, DELEGATION_TOOL_BACKOFF_EXPONENT, DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS, DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS, STREAM_PARSER_MAX_SNAPSHOT_SIZE, STREAM_PARSER_MAX_STREAMED_SIZE, STREAM_PARSER_MAX_COLLECTED_PARTS } from './chunk-SUUSOBLI.js';
-import { getTracer, HeadersScopeSchema, getRequestExecutionContext, createApiError, getAgentWithDefaultSubAgent, contextValidationMiddleware, getConversationId, getFullAgent, createOrGetConversation, getActiveAgentForConversation, setActiveAgentForConversation, getSubAgentById, handleContextResolution, createMessage, generateId, commonGetErrorResponses, loggerFactory, getConversation, createDefaultCredentialStores, CredentialStoreRegistry, createTask, getTask, updateTask, setSpanWithError, AGENT_EXECUTION_TRANSFER_COUNT_DEFAULT, updateConversation, handleApiError, TaskState, getAgentById, getProject, setActiveAgentForThread, getRelatedAgentsForAgent, getExternalAgentsForSubAgent, getTeamAgentsForSubAgent, getToolsForAgent, getDataComponentsForAgent, getArtifactComponentsForAgent, dbResultToMcpTool, CONVERSATION_HISTORY_MAX_OUTPUT_TOKENS_DEFAULT, CONVERSATION_HISTORY_DEFAULT_LIMIT, ModelFactory, verifyTempToken, validateAndGetApiKey, verifyServiceToken, validateTargetAgent, ContextResolver, CredentialStuffer, MCPServerType, getCredentialReference, McpClient, getFunctionToolsForSubAgent, getFunction, getContextConfigById, getFullAgentDefinition, TemplateEngine, listTaskIdsByContextId, getLedgerArtifacts, agentHasArtifactComponents, upsertLedgerArtifact, MCPTransportType, SPAN_KEYS, headers, generateServiceToken } from '@inkeep/agents-core';
+import { SESSION_CLEANUP_INTERVAL_MS, AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS, SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS, STREAM_MAX_LIFETIME_MS, STREAM_BUFFER_MAX_SIZE_BYTES, STREAM_TEXT_GAP_THRESHOLD_MS, ARTIFACT_GENERATION_MAX_RETRIES, ARTIFACT_SESSION_MAX_PENDING, STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS, STATUS_UPDATE_DEFAULT_NUM_EVENTS, ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES, AGENT_EXECUTION_MAX_GENERATION_STEPS, FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS, ARTIFACT_GENERATION_BACKOFF_INITIAL_MS, ARTIFACT_GENERATION_BACKOFF_MAX_MS, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING, LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS, DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS, DELEGATION_TOOL_BACKOFF_EXPONENT, DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS, DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS, STREAM_PARSER_MAX_SNAPSHOT_SIZE, STREAM_PARSER_MAX_STREAMED_SIZE, STREAM_PARSER_MAX_COLLECTED_PARTS } from './chunk-THWNUGWP.js';
+import { getTracer, HeadersScopeSchema, getRequestExecutionContext, createApiError, getAgentWithDefaultSubAgent, contextValidationMiddleware, getConversationId, getFullAgent, createOrGetConversation, getActiveAgentForConversation, setActiveAgentForConversation, getSubAgentById, handleContextResolution, createMessage, generateId, commonGetErrorResponses, loggerFactory, getConversation, createDefaultCredentialStores, CredentialStoreRegistry, createTask, getTask, updateTask, setSpanWithError, AGENT_EXECUTION_TRANSFER_COUNT_DEFAULT, updateConversation, handleApiError, TaskState, getAgentById, getProject, setActiveAgentForThread, getRelatedAgentsForAgent, getExternalAgentsForSubAgent, getTeamAgentsForSubAgent, getToolsForAgent, getDataComponentsForAgent, getArtifactComponentsForAgent, dbResultToMcpTool, CONVERSATION_HISTORY_MAX_OUTPUT_TOKENS_DEFAULT, CONVERSATION_HISTORY_DEFAULT_LIMIT, ModelFactory, getLedgerArtifacts, verifyTempToken, validateAndGetApiKey, verifyServiceToken, validateTargetAgent, ContextResolver, CredentialStuffer, MCPServerType, getUserScopedCredentialReference, getCredentialReference, McpClient, getFunctionToolsForSubAgent, getFunction, jsonSchemaToZod, getContextConfigById, getFullAgentDefinition, TemplateEngine, listTaskIdsByContextId, agentHasArtifactComponents, upsertLedgerArtifact, MCPTransportType, SPAN_KEYS, headers, generateServiceToken } from '@inkeep/agents-core';
 import { otel } from '@hono/otel';
-import { OpenAPIHono, createRoute, z } from '@hono/zod-openapi';
+import { OpenAPIHono, createRoute, z as z$1 } from '@hono/zod-openapi';
 import { trace, propagation, context, SpanStatusCode } from '@opentelemetry/api';
 import { Hono } from 'hono';
 import { cors } from 'hono/cors';
@@ -18,6 +18,8 @@ import { streamSSE, stream } from 'hono/streaming';
 import { createUIMessageStream, JsonToSseTransformStream, parsePartialJson, generateObject, tool, streamText, generateText, streamObject } from 'ai';
 import jmespath from 'jmespath';
 import Ajv from 'ajv';
+import { randomUUID } from 'crypto';
+import { z } from 'zod';
 import destr from 'destr';
 import traverse from 'traverse';
 import { McpServer } from '@alcyone-labs/modelcontextprotocol-sdk/server/mcp.js';
@@ -25,6 +27,10 @@ import { StreamableHTTPServerTransport } from '@alcyone-labs/modelcontextprotoco
 import { toReqRes, toFetchResponse } from 'fetch-to-node';
 
 // src/types/execution-context.ts
+function getUserIdFromContext(ctx) {
+  const metadata = ctx.metadata;
+  return metadata?.initiatedBy?.type === "user" ? metadata.initiatedBy.id : void 0;
+}
 function createExecutionContext(params) {
   return {
     apiKey: params.apiKey,
@@ -1611,7 +1617,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.`
       );
       logger5.error(
@@ -1622,9 +1628,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) {
       logger5.warn(
@@ -1774,7 +1784,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(
@@ -2362,7 +2372,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) {
@@ -2413,6 +2422,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`;
     }
@@ -2659,13 +2670,30 @@ var AgentSession = class {
   /**
    * Clean up status update resources when session ends
    */
-  cleanup() {
+  async cleanup() {
     this.isEnded = true;
     if (this.statusUpdateTimer) {
       clearInterval(this.statusUpdateTimer);
       this.statusUpdateTimer = void 0;
     }
     this.statusUpdateState = void 0;
+    if (this.pendingArtifacts.size > 0) {
+      const maxWaitTime = 1e4;
+      const startTime = Date.now();
+      while (this.pendingArtifacts.size > 0 && Date.now() - startTime < maxWaitTime) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+      if (this.pendingArtifacts.size > 0) {
+        logger7.warn(
+          {
+            sessionId: this.sessionId,
+            pendingCount: this.pendingArtifacts.size,
+            pendingIds: Array.from(this.pendingArtifacts)
+          },
+          "Cleanup proceeding with pending artifacts still processing"
+        );
+      }
+    }
     this.pendingArtifacts.clear();
     this.artifactProcessingErrors.clear();
     this.artifactCache.clear();
@@ -2908,12 +2936,12 @@ ${conversationHistory}
 Previous updates sent to user:
 ${previousSummaries.map((s, i) => `${i + 1}. ${s}`).join("\n")}
 ` : "";
-          const selectionSchema = z.object(
+          const selectionSchema = z$1.object(
             Object.fromEntries([
               [
                 "no_relevant_updates",
-                z.object({
-                  no_updates: z.boolean().default(true)
+                z$1.object({
+                  no_updates: z$1.boolean().default(true)
                 }).optional().describe(
                   "Use when nothing substantially new to report. Should only use on its own."
                 )
@@ -3047,8 +3075,8 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
     if (component.detailsSchema && "properties" in component.detailsSchema) {
       return this.buildZodSchemaFromJson(component.detailsSchema);
     }
-    return z.object({
-      label: z.string().describe(
+    return z$1.object({
+      label: z$1.string().describe(
         'A short 3-5 word phrase, that is a descriptive label for the update component. This Label must be EXTREMELY unique to represent the UNIQUE update we are providing. The ACTUAL finding or result, not the action. What specific information was discovered? (e.g., "Slack requires OAuth 2.0 setup", "Found 5 integration methods", "API rate limit is 100/minute"). Include the actual detail or insight, not just that you searched or processed. CRITICAL: Only use facts explicitly found in the activities - NEVER invent names, people, organizations, or details that are not present in the actual tool results.'
       )
     });
@@ -3058,56 +3086,56 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
    */
   buildZodSchemaFromJson(jsonSchema) {
     const properties = {};
-    properties.label = z.string().describe(
+    properties.label = z$1.string().describe(
       'A short 3-5 word phrase, that is a descriptive label for the update component. This Label must be EXTREMELY unique to represent the UNIQUE update we are providing. The SPECIFIC finding, result, or insight discovered (e.g., "Slack bot needs workspace admin role", "Found ingestion requires 3 steps", "Channel history limited to 10k messages"). State the ACTUAL information found, not that you searched. What did you LEARN or DISCOVER? What specific detail is now known? CRITICAL: Only use facts explicitly found in the activities - NEVER invent names, people, organizations, or details that are not present in the actual tool results.'
     );
     for (const [key, value] of Object.entries(jsonSchema.properties)) {
       let zodType;
       if (value.enum && Array.isArray(value.enum)) {
         if (value.enum.length === 1) {
-          zodType = z.literal(value.enum[0]);
+          zodType = z$1.literal(value.enum[0]);
         } else {
           const [first, ...rest] = value.enum;
-          zodType = z.enum([first, ...rest]);
+          zodType = z$1.enum([first, ...rest]);
         }
       } else if (value.type === "string") {
-        zodType = z.string();
+        zodType = z$1.string();
         if (value.minLength) zodType = zodType.min(value.minLength);
         if (value.maxLength) zodType = zodType.max(value.maxLength);
         if (value.format === "email") zodType = zodType.email();
         if (value.format === "url" || value.format === "uri")
           zodType = zodType.url();
       } else if (value.type === "number" || value.type === "integer") {
-        zodType = value.type === "integer" ? z.number().int() : z.number();
+        zodType = value.type === "integer" ? z$1.number().int() : z$1.number();
         if (value.minimum !== void 0) zodType = zodType.min(value.minimum);
         if (value.maximum !== void 0) zodType = zodType.max(value.maximum);
       } else if (value.type === "boolean") {
-        zodType = z.boolean();
+        zodType = z$1.boolean();
       } else if (value.type === "array") {
         if (value.items) {
           if (value.items.enum && Array.isArray(value.items.enum)) {
             const [first, ...rest] = value.items.enum;
-            zodType = z.array(z.enum([first, ...rest]));
+            zodType = z$1.array(z$1.enum([first, ...rest]));
           } else if (value.items.type === "string") {
-            zodType = z.array(z.string());
+            zodType = z$1.array(z$1.string());
           } else if (value.items.type === "number") {
-            zodType = z.array(z.number());
+            zodType = z$1.array(z$1.number());
           } else if (value.items.type === "boolean") {
-            zodType = z.array(z.boolean());
+            zodType = z$1.array(z$1.boolean());
           } else if (value.items.type === "object") {
-            zodType = z.array(z.record(z.string(), z.any()));
+            zodType = z$1.array(z$1.record(z$1.string(), z$1.any()));
           } else {
-            zodType = z.array(z.any());
+            zodType = z$1.array(z$1.any());
           }
         } else {
-          zodType = z.array(z.any());
+          zodType = z$1.array(z$1.any());
         }
         if (value.minItems) zodType = zodType.min(value.minItems);
         if (value.maxItems) zodType = zodType.max(value.maxItems);
       } else if (value.type === "object") {
-        zodType = z.record(z.string(), z.any());
+        zodType = z$1.record(z$1.string(), z$1.any());
       } else {
-        zodType = z.any();
+        zodType = z$1.any();
       }
       if (value.description) {
         zodType = zodType.describe(value.description);
@@ -3117,7 +3145,7 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
       }
       properties[key] = zodType;
     }
-    return z.object(properties);
+    return z$1.object(properties);
   }
   /**
    * Extract user-visible activities with rich formatting and complete information
@@ -3278,17 +3306,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 getLedgerArtifacts(dbClient_default)({
+                scopes: { tenantId: artifactData.tenantId, projectId: artifactData.projectId },
+                taskId: artifactData.taskId
+              });
+              existingNames = existingArtifacts.map((a) => a.name).filter(Boolean);
+            }
+          } catch (error) {
+            logger7.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.
 
-Tool Context: ${toolContext ? JSON.stringify(toolContext, null, 2) : "No tool context"}
-Context: ${conversationHistory?.slice(-200) || "Processing"}
-Type: ${artifactData.artifactType || "data"}
-Data: ${JSON.stringify(artifactData.data || artifactData.summaryData, null, 2)}
+CRITICAL: Your name must be different from these existing artifacts: ${existingNames.length > 0 ? existingNames.join(", ") : "None yet"}
 
-Make it specific and relevant.`;
+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)}
+
+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 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()) {
@@ -3342,15 +3412,16 @@ 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 = ModelFactory.createModel(modelToUse);
-            const schema = z.object({
-              name: z.string().describe("Concise, descriptive name for the artifact"),
-              description: z.string().describe("Brief description of the artifact's relevance to the user's question")
+            const schema = z$1.object({
+              name: z$1.string().describe("Concise, descriptive name for the artifact"),
+              description: z$1.string().describe("Brief description of the artifact's relevance to the user's question")
             });
             const { object } = await tracer.startActiveSpan(
               "agent_session.generate_artifact_metadata",
@@ -3439,13 +3510,32 @@ 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}`;
+            logger7.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");
+            }
             await this.artifactService.saveArtifact({
               artifactId: artifactData.artifactId,
               name: result.name,
               description: result.description,
               type: artifactData.artifactType || "source",
               data: artifactData.data || {},
+              summaryData: artifactData.summaryData,
               metadata: artifactData.metadata || {},
               toolCallId: artifactData.toolCallId
             });
@@ -3461,7 +3551,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"
             );
@@ -3482,6 +3578,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
                 });
@@ -3500,7 +3597,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"
                 );
@@ -3629,7 +3732,7 @@ var AgentSessionManager = class {
   /**
    * End a session and return the final event data
    */
-  endSession(sessionId) {
+  async endSession(sessionId) {
     const session = this.sessions.get(sessionId);
     if (!session) {
       logger7.warn({ sessionId }, "Attempted to end non-existent session");
@@ -3638,7 +3741,7 @@ var AgentSessionManager = class {
     const events = session.getEvents();
     const summary = session.getSummary();
     logger7.info({ sessionId, summary }, "AgentSession ended");
-    session.cleanup();
+    await session.cleanup();
     this.sessions.delete(sessionId);
     return events;
   }
@@ -4134,9 +4237,654 @@ ${chunk}`;
     }
   }
 };
+var logger9 = getLogger("distill-conversation-tool");
+var ConversationSummarySchema = z.object({
+  type: z.literal("conversation_summary_v1"),
+  session_id: z.string().nullable().optional(),
+  high_level: z.string().describe("1-3 sentences capturing what was discovered and learned"),
+  user_intent: z.string().describe("Current main goal or what the user wants to accomplish"),
+  decisions: z.array(z.string()).describe("Concrete decisions made about approach or implementation (\u22645 items)"),
+  open_questions: z.array(z.string()).describe("Unresolved questions about the subject matter (\u22645 items)"),
+  next_steps: z.object({
+    for_agent: z.array(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: z.array(z.string()).describe("Actions for user based on discovered content")
+  }),
+  related_artifacts: z.array(
+    z.object({
+      id: z.string().describe("Artifact ID"),
+      name: z.string().describe("Human-readable name describing the content"),
+      tool_name: z.string().describe("Tool that generated this artifact (e.g. search-inkeep-docs)"),
+      tool_call_id: z.string().describe("Specific tool call ID for precise referencing"),
+      content_type: z.string().describe("Type of content (e.g. search_results, api_response, documentation)"),
+      key_findings: z.array(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 = 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 parts = [];
+      if (typeof msg.content === "string") {
+        parts.push(msg.content);
+      } else if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === "text") {
+            parts.push(block.text);
+          } else if (block.type === "tool-call") {
+            parts.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}]` : "";
+            parts.push(
+              `[TOOL RESULT] ${block.toolName} [ID: ${block.toolCallId}]${artifactInfo}
+Result: ${JSON.stringify(block.result)}`
+            );
+          }
+        }
+      } else if (msg.content?.text) {
+        parts.push(msg.content.text);
+      }
+      return parts.length > 0 ? `${msg.role || "system"}: ${parts.join("\n")}` : "";
+    }).filter((line) => line.trim().length > 0).join("\n\n");
+    logger9.debug(
+      {
+        conversationId,
+        messageCount: messages.length,
+        formattedLength: formattedMessages.length,
+        sampleMessages: messages.slice(0, 2).map((m) => ({ role: m.role, contentType: typeof m.content, hasContent: !!m.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 generateObject({
+      model,
+      prompt,
+      schema: ConversationSummarySchema
+    });
+    summary.session_id = conversationId;
+    logger9.info(
+      {
+        conversationId,
+        messageCount: messages.length,
+        artifactsCount: summary.related_artifacts?.length || 0,
+        decisionsCount: summary.decisions.length
+      },
+      "Successfully distilled conversation"
+    );
+    return summary;
+  } catch (error) {
+    logger9.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 logger10 = 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;
+    logger10.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);
+    logger10.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);
+    logger10.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;
+    logger10.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);
+    logger10.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") {
+              logger10.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)) {
+              logger10.debug(
+                {
+                  toolCallId: block.toolCallId,
+                  toolName: block.toolName
+                },
+                "Skipping already processed tool call"
+              );
+              continue;
+            }
+            const artifactId = `compress_${block.toolName || "tool"}_${block.toolCallId || Date.now()}_${randomUUID().slice(0, 8)}`;
+            logger10.debug(
+              {
+                artifactId,
+                toolName: block.toolName,
+                toolCallId: block.toolCallId
+              },
+              "Saving compression artifact"
+            );
+            let toolInput = null;
+            if (Array.isArray(message.content)) {
+              const toolCall = message.content.find(
+                (b) => b.type === "tool-call" && b.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)) {
+              logger10.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) {
+              logger10.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;
+    logger10.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);
+    logger10.debug(
+      {
+        sessionId: this.sessionId,
+        messageCount: messages.length,
+        textMessageCount: textMessages.length,
+        artifactCount: Object.keys(toolCallToArtifactMap).length,
+        sampleMessages: messages.slice(0, 2).map((m) => ({
+          role: m.role,
+          contentType: typeof m.content,
+          contentPreview: typeof m.content === "string" ? m.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;
+    logger10.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 args = 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}(${args}).${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
-var logger9 = getLogger("PendingToolApprovalManager");
+var logger11 = getLogger("PendingToolApprovalManager");
 var APPROVAL_CLEANUP_INTERVAL_MS = 2 * 60 * 1e3;
 var APPROVAL_TIMEOUT_MS = 10 * 60 * 1e3;
 var PendingToolApprovalManager = class _PendingToolApprovalManager {
@@ -4175,7 +4923,7 @@ var PendingToolApprovalManager = class _PendingToolApprovalManager {
         timeoutId
       };
       this.pendingApprovals.set(toolCallId, approval);
-      logger9.info(
+      logger11.info(
         {
           toolCallId,
           toolName,
@@ -4192,10 +4940,10 @@ var PendingToolApprovalManager = class _PendingToolApprovalManager {
   approveToolCall(toolCallId) {
     const approval = this.pendingApprovals.get(toolCallId);
     if (!approval) {
-      logger9.warn({ toolCallId }, "Tool approval not found or already processed");
+      logger11.warn({ toolCallId }, "Tool approval not found or already processed");
       return false;
     }
-    logger9.info(
+    logger11.info(
       {
         toolCallId,
         toolName: approval.toolName,
@@ -4214,10 +4962,10 @@ var PendingToolApprovalManager = class _PendingToolApprovalManager {
   denyToolCall(toolCallId, reason) {
     const approval = this.pendingApprovals.get(toolCallId);
     if (!approval) {
-      logger9.warn({ toolCallId }, "Tool approval not found or already processed");
+      logger11.warn({ toolCallId }, "Tool approval not found or already processed");
       return false;
     }
-    logger9.info(
+    logger11.info(
       {
         toolCallId,
         toolName: approval.toolName,
@@ -4249,7 +4997,7 @@ var PendingToolApprovalManager = class _PendingToolApprovalManager {
       }
     }
     if (cleanedUp > 0) {
-      logger9.info({ cleanedUp }, "Cleaned up expired tool approvals");
+      logger11.info({ cleanedUp }, "Cleaned up expired tool approvals");
     }
   }
   /**
@@ -4272,7 +5020,7 @@ var PendingToolApprovalManager = class _PendingToolApprovalManager {
 var pendingToolApprovalManager = PendingToolApprovalManager.getInstance();
 
 // src/services/ResponseFormatter.ts
-var logger10 = getLogger("ResponseFormatter");
+var logger12 = getLogger("ResponseFormatter");
 var ResponseFormatter = class {
   artifactParser;
   subAgentId;
@@ -4331,7 +5079,7 @@ var ResponseFormatter = class {
         return { parts };
       } catch (error) {
         setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
-        logger10.error({ error, responseObject }, "Error formatting object response");
+        logger12.error({ error, responseObject }, "Error formatting object response");
         return {
           parts: [{ kind: "data", data: responseObject }]
         };
@@ -4387,7 +5135,7 @@ var ResponseFormatter = class {
         return { parts };
       } catch (error) {
         setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
-        logger10.error({ error, responseText }, "Error formatting response");
+        logger12.error({ error, responseText }, "Error formatting response");
         return { text: responseText };
       } finally {
         span.end();
@@ -4463,46 +5211,6 @@ function errorOp(message, subAgentId, severity = "error", code) {
 function generateToolId() {
   return `tool_${generateId(8)}`;
 }
-var logger11 = getLogger("DataComponentSchema");
-function jsonSchemaToZod(jsonSchema) {
-  if (!jsonSchema || typeof jsonSchema !== "object") {
-    logger11.warn({ jsonSchema }, "Invalid JSON schema provided, using string fallback");
-    return z.string();
-  }
-  switch (jsonSchema.type) {
-    case "object":
-      if (jsonSchema.properties) {
-        const shape = {};
-        for (const [key, prop] of Object.entries(jsonSchema.properties)) {
-          shape[key] = jsonSchemaToZod(prop);
-        }
-        return z.object(shape);
-      }
-      return z.record(z.string(), z.unknown());
-    case "array": {
-      const itemSchema = jsonSchema.items ? jsonSchemaToZod(jsonSchema.items) : z.unknown();
-      return z.array(itemSchema);
-    }
-    case "string":
-      return z.string();
-    case "number":
-    case "integer":
-      return z.number();
-    case "boolean":
-      return z.boolean();
-    case "null":
-      return z.null();
-    default:
-      logger11.warn(
-        {
-          unsupportedType: jsonSchema.type,
-          schema: jsonSchema
-        },
-        "Unsupported JSON schema type, using unknown validation"
-      );
-      return z.unknown();
-  }
-}
 var SchemaProcessor = class _SchemaProcessor {
   static logger = getLogger("SchemaProcessor");
   /**
@@ -4744,9 +5452,9 @@ var ArtifactReferenceSchema = class _ArtifactReferenceSchema {
    * Get the standard Zod schema for artifact reference components
    */
   static getSchema() {
-    return z.object({
-      id: z.string(),
-      name: z.literal("Artifact"),
+    return z$1.object({
+      id: z$1.string(),
+      name: z$1.literal("Artifact"),
       props: jsonSchemaToZod(_ArtifactReferenceSchema.ARTIFACT_PROPS_SCHEMA)
     });
   }
@@ -4797,9 +5505,9 @@ var ArtifactCreateSchema = class {
         },
         required: ["id", "tool_call_id", "type", "base_selector"]
       };
-      return z.object({
-        id: z.string(),
-        name: z.literal(`ArtifactCreate_${component.name}`),
+      return z$1.object({
+        id: z$1.string(),
+        name: z$1.literal(`ArtifactCreate_${component.name}`),
         props: jsonSchemaToZod(propsSchema)
       });
     });
@@ -4859,7 +5567,7 @@ function parseEmbeddedJson(data) {
 }
 
 // src/a2a/client.ts
-var logger12 = getLogger("a2aClient");
+var logger13 = getLogger("a2aClient");
 var DEFAULT_BACKOFF = {
   initialInterval: 500,
   maxInterval: 6e4,
@@ -5066,7 +5774,7 @@ var A2AClient = class {
       try {
         const res = await fn();
         if (attempt > 0) {
-          logger12.info(
+          logger13.info(
             {
               attempts: attempt + 1,
               elapsedTime: Date.now() - start
@@ -5081,7 +5789,7 @@ var A2AClient = class {
         }
         const elapsed = Date.now() - start;
         if (elapsed > maxElapsedTime) {
-          logger12.warn(
+          logger13.warn(
             {
               attempts: attempt + 1,
               elapsedTime: elapsed,
@@ -5102,7 +5810,7 @@ var A2AClient = class {
           retryInterval = initialInterval * attempt ** exponent + Math.random() * 1e3;
         }
         const delayMs = Math.min(retryInterval, maxInterval);
-        logger12.info(
+        logger13.info(
           {
             attempt: attempt + 1,
             delayMs,
@@ -5193,7 +5901,7 @@ var A2AClient = class {
       });
     }
     if (rpcResponse.id !== requestId2) {
-      logger12.warn(
+      logger13.warn(
         {
           method,
           expectedId: requestId2,
@@ -5390,7 +6098,7 @@ var A2AClient = class {
     try {
       while (true) {
         const { done, value } = await reader.read();
-        logger12.info({ done, value }, "parseA2ASseStream");
+        logger13.info({ done, value }, "parseA2ASseStream");
         if (done) {
           if (eventDataBuffer.trim()) {
             const result = this._processSseEventData(
@@ -5477,7 +6185,7 @@ var A2AClient = class {
 };
 
 // src/agents/relationTools.ts
-var logger13 = getLogger("relationships Tools");
+var logger14 = getLogger("relationships Tools");
 var A2A_RETRY_STATUS_CODES = ["429", "500", "502", "503", "504"];
 var generateTransferToolDescription = (config) => {
   let toolsSection = "";
@@ -5502,9 +6210,9 @@ Can Delegate To:
 ${delegateList}`;
   }
   if (config.tools && config.tools.length > 0) {
-    const toolDescriptions = config.tools.map((tool3) => {
-      const toolsList = tool3.availableTools?.map((t) => `  - ${t.name}: ${t.description || "No description available"}`).join("\n") || "";
-      return `MCP Server: ${tool3.name}
+    const toolDescriptions = config.tools.map((tool4) => {
+      const toolsList = tool4.availableTools?.map((t) => `  - ${t.name}: ${t.description || "No description available"}`).join("\n") || "";
+      return `MCP Server: ${tool4.name}
 ${toolsList}`;
     }).join("\n\n");
     toolsSection = `
@@ -5530,9 +6238,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((t) => `  - ${t.name}: ${t.description || "No description available"}`).join("\n") || "";
-        return `MCP Server: ${tool3.name}
+      const toolDescriptions = agentConfig.tools.map((tool4) => {
+        const toolsList = tool4.availableTools?.map((t) => `  - ${t.name}: ${t.description || "No description available"}`).join("\n") || "";
+        return `MCP Server: ${tool4.name}
 ${toolsList}`;
       }).join("\n\n");
       toolsSection = `
@@ -5579,7 +6287,7 @@ var createTransferToAgentTool = ({
   const toolDescription = generateTransferToolDescription(transferConfig);
   return tool({
     description: toolDescription,
-    inputSchema: z.object({}),
+    inputSchema: z$1.object({}),
     execute: async () => {
       const activeSpan = trace.getActiveSpan();
       if (activeSpan) {
@@ -5588,7 +6296,7 @@ var createTransferToAgentTool = ({
           [SPAN_KEYS.TRANSFER_TO_SUB_AGENT_ID]: transferConfig.id ?? "unknown"
         });
       }
-      logger13.info(
+      logger14.info(
         {
           transferTo: transferConfig.id ?? "unknown",
           fromSubAgent: callingAgentId
@@ -5609,7 +6317,7 @@ var createTransferToAgentTool = ({
         fromSubAgentId: callingAgentId
         // Include the calling agent ID for tracking
       };
-      logger13.info(
+      logger14.info(
         {
           transferResult,
           transferResultKeys: Object.keys(transferResult)
@@ -5634,7 +6342,7 @@ function createDelegateToAgentTool({
 }) {
   return tool({
     description: generateDelegateToolDescription(delegateConfig),
-    inputSchema: z.object({ message: z.string() }),
+    inputSchema: z$1.object({ message: z$1.string() }),
     execute: async (input, context) => {
       const delegationId = `del_${generateId()}`;
       const activeSpan = trace.getActiveSpan();
@@ -5756,7 +6464,7 @@ function createDelegateToAgentTool({
           ...isInternal ? { fromSubAgentId: callingAgentId } : { fromExternalAgentId: callingAgentId }
         }
       };
-      logger13.info({ messageToSend }, "messageToSend");
+      logger14.info({ messageToSend }, "messageToSend");
       await createMessage(dbClient_default)({
         id: generateId(),
         tenantId,
@@ -5818,7 +6526,7 @@ function createDelegateToAgentTool({
 }
 
 // src/agents/SystemPromptBuilder.ts
-var logger14 = getLogger("SystemPromptBuilder");
+var logger15 = getLogger("SystemPromptBuilder");
 var SystemPromptBuilder = class {
   constructor(version, versionConfig) {
     this.version = version;
@@ -5834,12 +6542,12 @@ var SystemPromptBuilder = class {
         this.templates.set(name, content);
       }
       this.loaded = true;
-      logger14.debug(
+      logger15.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}`);
+      logger15.error({ error }, `Failed to load templates for version ${this.version}`);
       throw new Error(`Template loading failed: ${error}`);
     }
   }
@@ -6079,7 +6787,14 @@ var Phase1Config = class _Phase1Config {
       throw new Error("System prompt template not loaded");
     }
     let systemPrompt = systemPromptTemplate;
-    systemPrompt = systemPrompt.replace("{{CORE_INSTRUCTIONS}}", config.corePrompt);
+    if (config.corePrompt && config.corePrompt.trim()) {
+      systemPrompt = systemPrompt.replace("{{CORE_INSTRUCTIONS}}", config.corePrompt);
+    } else {
+      systemPrompt = systemPrompt.replace(
+        /<core_instructions>\s*\{\{CORE_INSTRUCTIONS\}\}\s*<\/core_instructions>/g,
+        ""
+      );
+    }
     const agentContextSection = this.generateAgentContextSection(config.prompt);
     systemPrompt = systemPrompt.replace("{{AGENT_CONTEXT_SECTION}}", agentContextSection);
     const toolData = this.isToolDataArray(config.tools) ? config.tools : _Phase1Config.convertMcpToolsToToolData(config.tools);
@@ -6109,7 +6824,7 @@ var Phase1Config = class _Phase1Config {
     return systemPrompt;
   }
   generateAgentContextSection(prompt) {
-    if (!prompt) {
+    if (!prompt || prompt.trim() === "") {
       return "";
     }
     return `
@@ -6222,6 +6937,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:
@@ -6246,6 +6963,8 @@ THE details PROPERTY MUST CONTAIN JMESPATH SELECTORS THAT EXTRACT DATA FROM THE
 \u274C NEVER: [?text ~ contains(@, 'word')] (~ with @ operator)
 \u274C NEVER: contains(@, 'text') (@ operator usage)
 \u274C NEVER: [?field=="value"] (double quotes in filters)
+\u274C NEVER: [?field=='value'] (escaped quotes in filters)  
+\u274C NEVER: [?field=='"'"'value'"'"'] (nightmare quote mixing)
 \u274C NEVER: result.items[?type=='doc'][?status=='active'] (chained filters)
 
 \u2705 CORRECT JMESPATH SYNTAX:
@@ -6257,6 +6976,11 @@ THE details PROPERTY MUST CONTAIN JMESPATH SELECTORS THAT EXTRACT DATA FROM THE
 \u2705 [?contains(text, 'Founder')] (contains haystack, needle format)
 \u2705 source.content[?contains(text, 'Founder')].text (correct filter usage)
 
+\u{1F6A8} MANDATORY QUOTE PATTERN - FOLLOW EXACTLY:
+- ALWAYS: base="path[?field=='value']" (double quotes outside, single inside)
+- This is the ONLY allowed pattern - any other pattern WILL FAIL
+- NEVER escape quotes, NEVER mix quote types, NEVER use complex quoting
+
 \u{1F6A8} CRITICAL: EXAMINE TOOL RESULTS BEFORE CREATING SELECTORS! \u{1F6A8}
 
 STEP 1: INSPECT THE ACTUAL DATA FIRST
@@ -6295,7 +7019,7 @@ Only use artifact:ref when you need to cite the SAME artifact again for a differ
 Format: <artifact:ref id="artifact-id" tool="tool_call_id" />
 
 EXAMPLE TEXT RESPONSE:
-"I found the authentication documentation. <artifact:create id='auth-doc-1' tool='call_xyz789' type='APIDoc' base='result.documents[?type=="auth"]' details='{"title":"metadata.title","endpoint":"api.endpoint","description":"content.description","parameters":"spec.parameters","examples":"examples.sample_code"}' /> The documentation explains OAuth 2.0 implementation in detail.
+"I found the authentication documentation. <artifact:create id='auth-doc-1' tool='call_xyz789' type='APIDoc' base="result.documents[?type=='auth']" details='{"title":"metadata.title","endpoint":"api.endpoint","description":"content.description","parameters":"spec.parameters","examples":"examples.sample_code"}' /> The documentation explains OAuth 2.0 implementation in detail.
 
 The process involves three main steps: registration, token exchange, and API calls. As mentioned in the authentication documentation <artifact:ref id='auth-doc-1' tool='call_xyz789' />, you'll need to register your application first."
 
@@ -6433,27 +7157,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;
   }
@@ -6636,6 +7360,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)
@@ -6793,7 +7519,7 @@ ${componentDescriptions}`;
     dataComponentXml = dataComponentXml.replace("{{COMPONENT_NAME}}", dataComponent.name);
     dataComponentXml = dataComponentXml.replace(
       "{{COMPONENT_DESCRIPTION}}",
-      dataComponent.description
+      dataComponent.description || ""
     );
     dataComponentXml = dataComponentXml.replace(
       "{{COMPONENT_PROPS_SCHEMA}}",
@@ -6889,7 +7615,14 @@ ${artifact_retrieval_guidance_default}
       artifactComponents
     );
     let phase2Prompt = system_prompt_default2;
-    phase2Prompt = phase2Prompt.replace("{{CORE_INSTRUCTIONS}}", corePrompt);
+    if (corePrompt && corePrompt.trim()) {
+      phase2Prompt = phase2Prompt.replace("{{CORE_INSTRUCTIONS}}", corePrompt);
+    } else {
+      phase2Prompt = phase2Prompt.replace(
+        /<core_instructions>\s*\{\{CORE_INSTRUCTIONS\}\}\s*<\/core_instructions>/g,
+        ""
+      );
+    }
     phase2Prompt = phase2Prompt.replace("{{DATA_COMPONENTS_SECTION}}", dataComponentsSection);
     phase2Prompt = phase2Prompt.replace("{{ARTIFACTS_SECTION}}", artifactsSection);
     phase2Prompt = phase2Prompt.replace("{{ARTIFACT_GUIDANCE_SECTION}}", artifactGuidance);
@@ -6908,7 +7641,7 @@ function hasToolCallWithPrefix(prefix) {
     return false;
   };
 }
-var logger15 = getLogger("Agent");
+var logger16 = getLogger("Agent");
 function validateModel(modelString, modelType) {
   if (!modelString?.trim()) {
     throw new Error(
@@ -6917,8 +7650,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;
@@ -6934,6 +7667,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 || [];
@@ -7014,6 +7748,32 @@ var Agent = class {
     }
     return sanitizedTools;
   }
+  #createRelationToolName(prefix, targetId) {
+    return `${prefix}_to_${targetId.toLowerCase().replace(/\s+/g, "_")}`;
+  }
+  #getRelationshipIdForTool(toolName, toolType) {
+    if (toolType === "mcp") {
+      const matchingTool = this.config.tools?.find((tool4) => {
+        if (tool4.config?.type !== "mcp") {
+          return false;
+        }
+        if (tool4.availableTools?.some((available) => available.name === toolName)) {
+          return true;
+        }
+        if (tool4.config.mcp.activeTools?.includes(toolName)) {
+          return true;
+        }
+        return tool4.name === toolName;
+      });
+      return matchingTool?.relationshipId;
+    }
+    if (toolType === "delegation") {
+      const relation = this.config.delegateRelations.find(
+        (relation2) => this.#createRelationToolName("delegate", relation2.config.id) === toolName
+      );
+      return relation?.config.relationId;
+    }
+  }
   /**
    * Get the primary model settings for text generation and thinking
    * Requires model to be configured at project level
@@ -7057,9 +7817,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
    */
@@ -7082,10 +7892,11 @@ var Agent = class {
   /**
    * Wraps a tool with streaming lifecycle tracking (start, complete, error) and AgentSession recording
    */
-  wrapToolWithStreaming(toolName, toolDefinition, streamRequestId, toolType, relationshipId, options) {
+  wrapToolWithStreaming(toolName, toolDefinition, streamRequestId, toolType, options) {
     if (!toolDefinition || typeof toolDefinition !== "object" || !("execute" in toolDefinition)) {
       return toolDefinition;
     }
+    const relationshipId = this.#getRelationshipIdForTool(toolName, toolType);
     const originalExecute = toolDefinition.execute;
     return {
       ...toolDefinition,
@@ -7094,14 +7905,21 @@ var Agent = class {
         const toolCallId = context?.toolCallId || generateToolId();
         const activeSpan = 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;
@@ -7154,7 +7972,7 @@ var Agent = class {
               };
               await createMessage(dbClient_default)(messagePayload);
             } catch (error) {
-              logger15.warn(
+              logger16.warn(
                 { error, toolName, toolCallId, conversationId: toolResultConversationId },
                 "Failed to store tool result in conversation history"
               );
@@ -7192,10 +8010,9 @@ var Agent = class {
   }
   getRelationTools(runtimeContext, sessionId) {
     const { transferRelations = [], delegateRelations = [] } = this.config;
-    const createToolName = (prefix, subAgentId) => `${prefix}_to_${subAgentId.toLowerCase().replace(/\s+/g, "_")}`;
     return Object.fromEntries([
       ...transferRelations.map((agentConfig) => {
-        const toolName = createToolName("transfer", agentConfig.id);
+        const toolName = this.#createRelationToolName("transfer", agentConfig.id);
         return [
           toolName,
           this.wrapToolWithStreaming(
@@ -7212,7 +8029,7 @@ var Agent = class {
         ];
       }),
       ...delegateRelations.map((relation) => {
-        const toolName = createToolName("delegate", relation.config.id);
+        const toolName = this.#createRelationToolName("delegate", relation.config.id);
         return [
           toolName,
           this.wrapToolWithStreaming(
@@ -7243,14 +8060,13 @@ 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 [index, toolSet] of tools.entries()) {
-        const relationshipId = mcpTools[index]?.relationshipId;
+      for (const toolSet of tools) {
         for (const [toolName, toolDef] of Object.entries(toolSet.tools)) {
           const needsApproval = toolSet.toolPolicies?.[toolName]?.needsApproval || false;
           const enhancedTool = {
@@ -7262,23 +8078,25 @@ var Agent = class {
             enhancedTool,
             streamRequestId,
             "mcp",
-            relationshipId,
-            { needsApproval }
+            {
+              needsApproval,
+              mcpServerId: toolSet.mcpServerId,
+              mcpServerName: toolSet.mcpServerName
+            }
           );
         }
       }
       return wrappedTools2;
     }
     const wrappedTools = {};
-    for (const [index, toolResult] of tools.entries()) {
-      const relationshipId = mcpTools[index]?.relationshipId;
+    for (const toolResult of tools) {
       for (const [toolName, originalTool] of Object.entries(toolResult.tools)) {
         if (!isValidTool(originalTool)) {
-          logger15.error({ toolName }, "Invalid MCP tool structure - missing required properties");
+          logger16.error({ toolName }, "Invalid MCP tool structure - missing required properties");
           continue;
         }
         const needsApproval = toolResult.toolPolicies?.[toolName]?.needsApproval || false;
-        logger15.debug(
+        logger16.debug(
           {
             toolName,
             toolPolicies: toolResult.toolPolicies,
@@ -7292,7 +8110,7 @@ var Agent = class {
           inputSchema: originalTool.inputSchema,
           execute: async (args, { toolCallId }) => {
             if (needsApproval) {
-              logger15.info(
+              logger16.info(
                 { toolName, toolCallId, args },
                 "Tool requires approval - waiting for user response"
               );
@@ -7338,7 +8156,7 @@ var Agent = class {
                     }
                   },
                   (denialSpan) => {
-                    logger15.info(
+                    logger16.info(
                       { toolName, toolCallId, reason: approvalResult.reason },
                       "Tool execution denied by user"
                     );
@@ -7359,18 +8177,18 @@ var Agent = class {
                   }
                 },
                 (approvedSpan) => {
-                  logger15.info({ toolName, toolCallId }, "Tool approved, continuing with execution");
+                  logger16.info({ toolName, toolCallId }, "Tool approved, continuing with execution");
                   approvedSpan.setStatus({ code: SpanStatusCode.OK });
                   approvedSpan.end();
                 }
               );
             }
-            logger15.debug({ toolName, toolCallId }, "MCP Tool Called");
+            logger16.debug({ toolName, toolCallId }, "MCP Tool Called");
             try {
               const rawResult = await originalTool.execute(args, { toolCallId });
               if (rawResult && typeof rawResult === "object" && rawResult.isError) {
                 const errorMessage = rawResult.content?.[0]?.text || "MCP tool returned an error";
-                logger15.error(
+                logger16.error(
                   { toolName, toolCallId, errorMessage, rawResult },
                   "MCP tool returned error status"
                 );
@@ -7382,6 +8200,7 @@ var Agent = class {
                   timestamp: Date.now()
                 });
                 if (streamRequestId) {
+                  const relationshipId = this.#getRelationshipIdForTool(toolName, "mcp");
                   agentSessionManager.recordEvent(streamRequestId, "error", this.config.id, {
                     message: `MCP tool "${toolName}" failed: ${errorMessage}`,
                     code: "mcp_tool_error",
@@ -7420,7 +8239,7 @@ var Agent = class {
               });
               return { result: enhancedResult, toolCallId };
             } catch (error) {
-              logger15.error({ toolName, toolCallId, error }, "MCP tool execution failed");
+              logger16.error({ toolName, toolCallId, error }, "MCP tool execution failed");
               throw error;
             }
           }
@@ -7430,8 +8249,11 @@ var Agent = class {
           sessionWrappedTool,
           streamRequestId,
           "mcp",
-          relationshipId,
-          { needsApproval }
+          {
+            needsApproval,
+            mcpServerId: toolResult.mcpServerId,
+            mcpServerName: toolResult.mcpServerName
+          }
         );
       }
     }
@@ -7440,28 +8262,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") ? MCPServerType.nango : 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") ? MCPServerType.nango : 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 getToolsForAgent(dbClient_default)({
       scopes: {
         tenantId: this.config.tenantId,
@@ -7470,12 +8292,56 @@ var Agent = class {
         subAgentId: this.config.id
       }
     });
-    const toolRelation = toolsForAgent.data.find((t) => t.toolId === tool3.id);
+    const toolRelation = toolsForAgent.data.find((t) => t.toolId === tool4.id);
     const agentToolRelationHeaders = toolRelation?.headers || void 0;
     const selectedTools = toolRelation?.selectedTools || void 0;
     const toolPolicies = toolRelation?.toolPolicies || {};
     let serverConfig;
-    if (credentialReferenceId && this.credentialStuffer) {
+    const isUserScoped = tool4.credentialScope === "user";
+    const userId = this.config.userId;
+    if (isUserScoped && userId && this.credentialStuffer) {
+      const userCredentialReference = await getUserScopedCredentialReference(dbClient_default)({
+        scopes: {
+          tenantId: this.config.tenantId,
+          projectId: this.config.projectId
+        },
+        toolId: tool4.id,
+        userId
+      });
+      if (userCredentialReference) {
+        const storeReference = {
+          credentialStoreId: userCredentialReference.credentialStoreId,
+          retrievalParams: userCredentialReference.retrievalParams || {}
+        };
+        serverConfig = await this.credentialStuffer.buildMcpServerConfig(
+          {
+            tenantId: this.config.tenantId,
+            projectId: this.config.projectId,
+            contextConfigId: this.config.contextConfigId || void 0,
+            conversationId: this.conversationId || void 0
+          },
+          this.convertToMCPToolConfig(tool4, agentToolRelationHeaders),
+          storeReference,
+          selectedTools
+        );
+      } else {
+        logger16.warn(
+          { toolId: tool4.id, userId },
+          "User-scoped tool has no credential connected for this user"
+        );
+        serverConfig = await this.credentialStuffer.buildMcpServerConfig(
+          {
+            tenantId: this.config.tenantId,
+            projectId: this.config.projectId,
+            contextConfigId: this.config.contextConfigId || void 0,
+            conversationId: this.conversationId || void 0
+          },
+          this.convertToMCPToolConfig(tool4, agentToolRelationHeaders),
+          void 0,
+          selectedTools
+        );
+      }
+    } else if (credentialReferenceId && this.credentialStuffer) {
       const credentialReference = await getCredentialReference(dbClient_default)({
         scopes: {
           tenantId: this.config.tenantId,
@@ -7497,7 +8363,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
       );
@@ -7509,28 +8375,41 @@ 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 || MCPTransportType.streamableHttp,
-        url: tool3.config.mcp.server.url,
-        activeTools: tool3.config.mcp.activeTools,
+        type: tool4.config.mcp.transport?.type || MCPTransportType.streamableHttp,
+        url: tool4.config.mcp.server.url,
+        activeTools: tool4.config.mcp.activeTools,
         selectedTools,
         headers: agentToolRelationHeaders
       };
     }
-    logger15.info(
+    if (serverConfig.url?.toString().includes("composio.dev")) {
+      const urlObj = new URL(serverConfig.url.toString());
+      if (isUserScoped && userId) {
+        urlObj.searchParams.set("user_id", userId);
+      } else {
+        const SEPARATOR = "||";
+        urlObj.searchParams.set(
+          "user_id",
+          `${this.config.tenantId}${SEPARATOR}${this.config.projectId}`
+        );
+      }
+      serverConfig.url = urlObj.toString();
+    }
+    logger16.info(
       {
-        toolName: tool3.name,
+        toolName: tool4.name,
         credentialReferenceId,
         transportType: serverConfig.type,
-        headers: tool3.headers
+        headers: tool4.headers
       },
       "Built MCP server config with credentials"
     );
@@ -7542,7 +8421,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 {
@@ -7550,9 +8429,9 @@ var Agent = class {
         this.mcpClientCache.set(cacheKey, client);
       } catch (error) {
         this.mcpConnectionLocks.delete(cacheKey);
-        logger15.error(
+        logger16.error(
           {
-            toolName: tool3.name,
+            toolName: tool4.name,
             subAgentId: this.config.id,
             cacheKey,
             error: error instanceof Error ? error.message : String(error)
@@ -7570,13 +8449,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",
@@ -7588,14 +8467,14 @@ var Agent = class {
             }
           },
           (span) => {
-            setSpanWithError(span, new Error(`0 effective tools available for ${tool3.name}`));
+            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"
               }
             });
@@ -7604,20 +8483,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 McpClient({
-      name: tool3.name,
+      name: tool4.name,
       server: serverConfig
     });
     try {
       await client.connect();
       return client;
     } catch (error) {
-      logger15.error(
+      logger16.error(
         {
-          toolName: tool3.name,
+          toolName: tool4.name,
           subAgentId: this.config.id,
           error: error instanceof Error ? error.message : String(error)
         },
@@ -7652,12 +8531,12 @@ var Agent = class {
       if (functionToolsData.length === 0) {
         return functionTools;
       }
-      const { SandboxExecutorFactory } = await import('./SandboxExecutorFactory-A2LTPE2X.js');
+      const { SandboxExecutorFactory } = await import('./SandboxExecutorFactory-2N27SE3B.js');
       const sandboxExecutor = SandboxExecutorFactory.getInstance();
       for (const functionToolDef of functionToolsData) {
         const functionId = functionToolDef.functionId;
         if (!functionId) {
-          logger15.warn(
+          logger16.warn(
             { functionToolId: functionToolDef.id },
             "Function tool missing functionId reference"
           );
@@ -7671,7 +8550,7 @@ var Agent = class {
           }
         });
         if (!functionData) {
-          logger15.warn(
+          logger16.warn(
             { functionId, functionToolId: functionToolDef.id },
             "Function not found in functions table"
           );
@@ -7682,7 +8561,7 @@ var Agent = class {
           description: functionToolDef.description || functionToolDef.name,
           inputSchema: zodSchema,
           execute: async (args, { toolCallId }) => {
-            logger15.debug(
+            logger16.debug(
               { toolName: functionToolDef.name, toolCallId, args },
               "Function Tool Called"
             );
@@ -7709,7 +8588,7 @@ var Agent = class {
               });
               return { result, toolCallId };
             } catch (error) {
-              logger15.error(
+              logger16.error(
                 {
                   toolName: functionToolDef.name,
                   toolCallId,
@@ -7729,7 +8608,7 @@ var Agent = class {
         );
       }
     } catch (error) {
-      logger15.error({ error }, "Failed to load function tools from database");
+      logger16.error({ error }, "Failed to load function tools from database");
     }
     return functionTools;
   }
@@ -7739,7 +8618,7 @@ var Agent = class {
   async getResolvedContext(conversationId, headers2) {
     try {
       if (!this.config.contextConfigId) {
-        logger15.debug({ agentId: this.config.agentId }, "No context config found for agent");
+        logger16.debug({ agentId: this.config.agentId }, "No context config found for agent");
         return null;
       }
       const contextConfig = await getContextConfigById(dbClient_default)({
@@ -7751,7 +8630,7 @@ var Agent = class {
         id: this.config.contextConfigId
       });
       if (!contextConfig) {
-        logger15.warn({ contextConfigId: this.config.contextConfigId }, "Context config not found");
+        logger16.warn({ contextConfigId: this.config.contextConfigId }, "Context config not found");
         return null;
       }
       if (!this.contextResolver) {
@@ -7767,7 +8646,7 @@ var Agent = class {
         ...result.resolvedContext,
         $env: process.env
       };
-      logger15.debug(
+      logger16.debug(
         {
           conversationId,
           contextConfigId: contextConfig.id,
@@ -7781,7 +8660,7 @@ var Agent = class {
       );
       return contextWithBuiltins;
     } catch (error) {
-      logger15.error(
+      logger16.error(
         {
           conversationId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -7805,7 +8684,7 @@ var Agent = class {
       });
       return agentDefinition?.prompt || void 0;
     } catch (error) {
-      logger15.warn(
+      logger16.warn(
         {
           agentId: this.config.agentId,
           error: error instanceof Error ? error.message : "Unknown error"
@@ -7834,7 +8713,7 @@ var Agent = class {
         (subAgent) => "artifactComponents" in subAgent && subAgent.artifactComponents && subAgent.artifactComponents.length > 0
       );
     } catch (error) {
-      logger15.warn(
+      logger16.warn(
         {
           agentId: this.config.agentId,
           tenantId: this.config.tenantId,
@@ -7852,18 +8731,19 @@ 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;
-    if (resolvedContext) {
+    let processedPrompt = this.config.prompt || "";
+    if (resolvedContext && this.config.prompt) {
       try {
         processedPrompt = TemplateEngine.render(this.config.prompt, resolvedContext, {
           strict: false,
           preserveUnresolved: false
         });
       } catch (error) {
-        logger15.error(
+        logger16.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -7902,15 +8782,15 @@ var Agent = class {
       this.setConversationId(conversationId);
     }
     const resolvedContext = conversationId ? await this.getResolvedContext(conversationId) : null;
-    let processedPrompt = this.config.prompt;
-    if (resolvedContext) {
+    let processedPrompt = this.config.prompt || "";
+    if (resolvedContext && this.config.prompt) {
       try {
         processedPrompt = TemplateEngine.render(this.config.prompt, resolvedContext, {
           strict: false,
           preserveUnresolved: false
         });
       } catch (error) {
-        logger15.error(
+        logger16.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -7925,28 +8805,28 @@ var Agent = class {
     const functionTools = await this.getFunctionTools(streamRequestId || "");
     const relationTools = this.getRelationTools(runtimeContext);
     const allTools = { ...mcpTools, ...functionTools, ...relationTools };
-    logger15.info(
+    logger16.info(
       {
         mcpTools: Object.keys(mcpTools),
         functionTools: Object.keys(functionTools),
         relationTools: Object.keys(relationTools),
         allTools: Object.keys(allTools),
-        functionToolsDetails: Object.entries(functionTools).map(([name, tool3]) => ({
+        functionToolsDetails: Object.entries(functionTools).map(([name, tool4]) => ({
           name,
-          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(([name, tool3]) => ({
+    const toolDefinitions = Object.entries(allTools).map(([name, tool4]) => ({
       name,
-      description: tool3.description || "",
-      inputSchema: tool3.inputSchema || tool3.parameters || {},
+      description: tool4.description || "",
+      inputSchema: tool4.inputSchema || tool4.parameters || {},
       usageGuidelines: name.startsWith("transfer_to_") || name.startsWith("delegate_to_") ? `Use this tool to ${name.startsWith("transfer_to_") ? "transfer" : "delegate"} to another agent when appropriate.` : "Use this tool when appropriate for the task at hand."
     }));
-    const { getConversationScopedArtifacts } = await import('./conversations-33GSAG2C.js');
+    const { getConversationScopedArtifacts } = await import('./conversations-XPSTWUMK.js');
     const historyConfig = this.config.conversationHistoryConfig ?? createDefaultConversationHistoryConfig();
     const referenceArtifacts = await getConversationScopedArtifacts({
       tenantId: this.config.tenantId,
@@ -7964,7 +8844,7 @@ var Agent = class {
           preserveUnresolved: false
         });
       } catch (error) {
-        logger15.error(
+        logger16.error(
           {
             conversationId,
             error: error instanceof Error ? error.message : "Unknown error"
@@ -7974,7 +8854,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,
@@ -7992,12 +8873,12 @@ var Agent = class {
   getArtifactTools() {
     return tool({
       description: "Call this tool to get the complete artifact data with the given artifactId. This retrieves the full artifact content (not just the summary). Only use this when you need the complete artifact data and the summary shown in your context is insufficient.",
-      inputSchema: z.object({
-        artifactId: z.string().describe("The unique identifier of the artifact to get."),
-        toolCallId: z.string().describe("The tool call ID associated with this artifact.")
+      inputSchema: z$1.object({
+        artifactId: z$1.string().describe("The unique identifier of the artifact to get."),
+        toolCallId: z$1.string().describe("The tool call ID associated with this artifact.")
       }),
       execute: async ({ artifactId, toolCallId }) => {
-        logger15.info({ artifactId, toolCallId }, "get_artifact_full executed");
+        logger16.info({ artifactId, toolCallId }, "get_artifact_full executed");
         const streamRequestId = this.getStreamRequestId();
         const artifactService = agentSessionManager.getArtifactService(streamRequestId);
         if (!artifactService) {
@@ -8021,9 +8902,9 @@ var Agent = class {
   createThinkingCompleteTool() {
     return tool({
       description: "\u{1F6A8} CRITICAL: Call this tool IMMEDIATELY when you have gathered enough information to answer the user. This is MANDATORY - you CANNOT provide text responses in thinking mode, only tool calls. Call thinking_complete as soon as you have sufficient data to generate a structured response.",
-      inputSchema: z.object({
-        complete: z.boolean().describe("ALWAYS set to true - marks end of research phase"),
-        summary: z.string().describe(
+      inputSchema: z$1.object({
+        complete: z$1.boolean().describe("ALWAYS set to true - marks end of research phase"),
+        summary: z$1.string().describe(
           "Brief summary of what information was gathered and why it is sufficient to answer the user"
         )
       }),
@@ -8033,7 +8914,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;
@@ -8048,6 +8930,37 @@ var Agent = class {
         );
       }
     }
+    logger16.info(
+      { agentId: this.config.id, streamRequestId },
+      "Adding compress_context tool to defaultTools"
+    );
+    defaultTools.compress_context = tool({
+      description: "Manually compress the current conversation context to save space. Use when shifting topics, completing major tasks, or when context feels cluttered.",
+      inputSchema: z$1.object({
+        reason: z$1.string().describe(
+          'Why you are requesting compression (e.g., "shifting from research to coding", "completed analysis phase")'
+        )
+      }),
+      execute: async ({ reason }) => {
+        logger16.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."
+        };
+      }
+    });
+    logger16.info("getDefaultTools returning tools:", Object.keys(defaultTools).join(", "));
     return defaultTools;
   }
   getStreamRequestId() {
@@ -8293,7 +9206,7 @@ ${output}`;
       };
       return enhanced;
     } catch (error) {
-      logger15.warn({ error }, "Failed to enhance tool result with structure hints");
+      logger16.warn({ error }, "Failed to enhance tool result with structure hints");
       return result;
     }
   }
@@ -8308,7 +9221,7 @@ ${output}`;
         }
       });
     } catch (error) {
-      logger15.error(
+      logger16.error(
         { error, agentId: this.config.agentId },
         "Failed to check agent artifact components"
       );
@@ -8425,7 +9338,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) {
-            logger15.warn(
+            logger16.warn(
               {
                 requestedTimeout: modelSettings.maxDuration * 1e3,
                 appliedTimeout: timeoutMs,
@@ -8444,6 +9357,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,
@@ -8454,6 +9379,87 @@ ${output}`;
               ...streamConfig,
               messages,
               tools: sanitizedTools,
+              prepareStep: async ({ messages: stepMessages }) => {
+                if (!compressor) {
+                  return {};
+                }
+                const compressionNeeded = compressor.isCompressionNeeded(stepMessages);
+                if (compressionNeeded) {
+                  logger16.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.`
+                      });
+                      logger16.info(
+                        {
+                          originalTotal: stepMessages.length,
+                          compressed: finalMessages.length,
+                          originalKept: originalMessages.length,
+                          generatedCompressed: generatedMessages.length
+                        },
+                        "Generated content compression completed"
+                      );
+                      logger16.info({ summaryMessage }, "Summary message");
+                      return { messages: finalMessages };
+                    }
+                    return {};
+                  } catch (error) {
+                    logger16.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);
+                      logger16.info(
+                        {
+                          originalCount: stepMessages.length,
+                          compressedCount: fallbackMessages.length,
+                          compressionType: "simple_fallback"
+                        },
+                        "Simple compression fallback completed"
+                      );
+                      return { messages: fallbackMessages };
+                    } catch (fallbackError) {
+                      logger16.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) {
@@ -8467,7 +9473,7 @@ ${output}`;
                       }
                     );
                   } catch (error) {
-                    logger15.debug({ error }, "Failed to track agent reasoning");
+                    logger16.debug({ error }, "Failed to track agent reasoning");
                   }
                 }
                 if (last && last["content"] && last["content"].length > 0) {
@@ -8589,6 +9595,87 @@ ${output}`;
               ...genConfig,
               messages,
               tools: sanitizedTools,
+              prepareStep: async ({ messages: stepMessages }) => {
+                if (!compressor) {
+                  return {};
+                }
+                const compressionNeeded = compressor.isCompressionNeeded(stepMessages);
+                if (compressionNeeded) {
+                  logger16.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.`
+                      });
+                      logger16.info(
+                        {
+                          originalTotal: stepMessages.length,
+                          compressed: finalMessages.length,
+                          originalKept: originalMessages.length,
+                          generatedCompressed: generatedMessages.length
+                        },
+                        "Generated content compression completed"
+                      );
+                      logger16.info({ summaryMessage }, "Summary message");
+                      return { messages: finalMessages };
+                    }
+                    return {};
+                  } catch (error) {
+                    logger16.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);
+                      logger16.info(
+                        {
+                          originalCount: stepMessages.length,
+                          compressedCount: fallbackMessages.length,
+                          compressionType: "simple_fallback"
+                        },
+                        "Simple compression fallback completed"
+                      );
+                      return { messages: fallbackMessages };
+                    } catch (fallbackError) {
+                      logger16.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) {
@@ -8602,7 +9689,7 @@ ${output}`;
                       }
                     );
                   } catch (error) {
-                    logger15.debug({ error }, "Failed to track agent reasoning");
+                    logger16.debug({ error }, "Failed to track agent reasoning");
                   }
                 }
                 if (steps.length >= 2) {
@@ -8640,7 +9727,22 @@ ${output}`;
             const thinkingCompleteCall = response.steps?.flatMap((s) => s.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) => {
@@ -8714,9 +9816,9 @@ ${output}${structureHintsFormatted}`;
                 this.config.dataComponents.forEach((dc) => {
                   const propsSchema = jsonSchemaToZod(dc.props);
                   componentSchemas.push(
-                    z.object({
-                      id: z.string(),
-                      name: z.literal(dc.name),
+                    z$1.object({
+                      id: z$1.string(),
+                      name: z$1.literal(dc.name),
                       props: propsSchema
                     })
                   );
@@ -8733,7 +9835,7 @@ ${output}${structureHintsFormatted}`;
               if (componentSchemas.length === 1) {
                 dataComponentsSchema = componentSchemas[0];
               } else {
-                dataComponentsSchema = z.union(
+                dataComponentsSchema = z$1.union(
                   componentSchemas
                 );
               }
@@ -8749,7 +9851,7 @@ ${output}${structureHintsFormatted}`;
                 LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS
               );
               if (structuredModelSettings.maxDuration && structuredModelSettings.maxDuration * 1e3 > LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS) {
-                logger15.warn(
+                logger16.warn(
                   {
                     requestedTimeout: structuredModelSettings.maxDuration * 1e3,
                     appliedTimeout: phase2TimeoutMs,
@@ -8772,11 +9874,17 @@ ${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 = streamObject({
                   ...structuredModelSettings,
                   messages: phase2Messages,
-                  schema: z.object({
-                    dataComponents: z.array(dataComponentsSchema)
+                  schema: z$1.object({
+                    dataComponents: z$1.array(dataComponentsSchema)
                   }),
                   experimental_telemetry: {
                     isEnabled: true,
@@ -8842,12 +9950,18 @@ ${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 generateObject(
                   withJsonPostProcessing({
                     ...structuredModelSettings,
                     messages: phase2Messages,
-                    schema: z.object({
-                      dataComponents: z.array(dataComponentsSchema)
+                    schema: z$1.object({
+                      dataComponents: z$1.array(dataComponentsSchema)
                     }),
                     experimental_telemetry: {
                       isEnabled: true,
@@ -8912,8 +10026,10 @@ ${output}${structureHintsFormatted}`;
               generationType
             });
           }
+          this.currentCompressor = null;
           return formattedResponse;
         } catch (error) {
+          this.currentCompressor = null;
           const errorToThrow = error instanceof Error ? error : new Error(String(error));
           setSpanWithError(span, errorToThrow);
           span.end();
@@ -8925,7 +10041,7 @@ ${output}${structureHintsFormatted}`;
 };
 
 // src/agents/generateTaskHandler.ts
-var logger16 = getLogger("generateTaskHandler");
+var logger17 = getLogger("generateTaskHandler");
 var createTaskHandler = (config, credentialStoreRegistry) => {
   return async (task) => {
     try {
@@ -9043,7 +10159,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
               return { ...relation, description: enhancedDescription };
             }
           } catch (error) {
-            logger16.warn({ subAgentId: relation.id, error }, "Failed to enhance agent description");
+            logger17.warn({ subAgentId: relation.id, error }, "Failed to enhance agent description");
           }
           return relation;
         })
@@ -9101,7 +10217,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
               };
             }
           } catch (error) {
-            logger16.warn(
+            logger17.warn(
               { targetAgentId: relation.targetAgentId, error },
               "Failed to enhance team agent description"
             );
@@ -9109,7 +10225,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
           return relation;
         })
       );
-      const prompt = "prompt" in config.agentSchema ? config.agentSchema.prompt : "";
+      const prompt = "prompt" in config.agentSchema ? config.agentSchema.prompt || void 0 : "";
       const models = "models" in config.agentSchema ? config.agentSchema.models : void 0;
       const stopWhen = "stopWhen" in config.agentSchema ? config.agentSchema.stopWhen : void 0;
       const toolsForAgentResult = await Promise.all(
@@ -9118,11 +10234,12 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
             item.tool,
             dbClient_default,
             credentialStoreRegistry,
-            item.id
+            item.id,
+            config.userId
           );
           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;
         })
@@ -9135,6 +10252,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
           agentId: config.agentId,
           baseUrl: config.baseUrl,
           apiKey: config.apiKey,
+          userId: config.userId,
           name: config.name,
           description: config.description || "",
           prompt,
@@ -9148,7 +10266,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
             baseUrl: config.baseUrl,
             apiKey: config.apiKey,
             name: relation.name,
-            description: relation.description,
+            description: relation.description || void 0,
             prompt: "",
             delegateRelations: [],
             subAgentRelations: [],
@@ -9188,7 +10306,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
                 targetTransferRelations = transferRel;
                 targetDelegateRelations = delegateRel;
               } catch (err) {
-                logger16.info(
+                logger17.info(
                   {
                     agentId: relation.id,
                     error: err?.message || "Unknown error"
@@ -9202,12 +10320,13 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
                     item.tool,
                     dbClient_default,
                     credentialStoreRegistry,
-                    item.id
+                    item.id,
+                    config.userId
                   );
                   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;
@@ -9251,7 +10370,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
                 projectId: config.projectId,
                 agentId: config.agentId,
                 name: relation.name,
-                description: relation.description,
+                description: relation.description || void 0,
                 prompt: "",
                 delegateRelations: targetDelegateRelationsConfig,
                 subAgentRelations: [],
@@ -9266,13 +10385,14 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
               type: "internal",
               config: {
                 id: relation.id,
+                relationId: relation.relationId,
                 tenantId: config.tenantId,
                 projectId: config.projectId,
                 agentId: config.agentId,
                 baseUrl: config.baseUrl,
                 apiKey: config.apiKey,
                 name: relation.name,
-                description: relation.description,
+                description: relation.description || void 0,
                 prompt: "",
                 delegateRelations: [],
                 // Simplified - no nested relations
@@ -9327,7 +10447,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
         const taskIdMatch = task.id.match(/^task_([^-]+-[^-]+-\d+)-/);
         if (taskIdMatch) {
           contextId = taskIdMatch[1];
-          logger16.info(
+          logger17.info(
             {
               taskId: task.id,
               extractedContextId: contextId,
@@ -9345,7 +10465,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
       agent.setDelegationStatus(isDelegation);
       agent.setDelegationId(delegationId);
       if (isDelegation) {
-        logger16.info(
+        logger17.info(
           { subAgentId: config.subAgentId, taskId: task.id, delegationId },
           "Delegated agent - streaming disabled"
         );
@@ -9382,7 +10502,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
             const toolResult = allToolResults.find(
               (result) => result.toolCallId === toolCall.toolCallId
             );
-            logger16.info(
+            logger17.info(
               {
                 toolCallName: toolCall.toolName,
                 toolCallId: toolCall.toolCallId,
@@ -9399,7 +10519,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;
-              logger16.info(
+              logger17.info(
                 {
                   validationPassed: true,
                   transferResult,
@@ -9416,7 +10536,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
                 reason: transferReason,
                 original_message: userMessage
               };
-              logger16.info(
+              logger17.info(
                 {
                   artifactData,
                   artifactDataKeys: Object.keys(artifactData)
@@ -9441,7 +10561,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
                 ]
               };
             }
-            logger16.warn(
+            logger17.warn(
               {
                 hasToolResult: !!toolResult,
                 hasOutput: !!toolResult?.output,
@@ -9470,7 +10590,9 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
     } catch (error) {
       console.error("Task handler error:", error);
       const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
-      const isConnectionRefused = errorMessage.includes("Connection refused. Please check if the MCP server is running.");
+      const isConnectionRefused = errorMessage.includes(
+        "Connection refused. Please check if the MCP server is running."
+      );
       return {
         status: {
           state: TaskState.Failed,
@@ -9522,15 +10644,16 @@ var createTaskHandlerConfig = async (params) => {
     baseUrl: params.baseUrl,
     apiKey: params.apiKey,
     name: subAgent.name,
-    description: subAgent.description,
+    description: subAgent.description || void 0,
     conversationHistoryConfig: effectiveConversationHistoryConfig,
     contextConfigId: agent?.contextConfigId || void 0,
-    sandboxConfig: params.sandboxConfig
+    sandboxConfig: params.sandboxConfig,
+    userId: params.userId
   };
 };
 
 // src/data/agents.ts
-var logger17 = getLogger("agents");
+var logger18 = getLogger("agents");
 function createAgentCard({
   dbAgent,
   baseUrl
@@ -9600,7 +10723,8 @@ async function hydrateAgent({
   baseUrl,
   apiKey,
   credentialStoreRegistry,
-  sandboxConfig
+  sandboxConfig,
+  userId
 }) {
   try {
     const taskHandlerConfig = await createTaskHandlerConfig({
@@ -9610,7 +10734,8 @@ async function hydrateAgent({
       subAgentId: dbAgent.id,
       baseUrl,
       apiKey,
-      sandboxConfig
+      sandboxConfig,
+      userId
     });
     const taskHandler = createTaskHandler(taskHandlerConfig, credentialStoreRegistry);
     const agentCard = createAgentCard({
@@ -9633,12 +10758,13 @@ async function hydrateAgent({
 async function getRegisteredAgent(params) {
   const { executionContext, credentialStoreRegistry, sandboxConfig } = params;
   const { tenantId, projectId, agentId, subAgentId, baseUrl, apiKey } = executionContext;
+  const userId = getUserIdFromContext(executionContext);
   let dbAgent;
   if (!subAgentId) {
     const agent = await getAgentWithDefaultSubAgent(dbClient_default)({
       scopes: { tenantId, projectId, agentId }
     });
-    logger17.info({ agent }, "agent with default sub agent");
+    logger18.info({ agent }, "agent with default sub agent");
     if (!agent || !agent.defaultSubAgent) {
       return null;
     }
@@ -9663,13 +10789,14 @@ async function getRegisteredAgent(params) {
     baseUrl: agentFrameworkBaseUrl,
     credentialStoreRegistry,
     apiKey,
-    sandboxConfig
+    sandboxConfig,
+    userId
   });
 }
 
 // src/routes/agents.ts
 var app = new OpenAPIHono();
-var logger18 = getLogger("agents");
+var logger19 = getLogger("agents");
 app.openapi(
   createRoute({
     method: "get",
@@ -9684,14 +10811,14 @@ app.openapi(
         description: "Agent Card for A2A discovery",
         content: {
           "application/json": {
-            schema: z.object({
-              name: z.string(),
-              description: z.string().optional(),
-              url: z.string(),
-              version: z.string(),
-              defaultInputModes: z.array(z.string()),
-              defaultOutputModes: z.array(z.string()),
-              skills: z.array(z.any())
+            schema: z$1.object({
+              name: z$1.string(),
+              description: z$1.string().optional(),
+              url: z$1.string(),
+              version: z$1.string(),
+              defaultInputModes: z$1.array(z$1.string()),
+              defaultOutputModes: z$1.array(z$1.string()),
+              skills: z$1.array(z$1.any())
             })
           }
         }
@@ -9707,7 +10834,7 @@ app.openapi(
       tracestate: c.req.header("tracestate"),
       baggage: c.req.header("baggage")
     };
-    logger18.info(
+    logger19.info(
       {
         otelHeaders,
         path: c.req.path,
@@ -9717,8 +10844,8 @@ app.openapi(
     );
     const executionContext = getRequestExecutionContext(c);
     const { tenantId, projectId, agentId, subAgentId } = executionContext;
-    logger18.info({ executionContext }, "executionContext");
-    logger18.info(
+    logger19.info({ executionContext }, "executionContext");
+    logger19.info(
       {
         message: "getRegisteredAgent (agent-level)",
         tenantId,
@@ -9735,7 +10862,7 @@ app.openapi(
       credentialStoreRegistry: credentialStores,
       sandboxConfig
     });
-    logger18.info({ agent }, "agent registered: well-known agent.json");
+    logger19.info({ agent }, "agent registered: well-known agent.json");
     if (!agent) {
       throw createApiError({
         code: "not_found",
@@ -9751,7 +10878,7 @@ app.post("/a2a", async (c) => {
     tracestate: c.req.header("tracestate"),
     baggage: c.req.header("baggage")
   };
-  logger18.info(
+  logger19.info(
     {
       otelHeaders,
       path: c.req.path,
@@ -9762,7 +10889,7 @@ app.post("/a2a", async (c) => {
   const executionContext = getRequestExecutionContext(c);
   const { tenantId, projectId, agentId, subAgentId } = executionContext;
   if (subAgentId) {
-    logger18.info(
+    logger19.info(
       {
         message: "a2a (agent-level)",
         tenantId,
@@ -9791,7 +10918,7 @@ app.post("/a2a", async (c) => {
     }
     return a2aHandler(c, agent2);
   }
-  logger18.info(
+  logger19.info(
     {
       message: "a2a (agent-level)",
       tenantId,
@@ -9869,14 +10996,14 @@ function extractTransferData(task) {
 }
 
 // src/a2a/transfer.ts
-var logger19 = getLogger("Transfer");
+var logger20 = getLogger("Transfer");
 async function executeTransfer({
   tenantId,
   threadId,
   projectId,
   targetSubAgentId
 }) {
-  logger19.info(
+  logger20.info(
     {
       targetAgent: targetSubAgentId,
       threadId,
@@ -9891,12 +11018,12 @@ async function executeTransfer({
       threadId,
       subAgentId: targetSubAgentId
     });
-    logger19.info(
+    logger20.info(
       { targetAgent: targetSubAgentId, threadId },
       "Successfully updated active_sub_agent_id in database"
     );
   } catch (error) {
-    logger19.error(
+    logger20.error(
       { error, targetAgent: targetSubAgentId, threadId },
       "Failed to update active_sub_agent_id"
     );
@@ -10460,7 +11587,7 @@ function createBufferingStreamHelper() {
 var createMCPStreamHelper = createBufferingStreamHelper;
 
 // src/handlers/executionHandler.ts
-var logger20 = getLogger("ExecutionHandler");
+var logger21 = getLogger("ExecutionHandler");
 var ExecutionHandler = class {
   MAX_ERRORS = AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS;
   /**
@@ -10493,7 +11620,7 @@ var ExecutionHandler = class {
     if (emitOperations) {
       agentSessionManager.enableEmitOperations(requestId2);
     }
-    logger20.info(
+    logger21.info(
       { sessionId: requestId2, agentId, conversationId, emitOperations },
       "Created AgentSession for message execution"
     );
@@ -10526,7 +11653,7 @@ var ExecutionHandler = class {
             );
           }
         } catch (modelError) {
-          logger20.warn(
+          logger21.warn(
             {
               error: modelError instanceof Error ? modelError.message : "Unknown error",
               agentId
@@ -10541,7 +11668,7 @@ var ExecutionHandler = class {
         }
       }
     } catch (error) {
-      logger20.error(
+      logger21.error(
         {
           error: error instanceof Error ? error.message : "Unknown error",
           stack: error instanceof Error ? error.stack : void 0
@@ -10557,7 +11684,7 @@ var ExecutionHandler = class {
     try {
       await sseHelper.writeOperation(agentInitializingOp(requestId2, agentId));
       const taskId = `task_${conversationId}-${requestId2}`;
-      logger20.info(
+      logger21.info(
         { taskId, currentAgentId, conversationId, requestId: requestId2 },
         "Attempting to create or reuse existing task"
       );
@@ -10581,7 +11708,7 @@ var ExecutionHandler = class {
             sub_agent_id: currentAgentId
           }
         });
-        logger20.info(
+        logger21.info(
           {
             taskId,
             createdTaskMetadata: Array.isArray(task) ? task[0]?.metadata : task?.metadata
@@ -10590,27 +11717,27 @@ var ExecutionHandler = class {
         );
       } catch (error) {
         if (error?.cause?.code === "23505") {
-          logger20.info(
+          logger21.info(
             { taskId, error: error.message },
             "Task already exists, fetching existing task"
           );
           const existingTask = await getTask(dbClient_default)({ id: taskId });
           if (existingTask) {
             task = existingTask;
-            logger20.info(
+            logger21.info(
               { taskId, existingTask },
               "Successfully reused existing task from race condition"
             );
           } else {
-            logger20.error({ taskId, error }, "Task constraint failed but task not found");
+            logger21.error({ taskId, error }, "Task constraint failed but task not found");
             throw error;
           }
         } else {
-          logger20.error({ taskId, error }, "Failed to create task due to non-constraint error");
+          logger21.error({ taskId, error }, "Failed to create task due to non-constraint error");
           throw error;
         }
       }
-      logger20.debug(
+      logger21.debug(
         {
           timestamp: /* @__PURE__ */ new Date(),
           executionType: "create_initial_task",
@@ -10629,7 +11756,7 @@ var ExecutionHandler = class {
       const maxTransfers = agentConfig?.stopWhen?.transferCountIs ?? AGENT_EXECUTION_TRANSFER_COUNT_DEFAULT;
       while (iterations < maxTransfers) {
         iterations++;
-        logger20.info(
+        logger21.info(
           { iterations, currentAgentId, agentId, conversationId, fromSubAgentId },
           `Execution loop iteration ${iterations} with agent ${currentAgentId}, transfer from: ${fromSubAgentId || "none"}`
         );
@@ -10637,10 +11764,10 @@ var ExecutionHandler = class {
           scopes: { tenantId, projectId },
           conversationId
         });
-        logger20.info({ activeAgent }, "activeAgent");
+        logger21.info({ activeAgent }, "activeAgent");
         if (activeAgent && activeAgent.activeSubAgentId !== currentAgentId) {
           currentAgentId = activeAgent.activeSubAgentId;
-          logger20.info({ currentAgentId }, `Updated current agent to: ${currentAgentId}`);
+          logger21.info({ currentAgentId }, `Updated current agent to: ${currentAgentId}`);
         }
         const agentBaseUrl = `${baseUrl}/agents`;
         const a2aClient = new A2AClient(agentBaseUrl, {
@@ -10681,13 +11808,13 @@ var ExecutionHandler = class {
         });
         if (!messageResponse?.result) {
           errorCount++;
-          logger20.error(
+          logger21.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`;
-            logger20.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
+            logger21.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
             await sseHelper.writeOperation(errorOp(errorMessage2, currentAgentId || "system"));
             if (task) {
               await updateTask(dbClient_default)({
@@ -10702,7 +11829,7 @@ var ExecutionHandler = class {
                 }
               });
             }
-            agentSessionManager.endSession(requestId2);
+            await agentSessionManager.endSession(requestId2);
             unregisterStreamHelper(requestId2);
             return { success: false, error: errorMessage2, iterations };
           }
@@ -10711,7 +11838,7 @@ var ExecutionHandler = class {
         if (isTransferTask(messageResponse.result)) {
           const transferData = extractTransferData(messageResponse.result);
           if (!transferData) {
-            logger20.error(
+            logger21.error(
               { result: messageResponse.result },
               "Transfer detected but no transfer data found"
             );
@@ -10720,7 +11847,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";
-          logger20.info({ targetSubAgentId, transferReason, transferFromAgent }, "Transfer response");
+          logger21.info({ targetSubAgentId, transferReason, transferFromAgent }, "Transfer response");
           await createMessage(dbClient_default)({
             id: generateId(),
             tenantId,
@@ -10751,7 +11878,7 @@ var ExecutionHandler = class {
           if (success) {
             fromSubAgentId = currentAgentId;
             currentAgentId = newAgentId;
-            logger20.info(
+            logger21.info(
               {
                 transferFrom: fromSubAgentId,
                 transferTo: currentAgentId,
@@ -10765,7 +11892,7 @@ var ExecutionHandler = class {
         let responseParts = [];
         if (messageResponse.result.streamedContent?.parts) {
           responseParts = messageResponse.result.streamedContent.parts;
-          logger20.info(
+          logger21.info(
             { partsCount: responseParts.length },
             "Using streamed content for conversation history"
           );
@@ -10773,7 +11900,7 @@ var ExecutionHandler = class {
           responseParts = messageResponse.result.artifacts?.flatMap(
             (artifact) => artifact.parts || []
           ) || [];
-          logger20.info(
+          logger21.info(
             { partsCount: responseParts.length },
             "Using artifacts for conversation history (fallback)"
           );
@@ -10782,7 +11909,7 @@ var ExecutionHandler = class {
           const agentSessionData = agentSessionManager.getSession(requestId2);
           if (agentSessionData) {
             const sessionSummary = agentSessionData.getSummary();
-            logger20.info(sessionSummary, "AgentSession data after completion");
+            logger21.info(sessionSummary, "AgentSession data after completion");
           }
           let textContent = "";
           for (const part of responseParts) {
@@ -10836,22 +11963,22 @@ var ExecutionHandler = class {
                 }
               });
               const updateTaskEnd = Date.now();
-              logger20.info(
+              logger21.info(
                 { duration: updateTaskEnd - updateTaskStart },
                 "Completed updateTask operation"
               );
               await sseHelper.writeOperation(completionOp(currentAgentId, iterations));
               await sseHelper.complete();
-              logger20.info({}, "Ending AgentSession and cleaning up");
-              agentSessionManager.endSession(requestId2);
-              logger20.info({}, "Cleaning up streamHelper");
+              logger21.info({}, "Ending AgentSession and cleaning up");
+              await agentSessionManager.endSession(requestId2);
+              logger21.info({}, "Cleaning up streamHelper");
               unregisterStreamHelper(requestId2);
               let response;
               if (sseHelper instanceof BufferingStreamHelper) {
                 const captured = sseHelper.getCapturedResponse();
                 response = captured.text || "No response content";
               }
-              logger20.info({}, "ExecutionHandler returning success");
+              logger21.info({}, "ExecutionHandler returning success");
               return { success: true, iterations, response };
             } catch (error) {
               setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
@@ -10862,13 +11989,13 @@ var ExecutionHandler = class {
           });
         }
         errorCount++;
-        logger20.warn(
+        logger21.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`;
-          logger20.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
+          logger21.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
           await sseHelper.writeOperation(errorOp(errorMessage2, currentAgentId || "system"));
           if (task) {
             await updateTask(dbClient_default)({
@@ -10883,13 +12010,13 @@ var ExecutionHandler = class {
               }
             });
           }
-          agentSessionManager.endSession(requestId2);
+          await agentSessionManager.endSession(requestId2);
           unregisterStreamHelper(requestId2);
           return { success: false, error: errorMessage2, iterations };
         }
       }
       const errorMessage = `Maximum transfer limit (${maxTransfers}) reached without completion`;
-      logger20.error({ maxTransfers, iterations }, errorMessage);
+      logger21.error({ maxTransfers, iterations }, errorMessage);
       await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || "system"));
       if (task) {
         await updateTask(dbClient_default)({
@@ -10904,11 +12031,11 @@ var ExecutionHandler = class {
           }
         });
       }
-      agentSessionManager.endSession(requestId2);
+      await agentSessionManager.endSession(requestId2);
       unregisterStreamHelper(requestId2);
       return { success: false, error: errorMessage, iterations };
     } catch (error) {
-      logger20.error({ error }, "Error in execution handler");
+      logger21.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")
@@ -10926,7 +12053,7 @@ var ExecutionHandler = class {
           }
         });
       }
-      agentSessionManager.endSession(requestId2);
+      await agentSessionManager.endSession(requestId2);
       unregisterStreamHelper(requestId2);
       return { success: false, error: errorMessage, iterations };
     }
@@ -10935,7 +12062,7 @@ var ExecutionHandler = class {
 
 // src/routes/chat.ts
 var app2 = new OpenAPIHono();
-var logger21 = getLogger("completionsHandler");
+var logger22 = getLogger("completionsHandler");
 var chatCompletionsRoute = createRoute({
   method: "post",
   path: "/completions",
@@ -10947,36 +12074,36 @@ var chatCompletionsRoute = createRoute({
     body: {
       content: {
         "application/json": {
-          schema: z.object({
-            model: z.string().describe("The model to use for the completion"),
-            messages: z.array(
-              z.object({
-                role: z.enum(["system", "user", "assistant", "function", "tool"]).describe("The role of the message"),
-                content: z.union([
-                  z.string(),
-                  z.array(
-                    z.strictObject({
-                      type: z.string(),
-                      text: z.string().optional()
+          schema: z$1.object({
+            model: z$1.string().describe("The model to use for the completion"),
+            messages: z$1.array(
+              z$1.object({
+                role: z$1.enum(["system", "user", "assistant", "function", "tool"]).describe("The role of the message"),
+                content: z$1.union([
+                  z$1.string(),
+                  z$1.array(
+                    z$1.strictObject({
+                      type: z$1.string(),
+                      text: z$1.string().optional()
                     })
                   )
                 ]).describe("The message content"),
-                name: z.string().optional().describe("The name of the message sender")
+                name: z$1.string().optional().describe("The name of the message sender")
               })
             ).describe("The conversation messages"),
-            temperature: z.number().optional().describe("Controls randomness (0-1)"),
-            top_p: z.number().optional().describe("Controls nucleus sampling"),
-            n: z.number().optional().describe("Number of completions to generate"),
-            stream: z.boolean().optional().describe("Whether to stream the response"),
-            max_tokens: z.number().optional().describe("Maximum tokens to generate"),
-            presence_penalty: z.number().optional().describe("Presence penalty (-2 to 2)"),
-            frequency_penalty: z.number().optional().describe("Frequency penalty (-2 to 2)"),
-            logit_bias: z.record(z.string(), z.number()).optional().describe("Token logit bias"),
-            user: z.string().optional().describe("User identifier"),
-            conversationId: z.string().optional().describe("Conversation ID for multi-turn chat"),
-            tools: z.array(z.string()).optional().describe("Available tools"),
-            runConfig: z.record(z.string(), z.unknown()).optional().describe("Run configuration"),
-            headers: z.record(z.string(), z.unknown()).optional().describe(
+            temperature: z$1.number().optional().describe("Controls randomness (0-1)"),
+            top_p: z$1.number().optional().describe("Controls nucleus sampling"),
+            n: z$1.number().optional().describe("Number of completions to generate"),
+            stream: z$1.boolean().optional().describe("Whether to stream the response"),
+            max_tokens: z$1.number().optional().describe("Maximum tokens to generate"),
+            presence_penalty: z$1.number().optional().describe("Presence penalty (-2 to 2)"),
+            frequency_penalty: z$1.number().optional().describe("Frequency penalty (-2 to 2)"),
+            logit_bias: z$1.record(z$1.string(), z$1.number()).optional().describe("Token logit bias"),
+            user: z$1.string().optional().describe("User identifier"),
+            conversationId: z$1.string().optional().describe("Conversation ID for multi-turn chat"),
+            tools: z$1.array(z$1.string()).optional().describe("Available tools"),
+            runConfig: z$1.record(z$1.string(), z$1.unknown()).optional().describe("Run configuration"),
+            headers: z$1.record(z$1.string(), z$1.unknown()).optional().describe(
               "Headers data for template processing (validated against context config schema)"
             )
           })
@@ -10987,14 +12114,14 @@ var chatCompletionsRoute = createRoute({
   responses: {
     200: {
       description: "Streaming chat completion response in Server-Sent Events format",
-      headers: z.object({
-        "Content-Type": z.string().default("text/event-stream"),
-        "Cache-Control": z.string().default("no-cache"),
-        Connection: z.string().default("keep-alive")
+      headers: z$1.object({
+        "Content-Type": z$1.string().default("text/event-stream"),
+        "Cache-Control": z$1.string().default("no-cache"),
+        Connection: z$1.string().default("keep-alive")
       }),
       content: {
         "text/event-stream": {
-          schema: z.string().describe("Server-Sent Events stream with chat completion chunks")
+          schema: z$1.string().describe("Server-Sent Events stream with chat completion chunks")
         }
       }
     },
@@ -11002,13 +12129,13 @@ var chatCompletionsRoute = createRoute({
       description: "Invalid request context or parameters",
       content: {
         "application/json": {
-          schema: z.object({
-            error: z.string(),
-            details: z.array(
-              z.object({
-                field: z.string(),
-                message: z.string(),
-                value: z.unknown().optional()
+          schema: z$1.object({
+            error: z$1.string(),
+            details: z$1.array(
+              z$1.object({
+                field: z$1.string(),
+                message: z$1.string(),
+                value: z$1.unknown().optional()
               })
             ).optional()
           })
@@ -11019,8 +12146,8 @@ var chatCompletionsRoute = createRoute({
       description: "Agent or agent not found",
       content: {
         "application/json": {
-          schema: z.object({
-            error: z.string()
+          schema: z$1.object({
+            error: z$1.string()
           })
         }
       }
@@ -11029,9 +12156,9 @@ var chatCompletionsRoute = createRoute({
       description: "Internal server error",
       content: {
         "application/json": {
-          schema: z.object({
-            error: z.string(),
-            message: z.string()
+          schema: z$1.object({
+            error: z$1.string(),
+            message: z$1.string()
           })
         }
       }
@@ -11053,7 +12180,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
     tracestate: c.req.header("tracestate"),
     baggage: c.req.header("baggage")
   };
-  logger21.info(
+  logger22.info(
     {
       otelHeaders,
       path: c.req.path,
@@ -11162,7 +12289,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
         dbClient: dbClient_default,
         credentialStores
       });
-      logger21.info(
+      logger22.info(
         {
           tenantId,
           projectId,
@@ -11210,7 +12337,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
         try {
           const sseHelper = createSSEStreamHelper(stream2, requestId2, timestamp);
           await sseHelper.writeRole();
-          logger21.info({ subAgentId }, "Starting execution");
+          logger22.info({ subAgentId }, "Starting execution");
           const emitOperationsHeader = c.req.header("x-emit-operations");
           const emitOperations = emitOperationsHeader === "true";
           const executionHandler = new ExecutionHandler();
@@ -11223,7 +12350,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
             sseHelper,
             emitOperations
           });
-          logger21.info(
+          logger22.info(
             { result },
             `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
           );
@@ -11237,7 +12364,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
           }
           await sseHelper.complete();
         } catch (error) {
-          logger21.error(
+          logger22.error(
             {
               error: error instanceof Error ? error.message : error,
               stack: error instanceof Error ? error.stack : void 0
@@ -11254,13 +12381,13 @@ app2.openapi(chatCompletionsRoute, async (c) => {
             );
             await sseHelper.complete();
           } catch (streamError) {
-            logger21.error({ streamError }, "Failed to write error to stream");
+            logger22.error({ streamError }, "Failed to write error to stream");
           }
         }
       });
     });
   } catch (error) {
-    logger21.error(
+    logger22.error(
       {
         error: error instanceof Error ? error.message : error,
         stack: error instanceof Error ? error.stack : void 0
@@ -11284,7 +12411,7 @@ var getMessageText = (content) => {
 };
 var chat_default = app2;
 var app3 = new OpenAPIHono();
-var logger22 = getLogger("chatDataStream");
+var logger23 = getLogger("chatDataStream");
 var chatDataStreamRoute = createRoute({
   method: "post",
   path: "/chat",
@@ -11296,29 +12423,29 @@ var chatDataStreamRoute = createRoute({
     body: {
       content: {
         "application/json": {
-          schema: z.object({
-            model: z.string().optional(),
-            messages: z.array(
-              z.object({
-                role: z.enum(["system", "user", "assistant", "function", "tool"]),
-                content: z.any(),
-                parts: z.array(
-                  z.object({
-                    type: z.union([
-                      z.enum(["text", "image", "audio", "video", "file"]),
-                      z.string().regex(/^data-/, 'Type must start with "data-"')
+          schema: z$1.object({
+            model: z$1.string().optional(),
+            messages: z$1.array(
+              z$1.object({
+                role: z$1.enum(["system", "user", "assistant", "function", "tool"]),
+                content: z$1.any(),
+                parts: z$1.array(
+                  z$1.object({
+                    type: z$1.union([
+                      z$1.enum(["text", "image", "audio", "video", "file"]),
+                      z$1.string().regex(/^data-/, 'Type must start with "data-"')
                     ]),
-                    text: z.string().optional()
+                    text: z$1.string().optional()
                   })
                 ).optional()
               })
             ),
-            id: z.string().optional(),
-            conversationId: z.string().optional(),
-            stream: z.boolean().optional().describe("Whether to stream the response").default(true),
-            max_tokens: z.number().optional().describe("Maximum tokens to generate"),
-            headers: z.record(z.string(), z.unknown()).optional().describe("Headers data for template processing"),
-            runConfig: z.record(z.string(), z.unknown()).optional().describe("Run configuration")
+            id: z$1.string().optional(),
+            conversationId: z$1.string().optional(),
+            stream: z$1.boolean().optional().describe("Whether to stream the response").default(true),
+            max_tokens: z$1.number().optional().describe("Maximum tokens to generate"),
+            headers: z$1.record(z$1.string(), z$1.unknown()).optional().describe("Headers data for template processing"),
+            runConfig: z$1.record(z$1.string(), z$1.unknown()).optional().describe("Run configuration")
           })
         }
       }
@@ -11327,9 +12454,9 @@ var chatDataStreamRoute = createRoute({
   responses: {
     200: {
       description: "Streamed chat completion",
-      headers: z.object({
-        "Content-Type": z.string().default("text/plain; charset=utf-8"),
-        "x-vercel-ai-data-stream": z.string().default("v1")
+      headers: z$1.object({
+        "Content-Type": z$1.string().default("text/plain; charset=utf-8"),
+        "x-vercel-ai-data-stream": z$1.string().default("v1")
       })
     },
     ...commonGetErrorResponses
@@ -11411,7 +12538,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
       });
       const lastUserMessage = body.messages.filter((m) => m.role === "user").slice(-1)[0];
       const userText = typeof lastUserMessage?.content === "string" ? lastUserMessage.content : lastUserMessage?.parts?.map((p) => p.text).join("") || "";
-      logger22.info({ userText, lastUserMessage }, "userText");
+      logger23.info({ userText, lastUserMessage }, "userText");
       const messageSpan = trace.getActiveSpan();
       if (messageSpan) {
         messageSpan.setAttributes({
@@ -11494,7 +12621,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
               await streamHelper.writeOperation(errorOp("Unable to process request", "system"));
             }
           } catch (err) {
-            logger22.error({ err }, "Streaming error");
+            logger23.error({ err }, "Streaming error");
             await streamHelper.writeOperation(errorOp("Internal server error", "system"));
           } finally {
             if ("cleanup" in streamHelper && typeof streamHelper.cleanup === "function") {
@@ -11516,7 +12643,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
       );
     });
   } catch (error) {
-    logger22.error(
+    logger23.error(
       {
         error,
         errorMessage: error instanceof Error ? error.message : String(error),
@@ -11542,11 +12669,11 @@ var toolApprovalRoute = createRoute({
     body: {
       content: {
         "application/json": {
-          schema: z.object({
-            conversationId: z.string().describe("The conversation ID"),
-            toolCallId: z.string().describe("The tool call ID to respond to"),
-            approved: z.boolean().describe("Whether the tool execution is approved"),
-            reason: z.string().optional().describe("Optional reason for the decision")
+          schema: z$1.object({
+            conversationId: z$1.string().describe("The conversation ID"),
+            toolCallId: z$1.string().describe("The tool call ID to respond to"),
+            approved: z$1.boolean().describe("Whether the tool execution is approved"),
+            reason: z$1.string().optional().describe("Optional reason for the decision")
           })
         }
       }
@@ -11557,9 +12684,9 @@ var toolApprovalRoute = createRoute({
       description: "Tool approval response processed successfully",
       content: {
         "application/json": {
-          schema: z.object({
-            success: z.boolean(),
-            message: z.string().optional()
+          schema: z$1.object({
+            success: z$1.boolean(),
+            message: z$1.string().optional()
           })
         }
       }
@@ -11568,8 +12695,8 @@ var toolApprovalRoute = createRoute({
       description: "Bad request - invalid tool call ID or conversation ID",
       content: {
         "application/json": {
-          schema: z.object({
-            error: z.string()
+          schema: z$1.object({
+            error: z$1.string()
           })
         }
       }
@@ -11578,8 +12705,8 @@ var toolApprovalRoute = createRoute({
       description: "Tool call not found or already processed",
       content: {
         "application/json": {
-          schema: z.object({
-            error: z.string()
+          schema: z$1.object({
+            error: z$1.string()
           })
         }
       }
@@ -11588,9 +12715,9 @@ var toolApprovalRoute = createRoute({
       description: "Internal server error",
       content: {
         "application/json": {
-          schema: z.object({
-            error: z.string(),
-            message: z.string()
+          schema: z$1.object({
+            error: z$1.string(),
+            message: z$1.string()
           })
         }
       }
@@ -11605,7 +12732,7 @@ app3.openapi(toolApprovalRoute, async (c) => {
       const { tenantId, projectId } = executionContext;
       const requestBody = await c.req.json();
       const { conversationId, toolCallId, approved, reason } = requestBody;
-      logger22.info(
+      logger23.info(
         {
           conversationId,
           toolCallId,
@@ -11634,7 +12761,7 @@ app3.openapi(toolApprovalRoute, async (c) => {
         span.setStatus({ code: 1, message: "Tool call not found" });
         return c.json({ error: "Tool call not found or already processed" }, 404);
       }
-      logger22.info({ conversationId, toolCallId, approved }, "Tool approval processed successfully");
+      logger23.info({ conversationId, toolCallId, approved }, "Tool approval processed successfully");
       span.setStatus({ code: 1, message: "Success" });
       return c.json({
         success: true,
@@ -11642,7 +12769,7 @@ app3.openapi(toolApprovalRoute, async (c) => {
       });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      logger22.error(
+      logger23.error(
         {
           error: errorMessage,
           stack: error instanceof Error ? error.stack : void 0
@@ -11663,7 +12790,7 @@ app3.openapi(toolApprovalRoute, async (c) => {
   });
 });
 var chatDataStream_default = app3;
-var logger23 = getLogger("mcp");
+var logger24 = getLogger("mcp");
 var MockResponseSingleton = class _MockResponseSingleton {
   static instance;
   mockRes;
@@ -11717,21 +12844,21 @@ var createSpoofInitMessage = (mcpProtocolVersion) => ({
   id: 0
 });
 var spoofTransportInitialization = async (transport, req, sessionId, mcpProtocolVersion) => {
-  logger23.info({ sessionId }, "Spoofing initialization message to set transport state");
+  logger24.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);
-    logger23.info({ sessionId }, "Successfully spoofed initialization");
+    logger24.info({ sessionId }, "Successfully spoofed initialization");
   } catch (spoofError) {
-    logger23.warn({ sessionId, error: spoofError }, "Spoof initialization failed, continuing anyway");
+    logger24.warn({ sessionId, error: spoofError }, "Spoof initialization failed, continuing anyway");
   }
 };
 var validateSession = async (req, res, body, tenantId, projectId, agentId) => {
   const sessionId = req.headers["mcp-session-id"];
-  logger23.info({ sessionId }, "Received MCP session ID");
+  logger24.info({ sessionId }, "Received MCP session ID");
   if (!sessionId) {
-    logger23.info({ body }, "Missing session ID");
+    logger24.info({ body }, "Missing session ID");
     res.writeHead(400).end(
       JSON.stringify({
         jsonrpc: "2.0",
@@ -11758,7 +12885,7 @@ var validateSession = async (req, res, body, tenantId, projectId, agentId) => {
     scopes: { tenantId, projectId },
     conversationId: sessionId
   });
-  logger23.info(
+  logger24.info(
     {
       sessionId,
       conversationFound: !!conversation,
@@ -11769,7 +12896,7 @@ var validateSession = async (req, res, body, tenantId, projectId, agentId) => {
     "Conversation lookup result"
   );
   if (!conversation || conversation.metadata?.sessionData?.sessionType !== "mcp" || conversation.metadata?.sessionData?.agentId !== agentId) {
-    logger23.info(
+    logger24.info(
       { sessionId, conversationId: conversation?.id },
       "MCP session not found or invalid"
     );
@@ -11830,7 +12957,7 @@ var executeAgentQuery = async (executionContext, conversationId, query, defaultS
     requestId: requestId2,
     sseHelper: mcpStreamHelper
   });
-  logger23.info(
+  logger24.info(
     { result },
     `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
   );
@@ -11874,7 +13001,7 @@ var getServer = async (headers2, executionContext, conversationId, credentialSto
     "send-query-to-agent",
     `Send a query to the ${agent.name} agent. The agent has the following description: ${agent.description}`,
     {
-      query: z.string().describe("The query to send to the agent")
+      query: z$1.string().describe("The query to send to the agent")
     },
     async ({ query }) => {
       try {
@@ -11914,7 +13041,7 @@ var getServer = async (headers2, executionContext, conversationId, credentialSto
           dbClient: dbClient_default,
           credentialStores
         });
-        logger23.info(
+        logger24.info(
           {
             tenantId,
             projectId,
@@ -11976,7 +13103,7 @@ var validateRequestParameters = (c) => {
 };
 var handleInitializationRequest = async (body, executionContext, validatedContext, req, res, c, credentialStores) => {
   const { tenantId, projectId, agentId } = executionContext;
-  logger23.info({ body }, "Received initialization request");
+  logger24.info({ body }, "Received initialization request");
   const sessionId = getConversationId();
   const activeSpan = trace.getActiveSpan();
   if (activeSpan) {
@@ -12032,7 +13159,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
         }
       }
     });
-    logger23.info(
+    logger24.info(
       { sessionId, conversationId: conversation.id },
       "Created MCP session as conversation"
     );
@@ -12041,9 +13168,9 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
     });
     const server = await getServer(validatedContext, executionContext, sessionId, credentialStores);
     await server.connect(transport);
-    logger23.info({ sessionId }, "Server connected for initialization");
+    logger24.info({ sessionId }, "Server connected for initialization");
     res.setHeader("Mcp-Session-Id", sessionId);
-    logger23.info(
+    logger24.info(
       {
         sessionId,
         bodyMethod: body?.method,
@@ -12052,7 +13179,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
       "About to handle initialization request"
     );
     await transport.handleRequest(req, res, body);
-    logger23.info({ sessionId }, "Successfully handled initialization request");
+    logger24.info({ sessionId }, "Successfully handled initialization request");
     return toFetchResponse(res);
   });
 };
@@ -12079,8 +13206,8 @@ var handleExistingSessionRequest = async (body, executionContext, validatedConte
     sessionId,
     conversation.metadata?.session_data?.mcpProtocolVersion
   );
-  logger23.info({ sessionId }, "Server connected and transport initialized");
-  logger23.info(
+  logger24.info({ sessionId }, "Server connected and transport initialized");
+  logger24.info(
     {
       sessionId,
       bodyKeys: Object.keys(body || {}),
@@ -12094,9 +13221,9 @@ var handleExistingSessionRequest = async (body, executionContext, validatedConte
   );
   try {
     await transport.handleRequest(req, res, body);
-    logger23.info({ sessionId }, "Successfully handled MCP request");
+    logger24.info({ sessionId }, "Successfully handled MCP request");
   } catch (transportError) {
-    logger23.error(
+    logger24.error(
       {
         sessionId,
         error: transportError,
@@ -12147,13 +13274,13 @@ app4.openapi(
       }
       const { executionContext } = paramValidation;
       const body = c.get("requestBody") || {};
-      logger23.info({ body, bodyKeys: Object.keys(body || {}) }, "Parsed request body");
+      logger24.info({ body, bodyKeys: Object.keys(body || {}) }, "Parsed request body");
       const isInitRequest = body.method === "initialize";
       const { req, res } = toReqRes(c.req.raw);
       const validatedContext = c.get("validatedContext") || {};
       const credentialStores = c.get("credentialStores");
-      logger23.info({ validatedContext }, "Validated context");
-      logger23.info({ req }, "request");
+      logger24.info({ validatedContext }, "Validated context");
+      logger24.info({ req }, "request");
       if (isInitRequest) {
         return await handleInitializationRequest(
           body,
@@ -12174,7 +13301,7 @@ app4.openapi(
         credentialStores
       );
     } catch (e) {
-      logger23.error(
+      logger24.error(
         {
           error: e instanceof Error ? e.message : e,
           stack: e instanceof Error ? e.stack : void 0
@@ -12186,7 +13313,7 @@ app4.openapi(
   }
 );
 app4.get("/", async (c) => {
-  logger23.info({}, "Received GET MCP request");
+  logger24.info({}, "Received GET MCP request");
   return c.json(
     {
       jsonrpc: "2.0",
@@ -12200,7 +13327,7 @@ app4.get("/", async (c) => {
   );
 });
 app4.delete("/", async (c) => {
-  logger23.info({}, "Received DELETE MCP request");
+  logger24.info({}, "Received DELETE MCP request");
   return c.json(
     {
       jsonrpc: "2.0",
@@ -12213,7 +13340,7 @@ app4.delete("/", async (c) => {
 var mcp_default = app4;
 
 // src/app.ts
-var logger24 = getLogger("agents-run-api");
+var logger25 = getLogger("agents-run-api");
 function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
   const app6 = new OpenAPIHono();
   app6.use("*", otel());
@@ -12232,7 +13359,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
         const body = await c.req.json();
         c.set("requestBody", body);
       } catch (error) {
-        logger24.debug({ error }, "Failed to parse JSON body, continuing without parsed body");
+        logger25.debug({ error }, "Failed to parse JSON body, continuing without parsed body");
       }
     }
     return next();
@@ -12283,8 +13410,8 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
       if (!isExpectedError) {
         const errorMessage = err instanceof Error ? err.message : String(err);
         const errorStack = err instanceof Error ? err.stack : void 0;
-        if (logger24) {
-          logger24.error(
+        if (logger25) {
+          logger25.error(
             {
               error: err,
               message: errorMessage,
@@ -12296,8 +13423,8 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
           );
         }
       } else {
-        if (logger24) {
-          logger24.error(
+        if (logger25) {
+          logger25.error(
             {
               error: err,
               path: c.req.path,
@@ -12314,8 +13441,8 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
         const response = err.getResponse();
         return response;
       } catch (responseError) {
-        if (logger24) {
-          logger24.error({ error: responseError }, "Error while handling HTTPException response");
+        if (logger25) {
+          logger25.error({ error: responseError }, "Error while handling HTTPException response");
         }
       }
     }
@@ -12349,7 +13476,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
   app6.use("*", async (c, next) => {
     const executionContext = c.get("executionContext");
     if (!executionContext) {
-      logger24.debug({}, "Empty execution context");
+      logger25.debug({}, "Empty execution context");
       return next();
     }
     const { tenantId, projectId, agentId } = executionContext;
@@ -12358,7 +13485,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
     if (requestBody) {
       conversationId = requestBody.conversationId;
       if (!conversationId) {
-        logger24.debug({ requestBody }, "No conversation ID found in request body");
+        logger25.debug({ requestBody }, "No conversation ID found in request body");
       }
     }
     const entries = Object.fromEntries(
@@ -12373,7 +13500,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
       })
     );
     if (!Object.keys(entries).length) {
-      logger24.debug({}, "Empty entries for baggage");
+      logger25.debug({}, "Empty entries for baggage");
       return next();
     }
     const bag = Object.entries(entries).reduce(
@@ -12427,6 +13554,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
 }
 
 // src/index.ts
+defaultSDK.start();
 var defaultConfig = {
   port: 3003,
   serverOptions: {