@inkeep/agents-run-api 0.0.0-dev-20250917205552 → 0.0.0-dev-20250919020857

package/dist/index.js

@@ -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';
@@ -998,24 +998,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") {
@@ -1267,7 +1262,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 +1277,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 +1586,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 +1598,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 +1607,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 +1647,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 +1793,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;
@@ -1937,14 +1915,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!
@@ -1977,29 +1957,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();
         }
@@ -2577,7 +2557,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 || {}
     };
   }
@@ -2597,7 +2578,7 @@ var _ArtifactParser = class _ArtifactParser {
       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 +2590,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 +2700,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 +2712,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 +2729,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 +2741,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 +2868,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 +2911,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 +2960,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 +2980,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 +2988,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 +3002,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");
@@ -4979,6 +4995,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),
@@ -5456,7 +5489,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 +5498,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 +5509,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;
@@ -5973,35 +6008,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 || "";
           }
@@ -6054,10 +6148,13 @@ async function resolveModelConfig(graphId, agent) {
       summarizer: agent.models.summarizer || agent.models.base
     };
   }
-  const graph = await getAgentGraph(dbClient_default)({
-    scopes: { tenantId: agent.tenantId, projectId: agent.projectId },
-    graphId
-  });
+  let graph = null;
+  if (graphId) {
+    graph = await getAgentGraph(dbClient_default)({
+      scopes: { tenantId: agent.tenantId, projectId: agent.projectId },
+      graphId
+    });
+  }
   if (graph?.models?.base?.model) {
     return {
       base: graph.models.base,
@@ -6683,7 +6780,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 +6845,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 +6872,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 +6890,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 +6916,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 +6960,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 +7072,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({
+        type: "error",
+        ...error
+      });
+    }
   }
   async streamData(data) {
     await this.writeContent(JSON.stringify(data));
@@ -6987,20 +7101,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 +7114,7 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
     this.sentItems.clear();
     this.completedItems.clear();
     this.textId = null;
-    this.queuedOperations = [];
+    this.queuedEvents = [];
     this.isTextStreaming = false;
   }
   /**
@@ -7080,7 +7180,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 +7205,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 +7245,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 +7284,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 +7303,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
    */
@@ -7386,7 +7522,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 +7662,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 +7683,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 +7703,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,
@@ -7859,8 +7991,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();
@@ -8031,11 +8163,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();