@inkeep/agents-run-api 0.0.0-dev-20250917222639 → 0.0.0-dev-20250919052931

package/dist/index.js

@@ -8,7 +8,7 @@ import { resourceFromAttributes } from '@opentelemetry/resources';
 import { NodeSDK } from '@opentelemetry/sdk-node';
 import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base';
 import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
-import { getLogger, getTracer, HeadersScopeSchema, getRequestExecutionContext, getAgentGraphWithDefaultAgent, contextValidationMiddleware, getFullGraph, createOrGetConversation, getActiveAgentForConversation, setActiveAgentForConversation, getAgentById, handleContextResolution, createMessage, commonGetErrorResponses, createDefaultCredentialStores, CredentialStoreRegistry, listTaskIdsByContextId, getTask, getLedgerArtifacts, getAgentGraph, createTask, updateTask, setSpanWithError, updateConversation, handleApiError, TaskState, setActiveAgentForThread, getConversation, getRelatedAgentsForGraph, getToolsForAgent, getDataComponentsForAgent, getArtifactComponentsForAgent, validateAndGetApiKey, getProject, ContextResolver, CredentialStuffer, MCPServerType, getCredentialReference, McpClient, getContextConfigById, getFullGraphDefinition, TemplateEngine, graphHasArtifactComponents, MCPTransportType, getExternalAgent } from '@inkeep/agents-core';
+import { getLogger, getTracer, HeadersScopeSchema, getRequestExecutionContext, getAgentGraphWithDefaultAgent, contextValidationMiddleware, getFullGraph, createOrGetConversation, getActiveAgentForConversation, setActiveAgentForConversation, getAgentById, handleContextResolution, createMessage, commonGetErrorResponses, loggerFactory, createDefaultCredentialStores, CredentialStoreRegistry, listTaskIdsByContextId, getTask, getLedgerArtifacts, getAgentGraphById, createTask, updateTask, setSpanWithError, updateConversation, handleApiError, TaskState, setActiveAgentForThread, getConversation, getRelatedAgentsForGraph, getToolsForAgent, getDataComponentsForAgent, getArtifactComponentsForAgent, validateAndGetApiKey, getProject, ContextResolver, CredentialStuffer, MCPServerType, getCredentialReference, McpClient, getContextConfigById, getFullGraphDefinition, TemplateEngine, graphHasArtifactComponents, MCPTransportType, getExternalAgent } from '@inkeep/agents-core';
 import { OpenAPIHono, createRoute, z as z$1 } from '@hono/zod-openapi';
 import { trace, propagation, context, SpanStatusCode } from '@opentelemetry/api';
 import { Hono } from 'hono';
@@ -22,7 +22,7 @@ import { streamSSE, stream } from 'hono/streaming';
 import { nanoid } from 'nanoid';
 import destr from 'destr';
 import traverse from 'traverse';
-import { createUIMessageStream, JsonToSseTransformStream, parsePartialJson, generateText, generateObject, tool, streamText } from 'ai';
+import { createUIMessageStream, JsonToSseTransformStream, parsePartialJson, generateText, generateObject, tool, streamText, streamObject } from 'ai';
 import { createAnthropic, anthropic } from '@ai-sdk/anthropic';
 import { createGoogleGenerativeAI, google } from '@ai-sdk/google';
 import { createOpenAI, openai } from '@ai-sdk/openai';
@@ -965,7 +965,7 @@ async function getRegisteredAgent(executionContext, credentialStoreRegistry) {
     throw new Error("Agent ID is required");
   }
   const dbAgent = await getAgentById(dbClient_default)({
-    scopes: { tenantId, projectId },
+    scopes: { tenantId, projectId, graphId },
     agentId
   });
   if (!dbAgent) {
@@ -980,6 +980,38 @@ async function getRegisteredAgent(executionContext, credentialStoreRegistry) {
     apiKey
   });
 }
+async function resolveModelConfig(graphId, agent) {
+  if (agent.models?.base?.model) {
+    return {
+      base: agent.models.base,
+      structuredOutput: agent.models.structuredOutput || agent.models.base,
+      summarizer: agent.models.summarizer || agent.models.base
+    };
+  }
+  const graph = await getAgentGraphById(dbClient_default)({
+    scopes: { tenantId: agent.tenantId, projectId: agent.projectId, graphId }
+  });
+  if (graph?.models?.base?.model) {
+    return {
+      base: graph.models.base,
+      structuredOutput: agent.models?.structuredOutput || graph.models.structuredOutput || graph.models.base,
+      summarizer: agent.models?.summarizer || graph.models.summarizer || graph.models.base
+    };
+  }
+  const project = await getProject(dbClient_default)({
+    scopes: { tenantId: agent.tenantId, projectId: agent.projectId }
+  });
+  if (project?.models?.base?.model) {
+    return {
+      base: project.models.base,
+      structuredOutput: agent.models?.structuredOutput || project.models.structuredOutput || project.models.base,
+      summarizer: agent.models?.summarizer || project.models.summarizer || project.models.base
+    };
+  }
+  throw new Error(
+    "Base model configuration is required. Please configure models at the project level."
+  );
+}
 function agentInitializingOp(sessionId, graphId) {
   return {
     type: "agent_initializing",
@@ -998,24 +1030,19 @@ function completionOp(agentId, iterations) {
     }
   };
 }
