@inkeep/agents-run-api 0.2.2 → 0.5.0

package/dist/index.js

@@ -1,14 +1,8 @@
-import { env, __publicField, dbClient_default, getFormattedConversationHistory, createDefaultConversationHistoryConfig, saveA2AMessageResponse } from './chunk-7PHUFKNP.js';
-import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
-import { BaggageSpanProcessor, ALLOW_ALL_BAGGAGE_KEYS } from '@opentelemetry/baggage-span-processor';
-import { AsyncLocalStorageContextManager } from '@opentelemetry/context-async-hooks';
-import { CompositePropagator, W3CTraceContextPropagator, W3CBaggagePropagator } from '@opentelemetry/core';
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
-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 { defaultBatchProcessor } from './chunk-5RGAMXUL.js';
+import { dbClient_default, getFormattedConversationHistory, env, createDefaultConversationHistoryConfig, saveA2AMessageResponse } from './chunk-HIGMADTA.js';
+import { __publicField } from './chunk-PKBMQBKP.js';
+import { getLogger, getTracer, HeadersScopeSchema, getRequestExecutionContext, createApiError, 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 { otel } from '@hono/otel';
 import { OpenAPIHono, createRoute, z as z$1 } from '@hono/zod-openapi';
 import { trace, propagation, context, SpanStatusCode } from '@opentelemetry/api';
 import { Hono } from 'hono';
@@ -22,56 +16,17 @@ 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, generateObject, tool, streamText, generateText, streamObject } from 'ai';
 import { createAnthropic, anthropic } from '@ai-sdk/anthropic';
+import { createGateway, gateway } from '@ai-sdk/gateway';
 import { createGoogleGenerativeAI, google } from '@ai-sdk/google';
 import { createOpenAI, openai } from '@ai-sdk/openai';
+import { createOpenRouter, openrouter } from '@openrouter/ai-sdk-provider';
 import jmespath from 'jmespath';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { z as z$2 } from 'zod/v3';
 import { toReqRes, toFetchResponse } from 'fetch-to-node';
-import { otel } from '@hono/otel';
-
-var maxExportBatchSize = env.OTEL_MAX_EXPORT_BATCH_SIZE ?? (env.ENVIRONMENT === "development" ? 1 : 512);
-var otlpExporter = new OTLPTraceExporter();
-var batchProcessor = new BatchSpanProcessor(otlpExporter, {
-  maxExportBatchSize
-});
-var resource = resourceFromAttributes({
-  [ATTR_SERVICE_NAME]: "inkeep-agents-run-api"
-});
-var sdk = new NodeSDK({
-  resource,
-  contextManager: new AsyncLocalStorageContextManager(),
-  textMapPropagator: new CompositePropagator({
-    propagators: [new W3CTraceContextPropagator(), new W3CBaggagePropagator()]
-  }),
-  spanProcessors: [new BaggageSpanProcessor(ALLOW_ALL_BAGGAGE_KEYS), batchProcessor],
-  instrumentations: [
-    getNodeAutoInstrumentations({
-      "@opentelemetry/instrumentation-http": {
-        enabled: true,
-        requestHook: (span, request) => {
-          const url = request?.url ?? request?.path;
-          if (!url) return;
-          const u = new URL(url, "http://localhost");
-          span.updateName(`${request?.method || "UNKNOWN"} ${u.pathname}`);
-        }
-      },
-      "@opentelemetry/instrumentation-undici": {
-        requestHook: (span) => {
-          const method = span.attributes?.["http.request.method"];
-          const host = span.attributes?.["server.address"];
-          const path = span.attributes?.["url.path"];
-          if (method && path)
-            span.updateName(host ? `${method} ${host}${path}` : `${method} ${path}`);
-        }
-      }
-    })
-  ]
-});
-sdk.start();
 
 // src/types/execution-context.ts
 function createExecutionContext(params) {
@@ -965,7 +920,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 +935,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 +985,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") {
@@ -1100,6 +1082,17 @@ __publicField(_ArtifactReferenceSchema, "ARTIFACT_PROPS_SCHEMA", {
   required: ["artifact_id", "task_id"]
 });
 var ArtifactReferenceSchema = _ArtifactReferenceSchema;
+
+// src/utils/default-status-schemas.ts
+var retrieveStatusSchema = {
+  type: "retrieve",
+  description: 'Use this when the system found or retrieved specific information from searches, queries, or lookups. ONLY report ACTUAL findings that appear explicitly in the tool results - never make up data, names, numbers, or details. The label must state the SPECIFIC discovery (e.g., "Found 3 authentication methods", "Database contains 500 records", "API supports JSON format") not the act of searching. Every detail must be traceable to actual tool output. NEVER invent placeholder names, fictional data, or information not present in the activities.'
+};
+var actionStatusSchema = {
+  type: "action",
+  description: 'Use this when the system executed a tool or performed an operation that modified state or had side effects. ONLY report ACTUAL tool executions and their results as they appear in the tool outputs - never make up tool names, parameters, or outcomes. The label must describe what specific action was performed and its concrete result based on actual tool execution data. DO NOT make up examples like "Ran test suite with X passes" unless a test suite was ACTUALLY run and reported X passes. DO NOT say "Executed database query" unless a database query was ACTUALLY executed. Only report what literally happened. NEVER invent tool names, execution results, or details not explicitly present in the tool execution activities. If a tool failed, report the actual failure, not imagined success.'
+};
+var defaultStatusSchemas = [retrieveStatusSchema, actionStatusSchema];
 var logger5 = getLogger("ModelFactory");
 var _ModelFactory = class _ModelFactory {
   /**
@@ -1113,6 +1106,18 @@ var _ModelFactory = class _ModelFactory {
         return createOpenAI(config);
       case "google":
         return createGoogleGenerativeAI(config);
+      case "openrouter":
+        return {
+          ...createOpenRouter(config),
+          textEmbeddingModel: () => {
+            throw new Error("OpenRouter does not support text embeddings");
+          },
+          imageModel: () => {
+            throw new Error("OpenRouter does not support image generation");
+          }
+        };
+      case "gateway":
+        return createGateway(config);
       default:
         throw new Error(`Unsupported provider: ${provider}`);
     }
@@ -1145,6 +1150,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(
@@ -1169,26 +1177,29 @@ var _ModelFactory = class _ModelFactory {
         return openai(modelName);
       case "google":
         return google(modelName);
+      case "openrouter":
+        return openrouter(modelName);
+      case "gateway":
+        return gateway(modelName);
       default:
-        throw new Error(`Unsupported provider: ${provider}`);
+        throw new Error(
+          `Unsupported provider: ${provider}. Supported providers are: ${_ModelFactory.BUILT_IN_PROVIDERS.join(", ")}. To access other models, use OpenRouter (openrouter/model-id) or Vercel AI Gateway (gateway/model-id).`
+        );
     }
   }
   /**
    * Parse model string to extract provider and model name
    * Examples: "anthropic/claude-sonnet-4" -> { provider: "anthropic", modelName: "claude-sonnet-4" }
+   *          "openrouter/anthropic/claude-sonnet-4" -> { provider: "openrouter", modelName: "anthropic/claude-sonnet-4" }
    *          "claude-sonnet-4" -> { provider: "anthropic", modelName: "claude-sonnet-4" } (default to anthropic)
    */
   static parseModelString(modelString) {
     if (modelString.includes("/")) {
       const [provider, ...modelParts] = modelString.split("/");
       const normalizedProvider = provider.toLowerCase();
-      if (!_ModelFactory.SUPPORTED_PROVIDERS.includes(normalizedProvider)) {
-        logger5.error(
-          { provider: normalizedProvider, modelName: modelParts.join("/") },
-          "Unsupported provider detected, falling back to anthropic"
-        );
+      if (!_ModelFactory.BUILT_IN_PROVIDERS.includes(normalizedProvider)) {
         throw new Error(
-          `Unsupported provider: ${normalizedProvider}. Please provide a model in the format of provider/model-name.`
+          `Unsupported provider: ${normalizedProvider}. Supported providers are: ${_ModelFactory.BUILT_IN_PROVIDERS.join(", ")}. To access other models, use OpenRouter (openrouter/model-id) or Vercel AI Gateway (gateway/model-id).`
         );
       }
       return {
@@ -1197,9 +1208,7 @@ var _ModelFactory = class _ModelFactory {
         // In case model name has slashes
       };
     }
-    throw new Error(
-      `Invalid model provided: ${modelString}. Please provide a model in the format of provider/model-name.`
-    );
+    throw new Error(`No provider specified in model string: ${modelString}`);
   }
   /**
    * Get generation parameters from provider options
@@ -1263,11 +1272,16 @@ var _ModelFactory = class _ModelFactory {
   }
 };
 /**
- * Supported providers for security validation
+ * Built-in providers that have special handling
  */
-__publicField(_ModelFactory, "SUPPORTED_PROVIDERS", ["anthropic", "openai", "google"]);
+__publicField(_ModelFactory, "BUILT_IN_PROVIDERS", [
+  "anthropic",
+  "openai",
+  "google",
+  "openrouter",
+  "gateway"
+]);
 var ModelFactory = _ModelFactory;
-var tracer = getTracer("agents-run-api");
 
 // src/utils/stream-registry.ts
 var streamHelperRegistry = /* @__PURE__ */ new Map();
@@ -1283,6 +1297,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 +1606,6 @@ var GraphSession = class {
     }
     this.isGeneratingUpdate = true;
     const statusUpdateState = this.statusUpdateState;
-    const graphId = this.graphId;
     try {
       const streamHelper = getStreamHelper(this.sessionId);
       if (!streamHelper) {
@@ -1604,81 +1618,49 @@ var GraphSession = class {
       }
       const now = Date.now();
       const elapsedTime = now - statusUpdateState.startTime;
-      let operation;
-      if (statusUpdateState.config.statusComponents && statusUpdateState.config.statusComponents.length > 0) {
-        const result = await this.generateStructuredStatusUpdate(
-          this.events.slice(statusUpdateState.lastEventCount),
-          elapsedTime,
-          statusUpdateState.config.statusComponents,
-          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) {
-              logger6.warn(
-                {
-                  sessionId: this.sessionId,
-                  operation: op
-                },
-                "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))
-                )
-              }
-            };
-            await streamHelper.writeOperation(operationToSend);
-          }
-          const summaryTexts = result.operations.map(
-            (op) => JSON.stringify({ type: op.type, data: op.data })
-          );
-          this.previousSummaries.push(...summaryTexts);
-          if (this.statusUpdateState) {
-            this.statusUpdateState.lastUpdateTime = now;
-            this.statusUpdateState.lastEventCount = this.events.length;
+      const statusComponents = statusUpdateState.config.statusComponents && statusUpdateState.config.statusComponents.length > 0 ? statusUpdateState.config.statusComponents : defaultStatusSchemas;
+      const result = await this.generateStructuredStatusUpdate(
+        this.events.slice(statusUpdateState.lastEventCount),
+        elapsedTime,
+        statusComponents,
+        statusUpdateState.summarizerModel,
+        this.previousSummaries
+      );
+      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,
+                summary
+              },
+              "Skipping empty or invalid structured operation"
+            );
+            continue;
           }
-          return;
+          const summaryToSend = {
+            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.writeSummary(summaryToSend);
         }
-      } else {
-        const summary = await this.generateProgressSummary(
-          this.events.slice(statusUpdateState.lastEventCount),
-          elapsedTime,
-          statusUpdateState.summarizerModel,
-          this.previousSummaries
+        const summaryTexts = result.summaries.map(
+          (summary) => JSON.stringify({ type: summary.type, data: summary.data })
         );
-        this.previousSummaries.push(summary);
-        operation = statusUpdateOp({
-          summary,
-          eventCount: this.events.length,
-          elapsedTime,
-          currentPhase: "processing",
-          activeAgent: "system",
-          graphId,
-          sessionId: this.sessionId
-        });
+        this.previousSummaries.push(...summaryTexts);
+        if (this.statusUpdateState) {
+          this.statusUpdateState.lastUpdateTime = now;
+          this.statusUpdateState.lastEventCount = this.events.length;
+        }
+        return;
       }
       if (this.previousSummaries.length > 3) {
         this.previousSummaries.shift();
       }
-      if (!operation || !operation.type || !operation.ctx) {
-        logger6.warn(
-          {
-            sessionId: this.sessionId,
-            operation
-          },
-          "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;
@@ -1762,103 +1744,6 @@ var GraphSession = class {
       this.statusUpdateState.updateLock = false;
     }
   }
-  /**
-   * Generate user-focused progress summary hiding internal operations
-   */
-  async generateProgressSummary(newEvents, elapsedTime, summarizerModel, previousSummaries = []) {
-    return tracer.startActiveSpan(
-      "graph_session.generate_progress_summary",
-      {
-        attributes: {
-          "graph_session.id": this.sessionId,
-          "events.count": newEvents.length,
-          "elapsed_time.seconds": Math.round(elapsedTime / 1e3),
-          "llm.model": summarizerModel?.model,
-          "previous_summaries.count": previousSummaries.length
-        }
-      },
-      async (span) => {
-        try {
-          const userVisibleActivities = this.extractUserVisibleActivities(newEvents);
-          let conversationContext = "";
-          if (this.tenantId && this.projectId) {
-            try {
-              const conversationHistory = await getFormattedConversationHistory({
-                tenantId: this.tenantId,
-                projectId: this.projectId,
-                conversationId: this.sessionId,
-                options: {
-                  limit: 10,
-                  // Get recent conversation context
-                  maxOutputTokens: 2e3
-                },
-                filters: {}
-              });
-              conversationContext = conversationHistory.trim() ? `
-User's Question/Context:
-${conversationHistory}
-` : "";
-            } catch (error) {
-              logger6.warn(
-                { sessionId: this.sessionId, error },
-                "Failed to fetch conversation history for status update"
-              );
-            }
-          }
-          const previousSummaryContext = previousSummaries.length > 0 ? `
-Previous updates provided to user:
-${previousSummaries.map((s, i) => `${i + 1}. ${s}`).join("\n")}
-` : "";
-          const basePrompt = `Generate a meaningful status update that tells the user what specific information or result was just found/achieved.${conversationContext}${previousSummaries.length > 0 ? `
-${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").
-
-${this.statusUpdateState?.config.prompt?.trim() || ""}`;
-          const prompt = basePrompt;
-          let modelToUse = summarizerModel;
-          if (!summarizerModel?.model?.trim()) {
-            if (!this.statusUpdateState?.baseModel?.model?.trim()) {
-              throw new Error(
-                "Either summarizer or base model is required for progress summary generation. Please configure models at the project level."
-              );
-            }
-            modelToUse = this.statusUpdateState.baseModel;
-          }
-          const model = ModelFactory.createModel(modelToUse);
-          const { text } = await generateText({
-            model,
-            prompt,
-            experimental_telemetry: {
-              isEnabled: true,
-              functionId: `status_update_${this.sessionId}`,
-              recordInputs: true,
-              recordOutputs: true,
-              metadata: {
-                operation: "progress_summary_generation",
-                sessionId: this.sessionId
-              }
-            }
-          });
-          span.setAttributes({
-            "summary.length": text.trim().length,
-            "user_activities.count": userVisibleActivities.length
-          });
-          span.setStatus({ code: SpanStatusCode.OK });
-          return text.trim();
-        } catch (error) {
-          setSpanWithError(span, error);
-          logger6.error({ error }, "Failed to generate summary, using fallback");
-          return this.generateFallbackSummary(newEvents, elapsedTime);
-        } finally {
-          span.end();
-        }
-      }
-    );
-  }
   /**
    * Generate structured status update using configured data components
    */
@@ -1937,15 +1822,45 @@ 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-7 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
-- 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
-- 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
-- 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.
+- Examples: "Admin permissions required", "Three OAuth steps found", "Token expires daily"
+
+CRITICAL - HIDE ALL INTERNAL SYSTEM OPERATIONS:
+- You are ONE unified AI system presenting results to the user
+- ABSOLUTELY FORBIDDEN WORDS/PHRASES: "transfer", "transferring", "delegation", "delegating", "delegate", "agent", "routing", "route", "artifact", "saving artifact", "stored artifact", "artifact saved", "continuing", "passing to", "handing off", "switching to"
+- NEVER reveal internal architecture: No mentions of different agents, components, systems, or modules working together
+- NEVER mention artifact operations: Users don't need to know about data being saved, stored, or organized internally
+- NEVER describe handoffs or transitions: Present everything as one seamless operation
+- If you see "transfer", "delegation_sent", "delegation_returned", or "artifact_saved" events - IGNORE THEM or translate to user-facing information only
+- Focus ONLY on actual discoveries, findings, and results that matter to the user
+
+- Bad examples: 
+  * "Transferring to search agent"
+  * "Delegating research task" 
+  * "Routing to QA specialist"
+  * "Artifact saved successfully"
+  * "Storing results for later"
+  * "Passing request to tool handler"
+  * "Continuing with analysis"
+  * "Handing off to processor"
+- Good examples:
+  * "Slack bot needs admin privileges"
+  * "Found 3-step OAuth flow required"  
+  * "Channel limit is 500 per workspace"
+  * Use no_relevant_updates if nothing new to report
+
+CRITICAL ANTI-HALLUCINATION RULES:
+- NEVER MAKE UP SOMETHING WITHOUT BACKING IT UP WITH ACTUAL INFORMATION. EVERY SINGLE UPDATE MUST BE BACKED UP WITH ACTUAL INFORMATION.
+- DO NOT MAKE UP PEOPLE, NAMES, PLACES, THINGS, ORGANIZATIONS, OR INFORMATION. IT IS OBVIOUS WHEN A PERSON/ENTITY DOES NOT EXIST.
+- Only report facts that are EXPLICITLY mentioned in the activities or tool results
+- If you don't have concrete information about something, DO NOT mention it
+- Never invent names like "John Doe", "Alice", "Bob", or any other placeholder names
+- Never create fictional companies, products, or services
+- If a tool returned no results or an error, DO NOT pretend it found something
+- Every detail in your status update must be traceable back to the actual activities provided
 
 REMEMBER YOU CAN ONLY USE 'no_relevant_updates' ALONE! IT CANNOT BE CONCATENATED WITH OTHER STATUS UPDATES!
 
@@ -1960,6 +1875,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 +1895,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();
         }
@@ -2015,7 +1933,7 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
     }
     return z.object({
       label: z.string().describe(
-        'A short 3-5 word phrase, that is a descriptive label for the update component. This Label must be EXTREMELY unique to represent the UNIQUE update we are providing. The ACTUAL finding or result, not the action. What specific information was discovered? (e.g., "Slack requires OAuth 2.0 setup", "Found 5 integration methods", "API rate limit is 100/minute"). Include the actual detail or insight, not just that you searched or processed.'
+        'A short 3-5 word phrase, that is a descriptive label for the update component. This Label must be EXTREMELY unique to represent the UNIQUE update we are providing. The ACTUAL finding or result, not the action. What specific information was discovered? (e.g., "Slack requires OAuth 2.0 setup", "Found 5 integration methods", "API rate limit is 100/minute"). Include the actual detail or insight, not just that you searched or processed. CRITICAL: Only use facts explicitly found in the activities - NEVER invent names, people, organizations, or details that are not present in the actual tool results.'
       )
     });
   }
@@ -2025,7 +1943,7 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
   buildZodSchemaFromJson(jsonSchema) {
     const properties = {};
     properties["label"] = z.string().describe(
-      'A short 3-5 word phrase, that is a descriptive label for the update component. This Label must be EXTREMELY unique to represent the UNIQUE update we are providing. The SPECIFIC finding, result, or insight discovered (e.g., "Slack bot needs workspace admin role", "Found ingestion requires 3 steps", "Channel history limited to 10k messages"). State the ACTUAL information found, not that you searched. What did you LEARN or DISCOVER? What specific detail is now known?'
+      'A short 3-5 word phrase, that is a descriptive label for the update component. This Label must be EXTREMELY unique to represent the UNIQUE update we are providing. The SPECIFIC finding, result, or insight discovered (e.g., "Slack bot needs workspace admin role", "Found ingestion requires 3 steps", "Channel history limited to 10k messages"). State the ACTUAL information found, not that you searched. What did you LEARN or DISCOVER? What specific detail is now known? CRITICAL: Only use facts explicitly found in the activities - NEVER invent names, people, organizations, or details that are not present in the actual tool results.'
     );
     for (const [key, value] of Object.entries(jsonSchema.properties)) {
       let zodType;
@@ -2102,41 +2020,12 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
           );
           break;
         }
-        case "transfer": {
-          const data = event.data;
-          activities.push(
-            `\u{1F504} **Continuing**: ${data.reason || "Processing request"}
-   ${data.context ? `Context: ${JSON.stringify(data.context, null, 2)}` : ""}`
-          );
-          break;
-        }
-        case "delegation_sent": {
-          const data = event.data;
-          activities.push(
-            `\u{1F4E4} **Processing**: ${data.taskDescription}
-   ${data.context ? `Context: ${JSON.stringify(data.context, null, 2)}` : ""}`
-          );
-          break;
-        }
-        case "delegation_returned": {
-          const data = event.data;
-          activities.push(
-            `\u{1F4E5} **Completed subtask**
-   Result: ${JSON.stringify(data.result, null, 2)}`
-          );
-          break;
-        }
-        case "artifact_saved": {
-          const data = event.data;
-          activities.push(
-            `\u{1F4BE} **Artifact Saved**: ${data.artifactType}
-   ID: ${data.artifactId}
-   Task: ${data.taskId}
-   ${data.summaryData ? `Summary: ${data.summaryData}` : ""}
-   ${data.fullData ? `Full Data: ${data.fullData}` : ""}`
-          );
+        // INTERNAL OPERATIONS - DO NOT EXPOSE TO STATUS UPDATES
+        case "transfer":
+        case "delegation_sent":
+        case "delegation_returned":
+        case "artifact_saved":
           break;
-        }
         case "agent_reasoning": {
           const data = event.data;
           activities.push(
@@ -2161,21 +2050,6 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
     }
     return activities;
   }
-  /**
-   * Generate fallback summary when LLM fails
-   */
-  generateFallbackSummary(events, elapsedTime) {
-    const timeStr = Math.round(elapsedTime / 1e3);
-    const toolCalls = events.filter((e) => e.eventType === "tool_execution").length;
-    const artifacts = events.filter((e) => e.eventType === "artifact_saved").length;
-    if (artifacts > 0) {
-      return `Generated ${artifacts} result${artifacts > 1 ? "s" : ""} so far (${timeStr}s elapsed)`;
-    } else if (toolCalls > 0) {
-      return `Used ${toolCalls} tool${toolCalls > 1 ? "s" : ""} to gather information (${timeStr}s elapsed)`;
-    } else {
-      return `Processing your request... (${timeStr}s elapsed)`;
-    }
-  }
   /**
    * Process a single artifact to generate name and description using conversation context
    */
@@ -2212,7 +2086,7 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
             );
           }
           span.setAttributes({ "validation.passed": true });
-          const { getFormattedConversationHistory: getFormattedConversationHistory2 } = await import('./conversations-WDOIWO7W.js');
+          const { getFormattedConversationHistory: getFormattedConversationHistory2 } = await import('./conversations-OVETKXSP.js');
           const conversationHistory = await getFormattedConversationHistory2({
             tenantId: artifactData.tenantId,
             projectId: artifactData.projectId,
@@ -2250,6 +2124,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 +2405,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 +2455,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 +2473,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 +2489,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 +2599,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 +2611,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 +2628,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,129 +2640,179 @@ 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");
   }
   /**
-   * Legacy method for backward compatibility - defaults to text processing
+   * Stream a component and mark it as streamed
+   * Note: Text components are handled separately with incremental streaming
    */
-  async processChunk(chunk) {
-    await this.processTextChunk(chunk);
+  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);
   }
   /**
-   * Process any remaining buffer content at the end of stream
+   * Check if a component has the basic structure required for streaming
+   * Requires id, name, and props object with content
    */
-  async finalize() {
-    if (this.buffer.trim()) {
-      const part = {
-        kind: "text",
-        text: this.buffer.trim()
-      };
-      await this.streamPart(part);
+  isComponentComplete(component) {
+    if (!component || !component.id || !component.name) {
+      return false;
     }
-    if (this.pendingTextBuffer.trim()) {
-      const cleanedText = this.pendingTextBuffer.replace(/<\/?artifact:ref(?:\s[^>]*)?>\/?>/g, "").replace(/<\/?artifact(?:\s[^>]*)?>\/?>/g, "").replace(/<\/(?:\w+:)?artifact>/g, "").trim();
-      if (cleanedText) {
-        this.collectedParts.push({
-          kind: "text",
+    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
+   */
+  async processChunk(chunk) {
+    await this.processTextChunk(chunk);
+  }
+  /**
+   * Process any remaining buffer content at the end of stream
+   */
+  async finalize() {
+    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
+      };
+      await this.streamPart(part);
+    }
+    if (this.pendingTextBuffer) {
+      const cleanedText = this.pendingTextBuffer.replace(/<\/?artifact:ref(?:\s[^>]*)?>\/?>/g, "").replace(/<\/?artifact(?:\s[^>]*)?>\/?>/g, "").replace(/<\/artifact:ref>/g, "").replace(/<\/(?:\w+:)?artifact>/g, "");
+      if (cleanedText) {
+        this.collectedParts.push({
+          kind: "text",
           text: cleanedText
         });
         await this.streamHelper.streamText(cleanedText, 50);
       }
       this.pendingTextBuffer = "";
     }
+    this.componentSnapshots.clear();
+    this.lastStreamedComponents.clear();
+    this.componentAccumulator = {};
   }
   /**
    * Get all collected parts for building the final response
@@ -2925,30 +2859,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
    */
@@ -2968,16 +2878,16 @@ var IncrementalStreamParser = class {
     if (part.kind === "text" && part.text) {
       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()) {
+        const cleanedText = this.pendingTextBuffer.replace(/<\/?artifact:ref(?:\s[^>]*)?>\/?>/g, "").replace(/<\/?artifact(?:\s[^>]*)?>\/?>/g, "").replace(/<\/artifact:ref>/g, "").replace(/<\/(?:\w+:)?artifact>/g, "");
+        if (cleanedText) {
           await this.streamHelper.streamText(cleanedText, 50);
         }
         this.pendingTextBuffer = "";
       }
     } 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()) {
+        const cleanedText = this.pendingTextBuffer.replace(/<\/?artifact:ref(?:\s[^>]*)?>\/?>/g, "").replace(/<\/?artifact(?:\s[^>]*)?>\/?>/g, "").replace(/<\/artifact:ref>/g, "").replace(/<\/(?:\w+:)?artifact>/g, "");
+        if (cleanedText) {
           await this.streamHelper.streamText(cleanedText, 50);
         }
         this.pendingTextBuffer = "";
@@ -2991,6 +2901,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 +4292,8 @@ function createDelegateToAgentTool({
         const externalAgent = await getExternalAgent(dbClient_default)({
           scopes: {
             tenantId,
-            projectId
+            projectId,
+            graphId
           },
           agentId: delegateConfig.config.id
         });
@@ -4979,6 +4895,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 +5182,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 +5334,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 +5358,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 +5395,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 +5404,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 +5415,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 +5566,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 +5914,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 +6046,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 +6081,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 +6116,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 +6348,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 +6397,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 +6459,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 +6517,7 @@ app.openapi(
     );
     const executionContext = getRequestExecutionContext(c);
     const { tenantId, projectId, graphId, agentId } = executionContext;
+    console.dir("executionContext", executionContext);
     if (agentId) {
       logger17.info(
         {
@@ -6554,7 +6533,10 @@ app.openapi(
       const agent = await getRegisteredAgent(executionContext, credentialStores);
       logger17.info({ agent }, "agent registered: well-known agent.json");
       if (!agent) {
-        return c.json({ error: "Agent not found" }, 404);
+        throw createApiError({
+          code: "not_found",
+          message: "Agent not found"
+        });
       }
       return c.json(agent.agentCard);
     } else {
@@ -6569,7 +6551,10 @@ app.openapi(
       );
       const graph = await getRegisteredGraph(executionContext);
       if (!graph) {
-        return c.json({ error: "Graph not found" }, 404);
+        throw createApiError({
+          code: "not_found",
+          message: "Graph not found"
+        });
       }
       return c.json(graph.agentCard);
     }
@@ -6626,8 +6611,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 +6623,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 +6677,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 +6742,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 +6769,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 +6787,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 +6813,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,10 +6857,10 @@ 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);
+    __publicField(this, "TEXT_GAP_THRESHOLD", 2e3);
     // milliseconds - if gap between text sequences is less than this, queue operations
     // Connection management and forced cleanup
     __publicField(this, "connectionDropTimer");
@@ -6967,15 +6969,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 +6998,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 +7011,7 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
     this.sentItems.clear();
     this.completedItems.clear();
     this.textId = null;
-    this.queuedOperations = [];
+    this.queuedEvents = [];
     this.isTextStreaming = false;
   }
   /**
@@ -7080,7 +7077,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 +7102,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 +7142,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 +7181,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 +7200,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 +7237,8 @@ var MCPStreamHelper = class {
 function createMCPStreamHelper() {
   return new MCPStreamHelper();
 }
+
+// src/handlers/executionHandler.ts
 var logger19 = getLogger("ExecutionHandler");
 var ExecutionHandler = class {
   constructor() {
@@ -7232,7 +7267,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 +7421,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 +7561,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 +7582,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 +7602,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 +7764,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,16 +7781,21 @@ 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);
+        throw createApiError({
+          code: "not_found",
+          message: "Agent graph not found"
+        });
       }
       defaultAgentId = agentGraph.defaultAgentId || "";
     }
     if (!defaultAgentId) {
-      return c.json({ error: "No default agent found in graph" }, 404);
+      throw createApiError({
+        code: "not_found",
+        message: "No default agent found in graph"
+      });
     }
     await createOrGetConversation(dbClient_default)({
       tenantId,
@@ -7781,26 +7816,30 @@ 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) {
-      return c.json({ error: "Agent not found" }, 404);
+      throw createApiError({
+        code: "not_found",
+        message: "Agent not found"
+      });
     }
     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,
@@ -7842,41 +7881,69 @@ app2.openapi(chatCompletionsRoute, async (c) => {
       });
     }
     return streamSSE(c, async (stream2) => {
-      const sseHelper = createSSEStreamHelper(stream2, requestId2, timestamp);
-      await sseHelper.writeRole();
-      logger20.info({ agentId }, "Starting execution");
-      const executionHandler = new ExecutionHandler();
-      const result = await executionHandler.execute({
-        executionContext,
-        conversationId,
-        userMessage,
-        initialAgentId: agentId,
-        requestId: requestId2,
-        sseHelper
-      });
-      logger20.info(
-        { result },
-        `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."
+      try {
+        const sseHelper = createSSEStreamHelper(stream2, requestId2, timestamp);
+        await sseHelper.writeRole();
+        logger20.info({ agentId }, "Starting execution");
+        const executionHandler = new ExecutionHandler();
+        const result = await executionHandler.execute({
+          executionContext,
+          conversationId,
+          userMessage,
+          initialAgentId: agentId,
+          requestId: requestId2,
+          sseHelper
+        });
+        logger20.info(
+          { result },
+          `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
         );
+        if (!result.success) {
+          await sseHelper.writeOperation(
+            errorOp(
+              "Sorry, I was unable to process your request at this time. Please try again.",
+              "system"
+            )
+          );
+        }
+        await sseHelper.complete();
+      } catch (error) {
+        logger20.error(
+          {
+            error: error instanceof Error ? error.message : error,
+            stack: error instanceof Error ? error.stack : void 0
+          },
+          "Error during streaming execution"
+        );
+        try {
+          const sseHelper = createSSEStreamHelper(stream2, requestId2, timestamp);
+          await sseHelper.writeOperation(
+            errorOp(
+              "Sorry, I was unable to process your request at this time. Please try again.",
+              "system"
+            )
+          );
+          await sseHelper.complete();
+        } catch (streamError) {
+          logger20.error({ streamError }, "Failed to write error to stream");
+        }
       }
-      await sseHelper.complete();
     });
   } catch (error) {
-    console.error("\u274C Error in chat completions endpoint:", {
-      error: error instanceof Error ? error.message : error,
-      stack: error instanceof Error ? error.stack : void 0
-    });
-    return c.json(
+    logger20.error(
       {
-        error: "Failed to process chat completion",
-        message: error instanceof Error ? error.message : "Unknown error"
+        error: error instanceof Error ? error.message : error,
+        stack: error instanceof Error ? error.stack : void 0
       },
-      500
+      "Error in chat completions endpoint before streaming"
     );
+    if (error && typeof error === "object" && "status" in error) {
+      throw error;
+    }
+    throw createApiError({
+      code: "internal_server_error",
+      message: error instanceof Error ? error.message : "Failed to process chat completion"
+    });
   }
 });
 var getMessageText = (content) => {
@@ -7940,6 +8007,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 +8020,22 @@ 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);
+      throw createApiError({
+        code: "not_found",
+        message: "Agent graph not found"
+      });
     }
     const defaultAgentId = agentGraph.defaultAgentId;
     const graphName = agentGraph.name;
+    if (!defaultAgentId) {
+      throw createApiError({
+        code: "bad_request",
+        message: "Graph does not have a default agent configured"
+      });
+    }
     const activeAgent = await getActiveAgentForConversation(dbClient_default)({
       scopes: { tenantId, projectId },
       conversationId
@@ -7973,23 +8049,26 @@ 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) {
-      return c.json({ error: "Agent not found" }, 404);
+      throw createApiError({
+        code: "not_found",
+        message: "Agent not found"
+      });
     }
     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 +8110,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();
@@ -8056,7 +8135,10 @@ app3.openapi(chatDataStreamRoute, async (c) => {
     );
   } catch (error) {
     logger21.error({ error }, "chatDataStream error");
-    return c.json({ error: "Failed to process chat completion" }, 500);
+    throw createApiError({
+      code: "internal_server_error",
+      message: "Failed to process chat completion"
+    });
   }
 });
 var chatDataStream_default = app3;
@@ -8258,8 +8340,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 +8360,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 +8387,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 +8461,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 +8473,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,
@@ -8577,6 +8679,8 @@ app4.delete("/", async (c) => {
   );
 });
 var mcp_default = app4;
+
+// src/app.ts
 var logger23 = getLogger("agents-run-api");
 function createExecutionHono(serverConfig, credentialStores) {
   const app6 = new OpenAPIHono();
@@ -8766,21 +8870,21 @@ function createExecutionHono(serverConfig, credentialStores) {
   app6.route("/v1/mcp", mcp_default);
   app6.route("/agents", agents_default);
   setupOpenAPIRoutes(app6);
-  app6.use("/tenants/*", async (c, next) => {
+  app6.use("/tenants/*", async (_c, next) => {
     await next();
-    await batchProcessor.forceFlush();
+    await defaultBatchProcessor.forceFlush();
   });
-  app6.use("/agents/*", async (c, next) => {
+  app6.use("/agents/*", async (_c, next) => {
     await next();
-    await batchProcessor.forceFlush();
+    await defaultBatchProcessor.forceFlush();
   });
-  app6.use("/v1/*", async (c, next) => {
+  app6.use("/v1/*", async (_c, next) => {
     await next();
-    await batchProcessor.forceFlush();
+    await defaultBatchProcessor.forceFlush();
   });
-  app6.use("/api/*", async (c, next) => {
+  app6.use("/api/*", async (_c, next) => {
     await next();
-    await batchProcessor.forceFlush();
+    await defaultBatchProcessor.forceFlush();
   });
   const baseApp = new Hono();
   baseApp.route("/", app6);