-function errorOp(error, agentId) {
+function errorOp(message, agentId, severity = "error", code) {
   return {
     type: "error",
-    ctx: {
-      error,
-      agent: agentId
-    }
+    message,
+    agent: agentId,
+    severity,
+    code,
+    timestamp: Date.now()
   };
 }
 function generateToolId() {
   return `tool_${nanoid(8)}`;
 }
-function statusUpdateOp(ctx) {
-  return {
-    type: "status_update",
-    ctx
-  };
-}
 var logger4 = getLogger("DataComponentSchema");
 function jsonSchemaToZod(jsonSchema) {
   if (!jsonSchema || typeof jsonSchema !== "object") {
@@ -1145,6 +1172,9 @@ var _ModelFactory = class _ModelFactory {
       );
     }
     const modelSettings = config;
+    if (!modelSettings.model) {
+      throw new Error("Model configuration is required");
+    }
     const modelString = modelSettings.model.trim();
     const { provider, modelName } = _ModelFactory.parseModelString(modelString);
     logger5.debug(
@@ -1267,7 +1297,6 @@ var _ModelFactory = class _ModelFactory {
  */
 __publicField(_ModelFactory, "SUPPORTED_PROVIDERS", ["anthropic", "openai", "google"]);
 var ModelFactory = _ModelFactory;
-var tracer = getTracer("agents-run-api");
 
 // src/utils/stream-registry.ts
 var streamHelperRegistry = /* @__PURE__ */ new Map();
@@ -1283,6 +1312,7 @@ function getStreamHelper(requestId2) {
 function unregisterStreamHelper(requestId2) {
   streamHelperRegistry.delete(requestId2);
 }
+var tracer = getTracer("agents-run-api");
 
 // src/utils/graph-session.ts
 var logger6 = getLogger("GraphSession");
@@ -1591,7 +1621,6 @@ var GraphSession = class {
     }
     this.isGeneratingUpdate = true;
     const statusUpdateState = this.statusUpdateState;
-    const graphId = this.graphId;
     try {
       const streamHelper = getStreamHelper(this.sessionId);
       if (!streamHelper) {
@@ -1604,7 +1633,7 @@ var GraphSession = class {
       }
       const now = Date.now();
       const elapsedTime = now - statusUpdateState.startTime;
-      let operation;
+      let summaryToSend;
       if (statusUpdateState.config.statusComponents && statusUpdateState.config.statusComponents.length > 0) {
         const result = await this.generateStructuredStatusUpdate(
           this.events.slice(statusUpdateState.lastEventCount),
@@ -1613,32 +1642,30 @@ var GraphSession = class {
           statusUpdateState.summarizerModel,
           this.previousSummaries
         );
-        if (result.operations && result.operations.length > 0) {
-          for (const op of result.operations) {
-            if (!op || !op.type || !op.data || Object.keys(op.data).length === 0) {
+        if (result.summaries && result.summaries.length > 0) {
+          for (const summary of result.summaries) {
+            if (!summary || !summary.type || !summary.data || !summary.data.label || Object.keys(summary.data).length === 0) {
               logger6.warn(
                 {
                   sessionId: this.sessionId,
-                  operation: op
+                  summary
                 },
                 "Skipping empty or invalid structured operation"
               );
               continue;
             }
-            const operationToSend = {
-              type: "status_update",
-              ctx: {
-                operationType: op.type,
-                label: op.data.label,
-                data: Object.fromEntries(
-                  Object.entries(op.data).filter(([key]) => !["label", "type"].includes(key))
-                )
-              }
+            const summaryToSend2 = {
+              type: summary.data.type || summary.type,
+              // Preserve the actual custom type from LLM
+              label: summary.data.label,
+              details: Object.fromEntries(
+                Object.entries(summary.data).filter(([key]) => !["label", "type"].includes(key))
+              )
             };
-            await streamHelper.writeOperation(operationToSend);
+            await streamHelper.writeSummary(summaryToSend2);
           }
-          const summaryTexts = result.operations.map(
-            (op) => JSON.stringify({ type: op.type, data: op.data })
+          const summaryTexts = result.summaries.map(
+            (summary) => JSON.stringify({ type: summary.type, data: summary.data })
           );
           this.previousSummaries.push(...summaryTexts);
           if (this.statusUpdateState) {
@@ -1655,34 +1682,20 @@ var GraphSession = class {
           this.previousSummaries
         );
         this.previousSummaries.push(summary);
-        operation = statusUpdateOp({
-          summary,
-          eventCount: this.events.length,
-          elapsedTime,
-          currentPhase: "processing",
-          activeAgent: "system",
-          graphId,
-          sessionId: this.sessionId
-        });
       }
       if (this.previousSummaries.length > 3) {
         this.previousSummaries.shift();
       }
-      if (!operation || !operation.type || !operation.ctx) {
+      {
         logger6.warn(
           {
             sessionId: this.sessionId,
-            operation
+            summaryToSend
           },
           "Skipping empty or invalid status update operation"
         );
         return;
       }
-      await streamHelper.writeOperation(operation);
-      if (this.statusUpdateState) {
-        this.statusUpdateState.lastUpdateTime = now;
-        this.statusUpdateState.lastEventCount = this.events.length;
-      }
     } catch (error) {
       logger6.error(
         {
@@ -1815,7 +1828,7 @@ ${previousSummaryContext}` : ""}
 Activities:
 ${userVisibleActivities.join("\n") || "No New Activities"}
 
-Describe the ACTUAL finding, result, or specific information discovered (e.g., "Found Slack bot requires admin permissions", "Identified 3 channel types for ingestion", "Configuration requires OAuth token").
+Create a short 3-5 word label describing the ACTUAL finding. Use sentence case (only capitalize the first word and proper nouns). Examples: "Found admin permissions needed", "Identified three channel types", "OAuth token required".
 
 ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
           const prompt = basePrompt;
@@ -1828,6 +1841,9 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
             }
             modelToUse = this.statusUpdateState.baseModel;
           }
+          if (!modelToUse) {
+            throw new Error("No model configuration available");
+          }
           const model = ModelFactory.createModel(modelToUse);
           const { text } = await generateText({
             model,
@@ -1937,14 +1953,16 @@ Rules:
 - Fill in data for relevant components only
 - Use 'no_relevant_updates' if nothing substantially new to report. DO NOT WRITE LABELS OR USE OTHER COMPONENTS IF YOU USE THIS COMPONENT.
 - Never repeat previous values, make every update EXTREMELY unique. If you cannot do that the update is not worth mentioning.
-- Labels MUST contain the ACTUAL information discovered ("Found X", "Learned Y", "Discovered Z requires A")
+- Labels MUST be short 3-5 word phrases with ACTUAL information discovered. NEVER MAKE UP SOMETHING WITHOUT BACKING IT UP WITH ACTUAL INFORMATION.
+- Use sentence case: only capitalize the first word and proper nouns (e.g., "Admin permissions required", not "Admin Permissions Required"). ALWAYS capitalize the first word of the label.
 - DO NOT use action words like "Searching", "Processing", "Analyzing" - state what was FOUND
 - Include specific details, numbers, requirements, or insights discovered
+- Examples: "Admin permissions required", "Three OAuth steps found", "Token expires daily"
 - You are ONE unified AI system - NEVER mention agents, transfers, delegations, or routing
-- CRITICAL: NEVER use the words "transfer", "delegation", "agent", "routing", or any internal system terminology in labels
+- CRITICAL: NEVER use the words "transfer", "delegation", "agent", "routing", "artifact", or any internal system terminology in labels or any names of agents, tools, or systems.
 - Present all operations as seamless actions by a single system
 - Anonymize all internal operations so that the information appears descriptive and USER FRIENDLY. HIDE ALL INTERNAL OPERATIONS!
-- Bad examples: "Transferring to search agent", "Delegating task", "Routing request", "Processing request", or not using the no_relevant_updates
+- Bad examples: "Transferring to search agent", "continuing transfer to qa agent", "Delegating task", "Routing request", "Processing request", "Artifact found", "Artifact saved", or not using the no_relevant_updates
 - Good examples: "Slack bot needs admin privileges", "Found 3-step OAuth flow required", "Channel limit is 500 per workspace", or use the no_relevant_updates component if nothing new to report.
 
 REMEMBER YOU CAN ONLY USE 'no_relevant_updates' ALONE! IT CANNOT BE CONCATENATED WITH OTHER STATUS UPDATES!
@@ -1960,6 +1978,9 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
             }
             modelToUse = this.statusUpdateState.baseModel;
           }
+          if (!modelToUse) {
+            throw new Error("No model configuration available");
+          }
           const model = ModelFactory.createModel(modelToUse);
           const { object } = await generateObject({
             model,
@@ -1977,29 +1998,29 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
             }
           });
           const result = object;
-          const operations = [];
+          const summaries = [];
           for (const [componentId, data] of Object.entries(result)) {
             if (componentId === "no_relevant_updates") {
               continue;
             }
             if (data && typeof data === "object" && Object.keys(data).length > 0) {
-              operations.push({
+              summaries.push({
                 type: componentId,
                 data
               });
             }
           }
           span.setAttributes({
-            "operations.count": operations.length,
+            "summaries.count": summaries.length,
             "user_activities.count": userVisibleActivities.length,
             "result_keys.count": Object.keys(result).length
           });
           span.setStatus({ code: SpanStatusCode.OK });
-          return { operations };
+          return { summaries };
         } catch (error) {
           setSpanWithError(span, error);
           logger6.error({ error }, "Failed to generate structured update, using fallback");
-          return { operations: [] };
+          return { summaries: [] };
         } finally {
           span.end();
         }
@@ -2250,6 +2271,9 @@ Make it specific and relevant.`;
             }
             modelToUse = this.statusUpdateState.baseModel;
           }
+          if (!modelToUse) {
+            throw new Error("No model configuration available");
+          }
           const model = ModelFactory.createModel(modelToUse);
           const schema = z.object({
             name: z.string().max(50).describe("Concise, descriptive name for the artifact"),
@@ -2528,6 +2552,7 @@ var _ArtifactParser = class _ArtifactParser {
     }
     for (let i = matches.length - 1; i >= 0; i--) {
       const match = matches[i];
+      if (match.index === void 0) continue;
       const startIdx = match.index;
       const textAfterMatch = text.slice(startIdx);
       if (!textAfterMatch.includes("/>")) {
@@ -2577,7 +2602,8 @@ var _ArtifactParser = class _ArtifactParser {
       taskId,
       name: artifact.name || "Processing...",
       description: artifact.description || "Name and description being generated...",
-      artifactType: artifact.metadata?.artifactType,
+      type: artifact.metadata?.artifactType || artifact.artifactType,
+      // Map artifactType to type for consistency
       artifactSummary: artifact.parts?.[0]?.data?.summary || {}
     };
   }
@@ -2594,10 +2620,11 @@ var _ArtifactParser = class _ArtifactParser {
     let lastIndex = 0;
     for (const match of matches) {
       const [fullMatch, artifactId, taskId] = match;
+      if (match.index === void 0) continue;
       const matchStart = match.index;
       if (matchStart > lastIndex) {
         const textBefore = text.slice(lastIndex, matchStart);
-        if (textBefore.trim()) {
+        if (textBefore) {
           parts.push({ kind: "text", text: textBefore });
         }
       }
@@ -2609,7 +2636,7 @@ var _ArtifactParser = class _ArtifactParser {
     }
     if (lastIndex < text.length) {
       const remainingText = text.slice(lastIndex);
-      if (remainingText.trim()) {
+      if (remainingText) {
         parts.push({ kind: "text", text: remainingText });
       }
     }
@@ -2719,8 +2746,9 @@ __publicField(_ArtifactParser, "INCOMPLETE_ARTIFACT_REGEX", /<(a(r(t(i(f(a(c(t(:
 var ArtifactParser = _ArtifactParser;
 
 // src/utils/incremental-stream-parser.ts
-var logger8 = getLogger("IncrementalStreamParser");
-var IncrementalStreamParser = class {
+getLogger("IncrementalStreamParser");
+var _IncrementalStreamParser = class _IncrementalStreamParser {
+  // Max number of streamed component IDs to track
   constructor(streamHelper, tenantId, contextId) {
     __publicField(this, "buffer", "");
     __publicField(this, "pendingTextBuffer", "");
@@ -2730,6 +2758,9 @@ var IncrementalStreamParser = class {
     __publicField(this, "collectedParts", []);
     __publicField(this, "contextId");
     __publicField(this, "lastChunkWasToolResult", false);
+    __publicField(this, "componentAccumulator", {});
+    __publicField(this, "lastStreamedComponents", /* @__PURE__ */ new Map());
+    __publicField(this, "componentSnapshots", /* @__PURE__ */ new Map());
     this.streamHelper = streamHelper;
     this.contextId = contextId;
     this.artifactParser = new ArtifactParser(tenantId);
@@ -2744,7 +2775,7 @@ var IncrementalStreamParser = class {
    * Process a new text chunk for text streaming (handles artifact markers)
    */
   async processTextChunk(chunk) {
-    if (this.lastChunkWasToolResult && this.buffer === "" && chunk.trim()) {
+    if (this.lastChunkWasToolResult && this.buffer === "" && chunk) {
       chunk = "\n\n" + chunk;
       this.lastChunkWasToolResult = false;
     }
@@ -2756,100 +2787,122 @@ var IncrementalStreamParser = class {
     this.buffer = parseResult.remainingBuffer;
   }
   /**
-   * Process a new object chunk for object streaming (handles JSON objects with artifact references)
+   * Process object deltas directly from Vercel AI SDK's fullStream
+   * Accumulates components and streams them when they're stable (unchanged between deltas)
    */
-  async processObjectChunk(chunk) {
-    this.buffer += chunk;
-    const parseResult = await this.parseObjectBuffer();
-    for (const part of parseResult.completeParts) {
-      await this.streamPart(part);
+  async processObjectDelta(delta) {
+    if (!delta || typeof delta !== "object") {
+      return;
     }
-    this.buffer = parseResult.remainingBuffer;
-  }
-  /**
-   * Process tool call stream for structured output, streaming components as they complete
-   */
-  async processToolCallStream(stream2, targetToolName) {
-    let jsonBuffer = "";
-    let componentBuffer = "";
-    let depth = 0;
-    let componentsStreamed = 0;
-    const MAX_BUFFER_SIZE = 5 * 1024 * 1024;
-    for await (const part of stream2) {
-      if (part.type === "tool-call-delta" && part.toolName === targetToolName) {
-        const delta = part.argsTextDelta || "";
-        if (jsonBuffer.length + delta.length > MAX_BUFFER_SIZE) {
-          logger8.warn(
-            { bufferSize: jsonBuffer.length + delta.length, maxSize: MAX_BUFFER_SIZE },
-            "JSON buffer exceeded maximum size, truncating"
-          );
-          jsonBuffer = jsonBuffer.slice(-MAX_BUFFER_SIZE / 2);
+    this.componentAccumulator = this.deepMerge(this.componentAccumulator, delta);
+    if (this.componentAccumulator.dataComponents && Array.isArray(this.componentAccumulator.dataComponents)) {
+      const components = this.componentAccumulator.dataComponents;
+      const currentComponentIds = new Set(components.filter((c) => c?.id).map((c) => c.id));
+      for (const [componentId, snapshot] of this.componentSnapshots.entries()) {
+        if (!currentComponentIds.has(componentId) && !this.lastStreamedComponents.has(componentId)) {
+          try {
+            const component = JSON.parse(snapshot);
+            if (this.isComponentComplete(component)) {
+              await this.streamComponent(component);
+            }
+          } catch (e) {
+          }
         }
-        jsonBuffer += delta;
-        for (const char of delta) {
-          if (componentBuffer.length > MAX_BUFFER_SIZE) {
-            logger8.warn(
-              { bufferSize: componentBuffer.length, maxSize: MAX_BUFFER_SIZE },
-              "Component buffer exceeded maximum size, resetting"
-            );
-            componentBuffer = "";
-            depth = 0;
-            continue;
+      }
+      for (let i = 0; i < components.length; i++) {
+        const component = components[i];
+        if (!component?.id) continue;
+        const componentKey = component.id;
+        const hasBeenStreamed = this.lastStreamedComponents.has(componentKey);
+        if (hasBeenStreamed) continue;
+        const currentSnapshot = JSON.stringify(component);
+        const previousSnapshot = this.componentSnapshots.get(componentKey);
+        this.componentSnapshots.set(componentKey, currentSnapshot);
+        if (this.componentSnapshots.size > _IncrementalStreamParser.MAX_SNAPSHOT_SIZE) {
+          const firstKey = this.componentSnapshots.keys().next().value;
+          if (firstKey) {
+            this.componentSnapshots.delete(firstKey);
           }
-          componentBuffer += char;
-          if (char === "{") {
-            depth++;
-          } else if (char === "}") {
-            depth--;
-            if (depth === 2 && componentBuffer.includes('"id"')) {
-              const componentMatch = componentBuffer.match(/\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/);
-              if (componentMatch) {
-                const MAX_COMPONENT_SIZE = 1024 * 1024;
-                if (componentMatch[0].length > MAX_COMPONENT_SIZE) {
-                  logger8.warn(
-                    {
-                      size: componentMatch[0].length,
-                      maxSize: MAX_COMPONENT_SIZE
-                    },
-                    "Component exceeds size limit, skipping"
-                  );
-                  componentBuffer = "";
-                  continue;
-                }
-                try {
-                  const component = JSON.parse(componentMatch[0]);
-                  if (typeof component !== "object" || !component.id) {
-                    logger8.warn({ component }, "Invalid component structure, skipping");
-                    componentBuffer = "";
-                    continue;
-                  }
-                  const parts = await this.artifactParser.parseObject({
-                    dataComponents: [component]
-                  });
-                  for (const part2 of parts) {
-                    await this.streamPart(part2);
-                  }
-                  componentsStreamed++;
-                  componentBuffer = "";
-                } catch (e) {
-                  logger8.debug({ error: e }, "Failed to parse component, continuing to accumulate");
-                }
-              }
+        }
+        if (component.name === "Text" && component.props?.text) {
+          const previousTextContent = previousSnapshot ? JSON.parse(previousSnapshot).props?.text || "" : "";
+          const currentTextContent = component.props.text || "";
+          if (currentTextContent.length > previousTextContent.length) {
+            const newText = currentTextContent.slice(previousTextContent.length);
+            if (!this.hasStartedRole) {
+              await this.streamHelper.writeRole("assistant");
+              this.hasStartedRole = true;
             }
+            await this.streamHelper.streamText(newText, 50);
+            this.collectedParts.push({
+              kind: "text",
+              text: newText
+            });
           }
-          if (componentBuffer.includes('"dataComponents"') && componentBuffer.includes("[")) ;
+          continue;
         }
-      } else if (part.type === "tool-call" && part.toolName === targetToolName) {
-        if (part.args?.dataComponents) {
-          const parts = await this.artifactParser.parseObject(part.args);
-          for (const part2 of parts) {
-            await this.streamPart(part2);
+        if (this.isComponentComplete(component)) {
+          const currentPropsSnapshot = JSON.stringify(component.props);
+          const previousPropsSnapshot = previousSnapshot ? JSON.stringify(JSON.parse(previousSnapshot).props) : null;
+          if (previousPropsSnapshot === currentPropsSnapshot) {
+            await this.streamComponent(component);
           }
         }
-        break;
       }
     }
-    logger8.debug({ componentsStreamed }, "Finished streaming components");
+  }
+  /**
+   * Stream a component and mark it as streamed
+   * Note: Text components are handled separately with incremental streaming
+   */
+  async streamComponent(component) {
+    const parts = await this.artifactParser.parseObject({
+      dataComponents: [component]
+    });
+    for (const part of parts) {
+      await this.streamPart(part);
+    }
+    this.lastStreamedComponents.set(component.id, true);
+    if (this.lastStreamedComponents.size > _IncrementalStreamParser.MAX_STREAMED_SIZE) {
+      const firstKey = this.lastStreamedComponents.keys().next().value;
+      if (firstKey) {
+        this.lastStreamedComponents.delete(firstKey);
+      }
+    }
+    this.componentSnapshots.delete(component.id);
+  }
+  /**
+   * Check if a component has the basic structure required for streaming
+   * Requires id, name, and props object with content
+   */
+  isComponentComplete(component) {
+    if (!component || !component.id || !component.name) {
+      return false;
+    }
+    if (!component.props || typeof component.props !== "object") {
+      return false;
+    }
+    const isArtifact = component.name === "Artifact" || component.props.artifact_id && component.props.task_id;
+    if (isArtifact) {
+      return Boolean(component.props.artifact_id && component.props.task_id);
+    }
+    return true;
+  }
+  /**
+   * Deep merge helper for object deltas
+   */
+  deepMerge(target, source) {
+    if (!source) return target;
+    if (!target) return source;
+    const result = { ...target };
+    for (const key in source) {
+      if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+        result[key] = this.deepMerge(target[key], source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+    return result;
   }
   /**
    * Legacy method for backward compatibility - defaults to text processing
@@ -2861,15 +2914,40 @@ var IncrementalStreamParser = class {
    * Process any remaining buffer content at the end of stream
    */
   async finalize() {
-    if (this.buffer.trim()) {
+    if (this.componentAccumulator.dataComponents && Array.isArray(this.componentAccumulator.dataComponents)) {
+      const components = this.componentAccumulator.dataComponents;
+      for (let i = 0; i < components.length; i++) {
+        const component = components[i];
+        if (!component?.id) continue;
+        const componentKey = component.id;
+        const hasBeenStreamed = this.lastStreamedComponents.has(componentKey);
+        if (!hasBeenStreamed && this.isComponentComplete(component) && component.name !== "Text") {
+          const parts = await this.artifactParser.parseObject({
+            dataComponents: [component]
+          });
+          for (const part of parts) {
+            await this.streamPart(part);
+          }
+          this.lastStreamedComponents.set(componentKey, true);
+          if (this.lastStreamedComponents.size > _IncrementalStreamParser.MAX_STREAMED_SIZE) {
+            const firstKey = this.lastStreamedComponents.keys().next().value;
+            if (firstKey) {
+              this.lastStreamedComponents.delete(firstKey);
+            }
+          }
+          this.componentSnapshots.delete(componentKey);
+        }
+      }
+    }
+    if (this.buffer) {
       const part = {
         kind: "text",
-        text: this.buffer.trim()
+        text: this.buffer
       };
       await this.streamPart(part);
     }
-    if (this.pendingTextBuffer.trim()) {
-      const cleanedText = this.pendingTextBuffer.replace(/<\/?artifact:ref(?:\s[^>]*)?>\/?>/g, "").replace(/<\/?artifact(?:\s[^>]*)?>\/?>/g, "").replace(/<\/(?:\w+:)?artifact>/g, "").trim();
+    if (this.pendingTextBuffer) {
+      const cleanedText = this.pendingTextBuffer.replace(/<\/?artifact:ref(?:\s[^>]*)?>\/?>/g, "").replace(/<\/?artifact(?:\s[^>]*)?>\/?>/g, "").replace(/<\/(?:\w+:)?artifact>/g, "");
       if (cleanedText) {
         this.collectedParts.push({
           kind: "text",
@@ -2879,6 +2957,9 @@ var IncrementalStreamParser = class {
       }
       this.pendingTextBuffer = "";
     }
+    this.componentSnapshots.clear();
+    this.lastStreamedComponents.clear();
+    this.componentAccumulator = {};
   }
   /**
    * Get all collected parts for building the final response
@@ -2925,30 +3006,6 @@ var IncrementalStreamParser = class {
       remainingBuffer: ""
     };
   }
-  /**
-   * Parse buffer for complete JSON objects with artifact references (for object streaming)
-   */
-  async parseObjectBuffer() {
-    const completeParts = [];
-    try {
-      const parsed = JSON.parse(this.buffer);
-      const parts = await this.artifactParser.parseObject(parsed);
-      return {
-        completeParts: parts,
-        remainingBuffer: ""
-      };
-    } catch {
-      const { complete, remaining } = this.artifactParser.parsePartialJSON(this.buffer);
-      for (const obj of complete) {
-        const parts = await this.artifactParser.parseObject(obj);
-        completeParts.push(...parts);
-      }
-      return {
-        completeParts,
-        remainingBuffer: remaining
-      };
-    }
-  }
   /**
    * Check if text might be the start of an artifact marker
    */
@@ -2969,7 +3026,7 @@ var IncrementalStreamParser = class {
       this.pendingTextBuffer += part.text;
       if (!this.artifactParser.hasIncompleteArtifact(this.pendingTextBuffer)) {
         const cleanedText = this.pendingTextBuffer.replace(/<\/?artifact:ref(?:\s[^>]*)?>\/?>/g, "").replace(/<\/?artifact(?:\s[^>]*)?>\/?>/g, "").replace(/<\/(?:\w+:)?artifact>/g, "");
-        if (cleanedText.trim()) {
+        if (cleanedText) {
           await this.streamHelper.streamText(cleanedText, 50);
         }
         this.pendingTextBuffer = "";
@@ -2977,7 +3034,7 @@ var IncrementalStreamParser = class {
     } else if (part.kind === "data" && part.data) {
       if (this.pendingTextBuffer) {
         const cleanedText = this.pendingTextBuffer.replace(/<\/?artifact:ref(?:\s[^>]*)?>\/?>/g, "").replace(/<\/?artifact(?:\s[^>]*)?>\/?>/g, "").replace(/<\/(?:\w+:)?artifact>/g, "");
-        if (cleanedText.trim()) {
+        if (cleanedText) {
           await this.streamHelper.streamText(cleanedText, 50);
         }
         this.pendingTextBuffer = "";
@@ -2991,6 +3048,11 @@ var IncrementalStreamParser = class {
     }
   }
 };
+// Memory management constants
+__publicField(_IncrementalStreamParser, "MAX_SNAPSHOT_SIZE", 100);
+// Max number of snapshots to keep
+__publicField(_IncrementalStreamParser, "MAX_STREAMED_SIZE", 1e3);
+var IncrementalStreamParser = _IncrementalStreamParser;
 
 // src/utils/response-formatter.ts
 var logger9 = getLogger("ResponseFormatter");
@@ -4377,7 +4439,8 @@ function createDelegateToAgentTool({
         const externalAgent = await getExternalAgent(dbClient_default)({
           scopes: {
             tenantId,
-            projectId
+            projectId,
+            graphId
           },
           agentId: delegateConfig.config.id
         });
@@ -4979,6 +5042,23 @@ var Agent = class {
     __publicField(this, "credentialStoreRegistry");
     this.artifactComponents = config.artifactComponents || [];
     let processedDataComponents = config.dataComponents || [];
+    if (processedDataComponents.length > 0) {
+      processedDataComponents.push({
+        id: "text-content",
+        name: "Text",
+        description: "Natural conversational text for the user - write naturally without mentioning technical details. Avoid redundancy and repetition with data components.",
+        props: {
+          type: "object",
+          properties: {
+            text: {
+              type: "string",
+              description: "Natural conversational text - respond as if having a normal conversation, never mention JSON, components, schemas, or technical implementation. Avoid redundancy and repetition with data components."
+            }
+          },
+          required: ["text"]
+        }
+      });
+    }
     if (this.artifactComponents.length > 0 && config.dataComponents && config.dataComponents.length > 0) {
       processedDataComponents = [
         ArtifactReferenceSchema.getDataComponent(config.tenantId, config.projectId),
@@ -5249,8 +5329,12 @@ var Agent = class {
   async getMcpTool(tool4) {
     const credentialReferenceId = tool4.credentialReferenceId;
     const toolsForAgent = await getToolsForAgent(dbClient_default)({
-      scopes: { tenantId: this.config.tenantId, projectId: this.config.projectId },
-      agentId: this.config.id
+      scopes: {
+        tenantId: this.config.tenantId,
+        projectId: this.config.projectId,
+        graphId: this.config.graphId,
+        agentId: this.config.id
+      }
     });
     const selectedTools = toolsForAgent.data.find((t) => t.toolId === tool4.id)?.selectedTools || void 0;
     let serverConfig;
@@ -5397,9 +5481,9 @@ var Agent = class {
       const graphDefinition = await getFullGraphDefinition(dbClient_default)({
         scopes: {
           tenantId: this.config.tenantId,
-          projectId: this.config.projectId
-        },
-        graphId: this.config.graphId
+          projectId: this.config.projectId,
+          graphId: this.config.graphId
+        }
       });
       return graphDefinition?.graphPrompt || void 0;
     } catch (error) {
@@ -5421,14 +5505,16 @@ var Agent = class {
       const graphDefinition = await getFullGraphDefinition(dbClient_default)({
         scopes: {
           tenantId: this.config.tenantId,
-          projectId: this.config.projectId
-        },
-        graphId: this.config.graphId
+          projectId: this.config.projectId,
+          graphId: this.config.graphId
+        }
       });
       if (!graphDefinition) {
         return false;
       }
-      return !!(graphDefinition.artifactComponents && Object.keys(graphDefinition.artifactComponents).length > 0);
+      return Object.values(graphDefinition.agents).some(
+        (agent) => "artifactComponents" in agent && agent.artifactComponents && agent.artifactComponents.length > 0
+      );
     } catch (error) {
       logger15.warn(
         {
@@ -5456,7 +5542,8 @@ Key requirements:
 - Mix artifact references throughout your dataComponents array
 - Each artifact reference must use EXACT IDs from tool outputs
 - Reference artifacts that directly support the adjacent information
-- Follow the pattern: Data \u2192 Supporting Artifact \u2192 Next Data \u2192 Next Artifact`;
+- Follow the pattern: Data \u2192 Supporting Artifact \u2192 Next Data \u2192 Next Artifact
+- IMPORTANT: In Text components, write naturally as if having a conversation - do NOT mention components, schemas, JSON, structured data, or any technical implementation details`;
     }
     if (hasDataComponents && !hasArtifactComponents) {
       return `Generate the final structured JSON response using the configured data components. Organize the information from the research above into the appropriate structured format based on the available component schemas.
@@ -5464,7 +5551,8 @@ Key requirements:
 Key requirements:
 - Use the exact component structure and property names
 - Fill in all relevant data from the research
-- Ensure data is organized logically and completely`;
+- Ensure data is organized logically and completely
+- IMPORTANT: In Text components, write naturally as if having a conversation - do NOT mention components, schemas, JSON, structured data, or any technical implementation details`;
     }
     if (!hasDataComponents && hasArtifactComponents) {
       return `Generate the final structured response with artifact references based on the research above. Use the artifact reference component to cite relevant information with exact artifact_id and task_id values from the tool outputs.
@@ -5474,7 +5562,7 @@ Key requirements:
 - Reference artifacts that support your response
 - Never make up or modify artifact IDs`;
     }
-    return `Generate the final response based on the research above.`;
+    return `Generate the final response based on the research above. Write naturally as if having a conversation.`;
   }
   async buildSystemPrompt(runtimeContext, excludeDataComponents = false) {
     const conversationId = runtimeContext?.metadata?.conversationId || runtimeContext?.contextId;
@@ -5625,9 +5713,9 @@ Key requirements:
       return await graphHasArtifactComponents(dbClient_default)({
         scopes: {
           tenantId: this.config.tenantId,
-          projectId: this.config.projectId
-        },
-        graphId: this.config.graphId
+          projectId: this.config.projectId,
+          graphId: this.config.graphId
+        }
       });
     } catch (error) {
       logger15.error(
@@ -5973,35 +6061,94 @@ ${output}`;
               this.getStructuredOutputModel()
             );
             const phase2TimeoutMs = structuredModelSettings.maxDuration ? structuredModelSettings.maxDuration * 1e3 : CONSTANTS.PHASE_2_TIMEOUT_MS;
-            const structuredResponse = await generateObject({
-              ...structuredModelSettings,
-              messages: [
-                { role: "user", content: userMessage },
-                ...reasoningFlow,
-                {
-                  role: "user",
-                  content: await this.buildPhase2SystemPrompt()
-                }
-              ],
-              schema: z.object({
-                dataComponents: z.array(dataComponentsSchema)
-              }),
-              experimental_telemetry: {
-                isEnabled: true,
-                functionId: this.config.id,
-                recordInputs: true,
-                recordOutputs: true,
-                metadata: {
-                  phase: "structured_generation"
+            const shouldStreamPhase2 = this.getStreamingHelper();
+            if (shouldStreamPhase2) {
+              const streamResult = streamObject({
+                ...structuredModelSettings,
+                messages: [
+                  { role: "user", content: userMessage },
+                  ...reasoningFlow,
+                  {
+                    role: "user",
+                    content: await this.buildPhase2SystemPrompt()
+                  }
+                ],
+                schema: z.object({
+                  dataComponents: z.array(dataComponentsSchema)
+                }),
+                experimental_telemetry: {
+                  isEnabled: true,
+                  functionId: this.config.id,
+                  recordInputs: true,
+                  recordOutputs: true,
+                  metadata: {
+                    phase: "structured_generation"
+                  }
+                },
+                abortSignal: AbortSignal.timeout(phase2TimeoutMs)
+              });
+              const streamHelper = this.getStreamingHelper();
+              if (!streamHelper) {
+                throw new Error("Stream helper is unexpectedly undefined in streaming context");
+              }
+              const parser = new IncrementalStreamParser(
+                streamHelper,
+                this.config.tenantId,
+                contextId
+              );
+              for await (const delta of streamResult.partialObjectStream) {
+                if (delta) {
+                  await parser.processObjectDelta(delta);
                 }
-              },
-              abortSignal: AbortSignal.timeout(phase2TimeoutMs)
-            });
-            response = {
-              ...response,
-              object: structuredResponse.object
-            };
-            textResponse = JSON.stringify(structuredResponse.object, null, 2);
+              }
+              await parser.finalize();
+              const structuredResponse = await streamResult;
+              const collectedParts = parser.getCollectedParts();
+              if (collectedParts.length > 0) {
+                response.formattedContent = {
+                  parts: collectedParts.map((part) => ({
+                    kind: part.kind,
+                    ...part.kind === "text" && { text: part.text },
+                    ...part.kind === "data" && { data: part.data }
+                  }))
+                };
+              }
+              response = {
+                ...response,
+                object: structuredResponse.object
+              };
+              textResponse = JSON.stringify(structuredResponse.object, null, 2);
+            } else {
+              const structuredResponse = await generateObject({
+                ...structuredModelSettings,
+                messages: [
+                  { role: "user", content: userMessage },
+                  ...reasoningFlow,
+                  {
+                    role: "user",
+                    content: await this.buildPhase2SystemPrompt()
+                  }
+                ],
+                schema: z.object({
+                  dataComponents: z.array(dataComponentsSchema)
+                }),
+                experimental_telemetry: {
+                  isEnabled: true,
+                  functionId: this.config.id,
+                  recordInputs: true,
+                  recordOutputs: true,
+                  metadata: {
+                    phase: "structured_generation"
+                  }
+                },
+                abortSignal: AbortSignal.timeout(phase2TimeoutMs)
+              });
+              response = {
+                ...response,
+                object: structuredResponse.object
+              };
+              textResponse = JSON.stringify(structuredResponse.object, null, 2);
+            }
           } else {
             textResponse = response.text || "";
           }
@@ -6046,39 +6193,6 @@ ${output}`;
     });
   }
 };
-async function resolveModelConfig(graphId, agent) {
-  if (agent.models?.base?.model) {
-    return {
-      base: agent.models.base,
-      structuredOutput: agent.models.structuredOutput || agent.models.base,
-      summarizer: agent.models.summarizer || agent.models.base
-    };
-  }
-  const graph = await getAgentGraph(dbClient_default)({
-    scopes: { tenantId: agent.tenantId, projectId: agent.projectId },
-    graphId
-  });
-  if (graph?.models?.base?.model) {
-    return {
-      base: graph.models.base,
-      structuredOutput: agent.models?.structuredOutput || graph.models.structuredOutput || graph.models.base,
-      summarizer: agent.models?.summarizer || graph.models.summarizer || graph.models.base
-    };
-  }
-  const project = await getProject(dbClient_default)({
-    scopes: { tenantId: agent.tenantId, projectId: agent.projectId }
-  });
-  if (project?.models?.base?.model) {
-    return {
-      base: project.models.base,
-      structuredOutput: agent.models?.structuredOutput || project.models.structuredOutput || project.models.base,
-      summarizer: agent.models?.summarizer || project.models.summarizer || project.models.base
-    };
-  }
-  throw new Error(
-    "Base model configuration is required. Please configure models at the project level."
-  );
-}
 
 // src/agents/generateTaskHandler.ts
 function parseEmbeddedJson(data) {
@@ -6114,31 +6228,34 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
         getRelatedAgentsForGraph(dbClient_default)({
           scopes: {
             tenantId: config.tenantId,
-            projectId: config.projectId
+            projectId: config.projectId,
+            graphId: config.graphId
           },
-          graphId: config.graphId,
           agentId: config.agentId
         }),
         getToolsForAgent(dbClient_default)({
           scopes: {
             tenantId: config.tenantId,
-            projectId: config.projectId
-          },
-          agentId: config.agentId
+            projectId: config.projectId,
+            graphId: config.graphId,
+            agentId: config.agentId
+          }
         }),
         getDataComponentsForAgent(dbClient_default)({
           scopes: {
             tenantId: config.tenantId,
-            projectId: config.projectId
-          },
-          agentId: config.agentId
+            projectId: config.projectId,
+            graphId: config.graphId,
+            agentId: config.agentId
+          }
         }),
         getArtifactComponentsForAgent(dbClient_default)({
           scopes: {
             tenantId: config.tenantId,
-            projectId: config.projectId
-          },
-          agentId: config.agentId
+            projectId: config.projectId,
+            graphId: config.graphId,
+            agentId: config.agentId
+          }
         })
       ]);
       logger16.info({ toolsForAgent, internalRelations, externalRelations }, "agent stuff");
@@ -6146,13 +6263,16 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
         internalRelations.map(async (relation) => {
           try {
             const relatedAgent = await getAgentById(dbClient_default)({
-              scopes: { tenantId: config.tenantId, projectId: config.projectId },
+              scopes: {
+                tenantId: config.tenantId,
+                projectId: config.projectId,
+                graphId: config.graphId
+              },
               agentId: relation.id
             });
             if (relatedAgent) {
               const relatedAgentRelations = await getRelatedAgentsForGraph(dbClient_default)({
-                scopes: { tenantId: config.tenantId, projectId: config.projectId },
-                graphId: config.graphId,
+                scopes: { tenantId: config.tenantId, projectId: config.projectId, graphId: config.graphId },
                 agentId: relation.id
               });
               const enhancedDescription = generateDescriptionWithTransfers(
@@ -6375,16 +6495,17 @@ var createTaskHandlerConfig = async (params) => {
   const agent = await getAgentById(dbClient_default)({
     scopes: {
       tenantId: params.tenantId,
-      projectId: params.projectId
+      projectId: params.projectId,
+      graphId: params.graphId
     },
     agentId: params.agentId
   });
-  const agentGraph = await getAgentGraph(dbClient_default)({
+  const agentGraph = await getAgentGraphById(dbClient_default)({
     scopes: {
       tenantId: params.tenantId,
-      projectId: params.projectId
-    },
-    graphId: params.graphId
+      projectId: params.projectId,
+      graphId: params.graphId
+    }
   });
   if (!agent) {
     throw new Error(`Agent not found: ${params.agentId}`);
@@ -6423,10 +6544,14 @@ async function hydrateGraph({
   apiKey
 }) {
   try {
+    if (!dbGraph.defaultAgentId) {
+      throw new Error(`Graph ${dbGraph.id} does not have a default agent configured`);
+    }
     const defaultAgent = await getAgentById(dbClient_default)({
       scopes: {
         tenantId: dbGraph.tenantId,
-        projectId: dbGraph.projectId
+        projectId: dbGraph.projectId,
+        graphId: dbGraph.id
       },
       agentId: dbGraph.defaultAgentId
     });
@@ -6481,7 +6606,7 @@ async function hydrateGraph({
 }
 async function getRegisteredGraph(executionContext) {
   const { tenantId, projectId, graphId, baseUrl, apiKey } = executionContext;
-  const dbGraph = await getAgentGraph(dbClient_default)({ scopes: { tenantId, projectId }, graphId });
+  const dbGraph = await getAgentGraphById(dbClient_default)({ scopes: { tenantId, projectId, graphId } });
   if (!dbGraph) {
     return null;
   }
@@ -6539,6 +6664,7 @@ app.openapi(
     );
     const executionContext = getRequestExecutionContext(c);
     const { tenantId, projectId, graphId, agentId } = executionContext;
+    console.dir("executionContext", executionContext);
     if (agentId) {
       logger17.info(
         {
@@ -6626,8 +6752,7 @@ app.post("/a2a", async (c) => {
       "graph-level a2a endpoint"
     );
     const graph = await getAgentGraphWithDefaultAgent(dbClient_default)({
-      scopes: { tenantId, projectId },
-      graphId
+      scopes: { tenantId, projectId, graphId }
     });
     if (!graph) {
       return c.json(
@@ -6639,6 +6764,16 @@ app.post("/a2a", async (c) => {
         404
       );
     }
+    if (!graph.defaultAgentId) {
+      return c.json(
+        {
+          jsonrpc: "2.0",
+          error: { code: -32004, message: "Graph does not have a default agent configured" },
+          id: null
+        },
+        400
+      );
+    }
     executionContext.agentId = graph.defaultAgentId;
     const credentialStores = c.get("credentialStores");
     const defaultAgent = await getRegisteredAgent(executionContext, credentialStores);
@@ -6683,7 +6818,7 @@ var SSEStreamHelper = class {
     this.timestamp = timestamp;
     // Stream queuing for proper event ordering
     __publicField(this, "isTextStreaming", false);
-    __publicField(this, "queuedOperations", []);
+    __publicField(this, "queuedEvents", []);
   }
   /**
    * Write the initial role message
@@ -6748,9 +6883,10 @@ var SSEStreamHelper = class {
     await this.writeContent(JSON.stringify(data));
   }
   /**
-   * Write error message
+   * Write error message or error event
    */
-  async writeError(errorMessage) {
+  async writeError(error) {
+    const errorMessage = typeof error === "string" ? error : error.message;
     await this.writeContent(`
 
 ${errorMessage}`);
@@ -6774,22 +6910,6 @@ ${errorMessage}`);
       })
     });
   }
-  /**
-   * Write the final [DONE] message
-   */
-  async writeDone() {
-    await this.stream.writeSSE({
-      data: "[DONE]"
-    });
-  }
-  /**
-   * Complete the stream with finish reason and done message
-   */
-  async complete(finishReason = "stop") {
-    await this.flushQueuedOperations();
-    await this.writeCompletion(finishReason);
-    await this.writeDone();
-  }
   async writeData(type, data) {
     await this.stream.writeSSE({
       data: JSON.stringify({
@@ -6808,16 +6928,23 @@ ${errorMessage}`);
       })
     });
   }
-  async writeOperation(operation) {
-    if (operation.type === "status_update" && operation.ctx.label) {
-      operation = {
-        type: operation.type,
-        label: operation.ctx.label,
-        ctx: operation.ctx.data
-      };
+  async writeSummary(summary) {
+    if (this.isTextStreaming) {
+      this.queuedEvents.push({
+        type: "data-summary",
+        event: summary
+      });
+      return;
     }
+    await this.flushQueuedOperations();
+    await this.writeData("data-summary", summary);
+  }
+  async writeOperation(operation) {
     if (this.isTextStreaming) {
-      this.queuedOperations.push(operation);
+      this.queuedEvents.push({
+        type: "data-operation",
+        event: operation
+      });
       return;
     }
     await this.flushQueuedOperations();
@@ -6827,15 +6954,31 @@ ${errorMessage}`);
    * Flush all queued operations in order after text streaming completes
    */
   async flushQueuedOperations() {
-    if (this.queuedOperations.length === 0) {
+    if (this.queuedEvents.length === 0) {
       return;
     }
-    const operationsToFlush = [...this.queuedOperations];
-    this.queuedOperations = [];
-    for (const operation of operationsToFlush) {
-      await this.writeData("data-operation", operation);
+    const eventsToFlush = [...this.queuedEvents];
+    this.queuedEvents = [];
+    for (const event of eventsToFlush) {
+      await this.writeData(event.type, event.event);
     }
   }
+  /**
+   * Write the final [DONE] message
+   */
+  async writeDone() {
+    await this.stream.writeSSE({
+      data: "[DONE]"
+    });
+  }
+  /**
+   * Complete the stream with finish reason and done message
+   */
+  async complete(finishReason = "stop") {
+    await this.flushQueuedOperations();
+    await this.writeCompletion(finishReason);
+    await this.writeDone();
+  }
 };
 function createSSEStreamHelper(stream2, requestId2, timestamp) {
   return new SSEStreamHelper(stream2, requestId2, timestamp);
@@ -6855,7 +6998,7 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
     __publicField(this, "isCompleted", false);
     // Stream queuing for proper event ordering
     __publicField(this, "isTextStreaming", false);
-    __publicField(this, "queuedOperations", []);
+    __publicField(this, "queuedEvents", []);
     // Timing tracking for text sequences (text-end to text-start gap)
     __publicField(this, "lastTextEndTimestamp", 0);
     __publicField(this, "TEXT_GAP_THRESHOLD", 50);
@@ -6967,15 +7110,24 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
       data
     });
   }
-  async writeError(errorMessage) {
+  async writeError(error) {
     if (this.isCompleted) {
       console.warn("Attempted to write error to completed stream");
       return;
     }
-    this.writer.write({
-      type: "error",
-      errorText: errorMessage
-    });
+    if (typeof error === "string") {
+      this.writer.write({
+        type: "error",
+        message: error,
+        severity: "error",
+        timestamp: Date.now()
+      });
+    } else {
+      this.writer.write({
+        ...error,
+        type: "error"
+      });
+    }
   }
   async streamData(data) {
     await this.writeContent(JSON.stringify(data));
@@ -6987,20 +7139,6 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
     }
     this.writer.merge(stream2);
   }
-  async writeCompletion(_finishReason = "stop") {
-  }
-  async writeDone() {
-  }
-  /**
-   * Complete the stream and clean up all memory
-   * This is the primary cleanup point to prevent memory leaks between requests
-   */
-  async complete() {
-    if (this.isCompleted) return;
-    await this.flushQueuedOperations();
-    this.isCompleted = true;
-    this.cleanup();
-  }
   /**
    * Clean up all memory allocations
    * Should be called when the stream helper is no longer needed
@@ -7014,7 +7152,7 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
     this.sentItems.clear();
     this.completedItems.clear();
     this.textId = null;
-    this.queuedOperations = [];
+    this.queuedEvents = [];
     this.isTextStreaming = false;
   }
   /**
@@ -7080,7 +7218,9 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
       if (this.writer && !this.isCompleted) {
         this.writer.write({
           type: "error",
-          errorText: `Stream terminated: ${reason}`
+          message: `Stream terminated: ${reason}`,
+          severity: "error",
+          timestamp: Date.now()
         });
       }
     } catch (e) {
@@ -7103,23 +7243,33 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
       isCompleted: this.isCompleted
     };
   }
+  async writeSummary(summary) {
+    if (this.isCompleted) {
+      console.warn("Attempted to write summary to completed stream");
+      return;
+    }
+    const now = Date.now();
+    const gapFromLastTextEnd = this.lastTextEndTimestamp > 0 ? now - this.lastTextEndTimestamp : Number.MAX_SAFE_INTEGER;
+    if (this.isTextStreaming || gapFromLastTextEnd < this.TEXT_GAP_THRESHOLD) {
+      this.queuedEvents.push({ type: "data-summary", event: summary });
+      return;
+    }
+    await this.flushQueuedOperations();
+    await this.writer.write({
+      id: "id" in summary ? summary.id : void 0,
+      type: "data-summary",
+      data: summary
+    });
+  }
   async writeOperation(operation) {
     if (this.isCompleted) {
       console.warn("Attempted to write operation to completed stream");
       return;
     }
-    if (operation.type === "status_update" && operation.ctx.label) {
-      operation = {
-        type: operation.type,
-        label: operation.ctx.label,
-        // Preserve the label for the UI
-        ctx: operation.ctx.data
-      };
-    }
     const now = Date.now();
     const gapFromLastTextEnd = this.lastTextEndTimestamp > 0 ? now - this.lastTextEndTimestamp : Number.MAX_SAFE_INTEGER;
     if (this.isTextStreaming || gapFromLastTextEnd < this.TEXT_GAP_THRESHOLD) {
-      this.queuedOperations.push(operation);
+      this.queuedEvents.push({ type: "data-operation", event: operation });
       return;
     }
     await this.flushQueuedOperations();
@@ -7133,19 +7283,33 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
    * Flush all queued operations in order after text streaming completes
    */
   async flushQueuedOperations() {
-    if (this.queuedOperations.length === 0) {
+    if (this.queuedEvents.length === 0) {
       return;
     }
-    const operationsToFlush = [...this.queuedOperations];
-    this.queuedOperations = [];
-    for (const operation of operationsToFlush) {
+    const eventsToFlush = [...this.queuedEvents];
+    this.queuedEvents = [];
+    for (const event of eventsToFlush) {
       this.writer.write({
-        id: "id" in operation ? operation.id : void 0,
-        type: "data-operation",
-        data: operation
+        id: "id" in event.event ? event.event.id : void 0,
+        type: event.type,
+        data: event.event
       });
     }
   }
+  async writeCompletion(_finishReason = "stop") {
+  }
+  async writeDone() {
+  }
+  /**
+   * Complete the stream and clean up all memory
+   * This is the primary cleanup point to prevent memory leaks between requests
+   */
+  async complete() {
+    if (this.isCompleted) return;
+    await this.flushQueuedOperations();
+    this.isCompleted = true;
+    this.cleanup();
+  }
 };
 // Memory management - focused on connection completion cleanup
 __publicField(_VercelDataStreamHelper, "MAX_BUFFER_SIZE", 5 * 1024 * 1024);
@@ -7158,6 +7322,7 @@ var MCPStreamHelper = class {
     __publicField(this, "capturedText", "");
     __publicField(this, "capturedData", []);
     __publicField(this, "capturedOperations", []);
+    __publicField(this, "capturedSummaries", []);
     __publicField(this, "hasError", false);
     __publicField(this, "errorMessage", "");
     __publicField(this, "sessionId");
@@ -7176,18 +7341,27 @@ var MCPStreamHelper = class {
   async streamData(data) {
     this.capturedData.push(data);
   }
+  async streamSummary(summary) {
+    this.capturedSummaries.push(summary);
+  }
+  async streamOperation(operation) {
+    this.capturedOperations.push(operation);
+  }
   async writeData(_type, data) {
     this.capturedData.push(data);
   }
-  async writeError(errorMessage) {
-    this.hasError = true;
-    this.errorMessage = errorMessage;
-  }
-  async complete() {
+  async writeSummary(summary) {
+    this.capturedSummaries.push(summary);
   }
   async writeOperation(operation) {
     this.capturedOperations.push(operation);
   }
+  async writeError(error) {
+    this.hasError = true;
+    this.errorMessage = typeof error === "string" ? error : error.message;
+  }
+  async complete() {
+  }
   /**
    * Get the captured response for MCP tool result
    */
@@ -7204,6 +7378,8 @@ var MCPStreamHelper = class {
 function createMCPStreamHelper() {
   return new MCPStreamHelper();
 }
+
+// src/handlers/executionHandler.ts
 var logger19 = getLogger("ExecutionHandler");
 var ExecutionHandler = class {
   constructor() {
@@ -7232,7 +7408,7 @@ var ExecutionHandler = class {
     logger19.info({ sessionId: requestId2, graphId }, "Created GraphSession for message execution");
     let graphConfig = null;
     try {
-      graphConfig = await getFullGraph(dbClient_default)({ scopes: { tenantId, projectId }, graphId });
+      graphConfig = await getFullGraph(dbClient_default)({ scopes: { tenantId, projectId, graphId } });
       if (graphConfig?.statusUpdates && graphConfig.statusUpdates.enabled !== false) {
         graphSessionManager.initializeStatusUpdates(
           requestId2,
@@ -7386,7 +7562,6 @@ var ExecutionHandler = class {
           if (errorCount >= this.MAX_ERRORS) {
             const errorMessage2 = `Maximum error limit (${this.MAX_ERRORS}) reached`;
             logger19.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
-            await sseHelper.writeError(errorMessage2);
             await sseHelper.writeOperation(errorOp(errorMessage2, currentAgentId || "system"));
             if (task) {
               await updateTask(dbClient_default)({
@@ -7527,7 +7702,6 @@ var ExecutionHandler = class {
         if (errorCount >= this.MAX_ERRORS) {
           const errorMessage2 = `Maximum error limit (${this.MAX_ERRORS}) reached`;
           logger19.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
-          await sseHelper.writeError(errorMessage2);
           await sseHelper.writeOperation(errorOp(errorMessage2, currentAgentId || "system"));
           if (task) {
             await updateTask(dbClient_default)({
@@ -7549,7 +7723,6 @@ var ExecutionHandler = class {
       }
       const errorMessage = `Maximum transfer limit (${maxTransfers}) reached without completion`;
       logger19.error({ maxTransfers, iterations }, errorMessage);
-      await sseHelper.writeError(errorMessage);
       await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || "system"));
       if (task) {
         await updateTask(dbClient_default)({
@@ -7570,8 +7743,7 @@ var ExecutionHandler = class {
     } catch (error) {
       logger19.error({ error }, "Error in execution handler");
       const errorMessage = error instanceof Error ? error.message : "Unknown execution error";
-      await sseHelper.writeError(`Execution error: ${errorMessage}`);
-      await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || "system"));
+      await sseHelper.writeOperation(errorOp(`Execution error: ${errorMessage}`, currentAgentId || "system"));
       if (task) {
         await updateTask(dbClient_default)({
           taskId: task.id,
@@ -7733,8 +7905,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
     const body = c.get("requestBody") || {};
     const conversationId = body.conversationId || nanoid();
     const fullGraph = await getFullGraph(dbClient_default)({
-      scopes: { tenantId, projectId },
-      graphId
+      scopes: { tenantId, projectId, graphId }
     });
     let agentGraph;
     let defaultAgentId;
@@ -7751,8 +7922,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
       defaultAgentId = fullGraph.defaultAgentId || firstAgentId;
     } else {
       agentGraph = await getAgentGraphWithDefaultAgent(dbClient_default)({
-        scopes: { tenantId, projectId },
-        graphId
+        scopes: { tenantId, projectId, graphId }
       });
       if (!agentGraph) {
         return c.json({ error: "Agent graph not found" }, 404);
@@ -7781,7 +7951,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
     }
     const agentId = activeAgent?.activeAgentId || defaultAgentId;
     const agentInfo = await getAgentById(dbClient_default)({
-      scopes: { tenantId, projectId },
+      scopes: { tenantId, projectId, graphId },
       agentId
     });
     if (!agentInfo) {
@@ -7789,18 +7959,19 @@ app2.openapi(chatCompletionsRoute, async (c) => {
     }
     const validatedContext = c.get("validatedContext") || body.requestContext || {};
     const credentialStores = c.get("credentialStores");
-    await handleContextResolution(
+    await handleContextResolution({
       tenantId,
       projectId,
-      conversationId,
       graphId,
-      validatedContext,
-      dbClient_default,
+      conversationId,
+      requestContext: validatedContext,
+      dbClient: dbClient_default,
       credentialStores
-    );
+    });
     logger20.info(
       {
         tenantId,
+        projectId,
         graphId,
         conversationId,
         defaultAgentId,
@@ -7859,8 +8030,8 @@ app2.openapi(chatCompletionsRoute, async (c) => {
         `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
       );
       if (!result.success) {
-        await sseHelper.writeError(
-          "Sorry, I was unable to process your request at this time. Please try again."
+        await sseHelper.writeOperation(
+          errorOp("Sorry, I was unable to process your request at this time. Please try again.", "system")
         );
       }
       await sseHelper.complete();
@@ -7940,6 +8111,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
   try {
     const executionContext = getRequestExecutionContext(c);
     const { tenantId, projectId, graphId } = executionContext;
+    loggerFactory.getLogger("chatDataStream").debug({ tenantId, projectId, graphId }, "Extracted chatDataStream parameters");
     const body = c.get("requestBody") || {};
     const conversationId = body.conversationId || nanoid();
     const activeSpan = trace.getActiveSpan();
@@ -7952,14 +8124,16 @@ app3.openapi(chatDataStreamRoute, async (c) => {
       });
     }
     const agentGraph = await getAgentGraphWithDefaultAgent(dbClient_default)({
-      scopes: { tenantId, projectId },
-      graphId
+      scopes: { tenantId, projectId, graphId }
     });
     if (!agentGraph) {
       return c.json({ error: "Agent graph not found" }, 404);
     }
     const defaultAgentId = agentGraph.defaultAgentId;
     const graphName = agentGraph.name;
+    if (!defaultAgentId) {
+      return c.json({ error: "Graph does not have a default agent configured" }, 400);
+    }
     const activeAgent = await getActiveAgentForConversation(dbClient_default)({
       scopes: { tenantId, projectId },
       conversationId
@@ -7973,7 +8147,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
     }
     const agentId = activeAgent?.activeAgentId || defaultAgentId;
     const agentInfo = await getAgentById(dbClient_default)({
-      scopes: { tenantId, projectId },
+      scopes: { tenantId, projectId, graphId },
       agentId
     });
     if (!agentInfo) {
@@ -7981,15 +8155,15 @@ app3.openapi(chatDataStreamRoute, async (c) => {
     }
     const validatedContext = c.get("validatedContext") || body.requestContext || {};
     const credentialStores = c.get("credentialStores");
-    await handleContextResolution(
+    await handleContextResolution({
       tenantId,
       projectId,
-      conversationId,
       graphId,
-      validatedContext,
-      dbClient_default,
+      conversationId,
+      requestContext: validatedContext,
+      dbClient: dbClient_default,
       credentialStores
-    );
+    });
     const lastUserMessage = body.messages.filter((m) => m.role === "user").slice(-1)[0];
     const userText = typeof lastUserMessage?.content === "string" ? lastUserMessage.content : lastUserMessage?.parts?.map((p) => p.text).join("") || "";
     logger21.info({ userText, lastUserMessage }, "userText");
@@ -8031,11 +8205,11 @@ app3.openapi(chatDataStreamRoute, async (c) => {
             sseHelper: streamHelper
           });
           if (!result.success) {
-            await streamHelper.writeError("Unable to process request");
+            await streamHelper.writeOperation(errorOp("Unable to process request", "system"));
           }
         } catch (err) {
           logger21.error({ err }, "Streaming error");
-          await streamHelper.writeError("Internal server error");
+          await streamHelper.writeOperation(errorOp("Internal server error", "system"));
         } finally {
           if ("cleanup" in streamHelper && typeof streamHelper.cleanup === "function") {
             streamHelper.cleanup();
@@ -8258,8 +8432,7 @@ var getServer = async (requestContext, executionContext, conversationId, credent
   const { tenantId, projectId, graphId } = executionContext;
   setupTracing(conversationId, tenantId, graphId);
   const agentGraph = await getAgentGraphWithDefaultAgent(dbClient_default)({
-    scopes: { tenantId, projectId },
-    graphId
+    scopes: { tenantId, projectId, graphId }
   });
   if (!agentGraph) {
     throw new Error("Agent graph not found");
@@ -8279,9 +8452,20 @@ var getServer = async (requestContext, executionContext, conversationId, credent
     },
     async ({ query }) => {
       try {
+        if (!agentGraph.defaultAgentId) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Graph does not have a default agent configured`
+              }
+            ],
+            isError: true
+          };
+        }
         const defaultAgentId = agentGraph.defaultAgentId;
         const agentInfo = await getAgentById(dbClient_default)({
-          scopes: { tenantId, projectId },
+          scopes: { tenantId, projectId, graphId },
           agentId: defaultAgentId
         });
         if (!agentInfo) {
@@ -8295,18 +8479,19 @@ var getServer = async (requestContext, executionContext, conversationId, credent
             isError: true
           };
         }
-        const resolvedContext = await handleContextResolution(
+        const resolvedContext = await handleContextResolution({
           tenantId,
           projectId,
-          conversationId,
           graphId,
+          conversationId,
           requestContext,
-          dbClient_default,
+          dbClient: dbClient_default,
           credentialStores
-        );
+        });
         logger22.info(
           {
             tenantId,
+            projectId,
             graphId,
             conversationId,
             hasContextConfig: !!agentGraph.contextConfigId,
@@ -8368,8 +8553,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
   logger22.info({ body }, "Received initialization request");
   const sessionId = nanoid();
   const agentGraph = await getAgentGraphWithDefaultAgent(dbClient_default)({
-    scopes: { tenantId, projectId },
-    graphId
+    scopes: { tenantId, projectId, graphId }
   });
   if (!agentGraph) {
     return c.json(
@@ -8381,6 +8565,16 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
       { status: 404 }
     );
   }
+  if (!agentGraph.defaultAgentId) {
+    return c.json(
+      {
+        jsonrpc: "2.0",
+        error: { code: -32001, message: "Graph does not have a default agent configured" },
+        id: body.id || null
+      },
+      { status: 400 }
+    );
+  }
   const conversation = await createOrGetConversation(dbClient_default)({
     id: sessionId,
     tenantId,