@inkeep/agents-run-api 0.2.1 → 0.3.0

package/dist/index.cjs

@@ -2,11 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var fs = require('fs');
-var path = require('path');
-var dotenv = require('dotenv');
-var z5 = require('zod');
 var agentsCore = require('@inkeep/agents-core');
+var z5 = require('zod');
 var nanoid = require('nanoid');
 var autoInstrumentationsNode = require('@opentelemetry/auto-instrumentations-node');
 var baggageSpanProcessor = require('@opentelemetry/baggage-span-processor');
@@ -17,6 +14,7 @@ var resources = require('@opentelemetry/resources');
 var sdkNode = require('@opentelemetry/sdk-node');
 var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
 var semanticConventions = require('@opentelemetry/semantic-conventions');
+var otel = require('@hono/otel');
 var zodOpenapi = require('@hono/zod-openapi');
 var api = require('@opentelemetry/api');
 var hono = require('hono');
@@ -37,31 +35,9 @@ var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
 var streamableHttp_js = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
 var v3 = require('zod/v3');
 var fetchToNode = require('fetch-to-node');
-var otel = require('@hono/otel');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var fs__default = /*#__PURE__*/_interopDefault(fs);
-var path__default = /*#__PURE__*/_interopDefault(path);
-var dotenv__namespace = /*#__PURE__*/_interopNamespace(dotenv);
 var z5__default = /*#__PURE__*/_interopDefault(z5);
 var destr__default = /*#__PURE__*/_interopDefault(destr);
 var traverse__default = /*#__PURE__*/_interopDefault(traverse);
@@ -78,31 +54,14 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var environmentSchema, criticalEnv, loadEnvFile, envSchema, parseEnv, env;
+var envSchema, parseEnv, env;
 var init_env = __esm({
   "src/env.ts"() {
-    dotenv__namespace.config({ quiet: true });
-    z5.z.enum(["development", "production"]).default("development");
-    environmentSchema = z5.z.enum(["development", "pentest", "production", "test"]);
-    criticalEnv = z5.z.object({
-      ENVIRONMENT: environmentSchema
-    }).parse(process.env);
-    loadEnvFile = () => {
-      const envPath = path__default.default.resolve(process.cwd(), `.env.${criticalEnv.ENVIRONMENT}.nonsecret`);
-      if (fs__default.default.existsSync(envPath)) {
-        const envConfig = dotenv__namespace.parse(fs__default.default.readFileSync(envPath));
-        for (const k in envConfig) {
-          if (!(k in process.env)) {
-            process.env[k] = envConfig[k];
-          }
-        }
-      }
-    };
-    loadEnvFile();
+    agentsCore.loadEnvironmentFiles();
     envSchema = z5.z.object({
       NODE_ENV: z5.z.enum(["development", "production", "test"]).optional(),
       ENVIRONMENT: z5.z.enum(["development", "production", "pentest", "test"]).optional().default("development"),
-      DB_FILE_NAME: z5.z.string().default("file:../local.db"),
+      DB_FILE_NAME: z5.z.string(),
       AGENTS_RUN_API_URL: z5.z.string().optional().default("http://localhost:3003"),
       LOG_LEVEL: z5.z.enum(["trace", "debug", "info", "warn", "error"]).optional().default("debug"),
       NANGO_SECRET_KEY: z5.z.string().optional(),
@@ -356,9 +315,9 @@ var sdk = new sdkNode.NodeSDK({
         requestHook: (span) => {
           const method = span.attributes?.["http.request.method"];
           const host = span.attributes?.["server.address"];
-          const path2 = span.attributes?.["url.path"];
-          if (method && path2)
-            span.updateName(host ? `${method} ${host}${path2}` : `${method} ${path2}`);
+          const path = span.attributes?.["url.path"];
+          if (method && path)
+            span.updateName(host ? `${method} ${host}${path}` : `${method} ${path}`);
         }
       }
     })
@@ -1267,7 +1226,7 @@ async function getRegisteredAgent(executionContext, credentialStoreRegistry) {
     throw new Error("Agent ID is required");
   }
   const dbAgent = await agentsCore.getAgentById(dbClient_default)({
-    scopes: { tenantId, projectId },
+    scopes: { tenantId, projectId, graphId },
     agentId
   });
   if (!dbAgent) {
@@ -1286,6 +1245,41 @@ async function getRegisteredAgent(executionContext, credentialStoreRegistry) {
 // src/agents/generateTaskHandler.ts
 init_dbClient();
 
+// src/utils/model-resolver.ts
+init_dbClient();
+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 agentsCore.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 agentsCore.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/Agent.ts
 init_conversations();
 init_dbClient();
@@ -1307,24 +1301,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.nanoid(8)}`;
 }
-function statusUpdateOp(ctx) {
-  return {
-    type: "status_update",
-    ctx
-  };
-}
 var logger4 = agentsCore.getLogger("DataComponentSchema");
 function jsonSchemaToZod(jsonSchema) {
   if (!jsonSchema || typeof jsonSchema !== "object") {
@@ -1414,14 +1403,14 @@ var _ModelFactory = class _ModelFactory {
   /**
    * Create a provider instance with custom configuration
    */
-  static createProvider(provider, config2) {
+  static createProvider(provider, config) {
     switch (provider) {
       case "anthropic":
-        return anthropic.createAnthropic(config2);
+        return anthropic.createAnthropic(config);
       case "openai":
-        return openai.createOpenAI(config2);
+        return openai.createOpenAI(config);
       case "google":
-        return google.createGoogleGenerativeAI(config2);
+        return google.createGoogleGenerativeAI(config);
       default:
         throw new Error(`Unsupported provider: ${provider}`);
     }
@@ -1447,13 +1436,16 @@ var _ModelFactory = class _ModelFactory {
    * Create a language model instance from configuration
    * Throws error if no config provided - models must be configured at project level
    */
-  static createModel(config2) {
-    if (!config2?.model?.trim()) {
+  static createModel(config) {
+    if (!config?.model?.trim()) {
       throw new Error(
         "Model configuration is required. Please configure models at the project level."
       );
     }
-    const modelSettings = config2;
+    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(
@@ -1550,19 +1542,19 @@ var _ModelFactory = class _ModelFactory {
    * Validate model settingsuration
    * Basic validation only - let AI SDK handle parameter-specific validation
    */
-  static validateConfig(config2) {
+  static validateConfig(config) {
     const errors = [];
-    if (!config2.model) {
+    if (!config.model) {
       errors.push("Model name is required");
     }
-    if (config2.providerOptions) {
-      if (config2.providerOptions.apiKey) {
+    if (config.providerOptions) {
+      if (config.providerOptions.apiKey) {
         errors.push(
           "API keys should not be stored in provider options. Use environment variables (ANTHROPIC_API_KEY, OPENAI_API_KEY) or credential store instead."
         );
       }
-      if (config2.providerOptions.maxDuration !== void 0) {
-        const maxDuration = config2.providerOptions.maxDuration;
+      if (config.providerOptions.maxDuration !== void 0) {
+        const maxDuration = config.providerOptions.maxDuration;
         if (typeof maxDuration !== "number" || maxDuration <= 0) {
           errors.push("maxDuration must be a positive number (in seconds)");
         }
@@ -1580,7 +1572,6 @@ var ModelFactory = _ModelFactory;
 // src/utils/graph-session.ts
 init_conversations();
 init_dbClient();
-var tracer = agentsCore.getTracer("agents-run-api");
 
 // src/utils/stream-registry.ts
 var streamHelperRegistry = /* @__PURE__ */ new Map();
@@ -1596,6 +1587,7 @@ function getStreamHelper(requestId2) {
 function unregisterStreamHelper(requestId2) {
   streamHelperRegistry.delete(requestId2);
 }
+var tracer = agentsCore.getTracer("agents-run-api");
 
 // src/utils/graph-session.ts
 var logger6 = agentsCore.getLogger("GraphSession");
@@ -1627,7 +1619,7 @@ var GraphSession = class {
   /**
    * Initialize status updates for this session
    */
-  initializeStatusUpdates(config2, summarizerModel, baseModel) {
+  initializeStatusUpdates(config, summarizerModel, baseModel) {
     const now = Date.now();
     this.statusUpdateState = {
       lastUpdateTime: now,
@@ -1636,9 +1628,9 @@ var GraphSession = class {
       summarizerModel,
       baseModel,
       config: {
-        numEvents: config2.numEvents || 1,
-        timeInSeconds: config2.timeInSeconds || 2,
-        ...config2
+        numEvents: config.numEvents || 1,
+        timeInSeconds: config.timeInSeconds || 2,
+        ...config
       }
     };
     if (this.statusUpdateState.config.timeInSeconds) {
@@ -1904,7 +1896,6 @@ var GraphSession = class {
     }
     this.isGeneratingUpdate = true;
     const statusUpdateState = this.statusUpdateState;
-    const graphId = this.graphId;
     try {
       const streamHelper = getStreamHelper(this.sessionId);
       if (!streamHelper) {
@@ -1917,7 +1908,7 @@ var GraphSession = class {
       }
       const now = Date.now();
       const elapsedTime = now - statusUpdateState.startTime;
-      let operation;
+      let summaryToSend;
       if (statusUpdateState.config.statusComponents && statusUpdateState.config.statusComponents.length > 0) {
         const result = await this.generateStructuredStatusUpdate(
           this.events.slice(statusUpdateState.lastEventCount),
@@ -1926,32 +1917,30 @@ var GraphSession = class {
           statusUpdateState.summarizerModel,
           this.previousSummaries
         );
-        if (result.operations && result.operations.length > 0) {
-          for (const op of result.operations) {
-            if (!op || !op.type || !op.data || Object.keys(op.data).length === 0) {
+        if (result.summaries && result.summaries.length > 0) {
+          for (const summary of result.summaries) {
+            if (!summary || !summary.type || !summary.data || !summary.data.label || Object.keys(summary.data).length === 0) {
               logger6.warn(
                 {
                   sessionId: this.sessionId,
-                  operation: op
+                  summary
                 },
                 "Skipping empty or invalid structured operation"
               );
               continue;
             }
-            const operationToSend = {
-              type: "status_update",
-              ctx: {
-                operationType: op.type,
-                label: op.data.label,
-                data: Object.fromEntries(
-                  Object.entries(op.data).filter(([key]) => !["label", "type"].includes(key))
-                )
-              }
+            const summaryToSend2 = {
+              type: summary.data.type || summary.type,
+              // Preserve the actual custom type from LLM
+              label: summary.data.label,
+              details: Object.fromEntries(
+                Object.entries(summary.data).filter(([key]) => !["label", "type"].includes(key))
+              )
             };
-            await streamHelper.writeOperation(operationToSend);
+            await streamHelper.writeSummary(summaryToSend2);
           }
-          const summaryTexts = result.operations.map(
-            (op) => JSON.stringify({ type: op.type, data: op.data })
+          const summaryTexts = result.summaries.map(
+            (summary) => JSON.stringify({ type: summary.type, data: summary.data })
           );
           this.previousSummaries.push(...summaryTexts);
           if (this.statusUpdateState) {
@@ -1968,34 +1957,20 @@ var GraphSession = class {
           this.previousSummaries
         );
         this.previousSummaries.push(summary);
-        operation = statusUpdateOp({
-          summary,
-          eventCount: this.events.length,
-          elapsedTime,
-          currentPhase: "processing",
-          activeAgent: "system",
-          graphId,
-          sessionId: this.sessionId
-        });
       }
       if (this.previousSummaries.length > 3) {
         this.previousSummaries.shift();
       }
-      if (!operation || !operation.type || !operation.ctx) {
+      {
         logger6.warn(
           {
             sessionId: this.sessionId,
-            operation
+            summaryToSend
           },
           "Skipping empty or invalid status update operation"
         );
         return;
       }
-      await streamHelper.writeOperation(operation);
-      if (this.statusUpdateState) {
-        this.statusUpdateState.lastUpdateTime = now;
-        this.statusUpdateState.lastEventCount = this.events.length;
-      }
     } catch (error) {
       logger6.error(
         {
@@ -2128,7 +2103,7 @@ ${previousSummaryContext}` : ""}
 Activities:
 ${userVisibleActivities.join("\n") || "No New Activities"}
 
-Describe the ACTUAL finding, result, or specific information discovered (e.g., "Found Slack bot requires admin permissions", "Identified 3 channel types for ingestion", "Configuration requires OAuth token").
+Create a short 3-5 word label describing the ACTUAL finding. Use sentence case (only capitalize the first word and proper nouns). Examples: "Found admin permissions needed", "Identified three channel types", "OAuth token required".
 
 ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
           const prompt = basePrompt;
@@ -2141,6 +2116,9 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
             }
             modelToUse = this.statusUpdateState.baseModel;
           }
+          if (!modelToUse) {
+            throw new Error("No model configuration available");
+          }
           const model = ModelFactory.createModel(modelToUse);
           const { text } = await ai.generateText({
             model,
@@ -2250,14 +2228,16 @@ Rules:
 - Fill in data for relevant components only
 - Use 'no_relevant_updates' if nothing substantially new to report. DO NOT WRITE LABELS OR USE OTHER COMPONENTS IF YOU USE THIS COMPONENT.
 - Never repeat previous values, make every update EXTREMELY unique. If you cannot do that the update is not worth mentioning.
-- Labels MUST contain the ACTUAL information discovered ("Found X", "Learned Y", "Discovered Z requires A")
+- Labels MUST be short 3-5 word phrases with ACTUAL information discovered. NEVER MAKE UP SOMETHING WITHOUT BACKING IT UP WITH ACTUAL INFORMATION.
+- Use sentence case: only capitalize the first word and proper nouns (e.g., "Admin permissions required", not "Admin Permissions Required"). ALWAYS capitalize the first word of the label.
 - DO NOT use action words like "Searching", "Processing", "Analyzing" - state what was FOUND
 - Include specific details, numbers, requirements, or insights discovered
+- Examples: "Admin permissions required", "Three OAuth steps found", "Token expires daily"
 - You are ONE unified AI system - NEVER mention agents, transfers, delegations, or routing
-- CRITICAL: NEVER use the words "transfer", "delegation", "agent", "routing", or any internal system terminology in labels
+- CRITICAL: NEVER use the words "transfer", "delegation", "agent", "routing", "artifact", or any internal system terminology in labels or any names of agents, tools, or systems.
 - Present all operations as seamless actions by a single system
 - Anonymize all internal operations so that the information appears descriptive and USER FRIENDLY. HIDE ALL INTERNAL OPERATIONS!
-- Bad examples: "Transferring to search agent", "Delegating task", "Routing request", "Processing request", or not using the no_relevant_updates
+- Bad examples: "Transferring to search agent", "continuing transfer to qa agent", "Delegating task", "Routing request", "Processing request", "Artifact found", "Artifact saved", or not using the no_relevant_updates
 - Good examples: "Slack bot needs admin privileges", "Found 3-step OAuth flow required", "Channel limit is 500 per workspace", or use the no_relevant_updates component if nothing new to report.
 
 REMEMBER YOU CAN ONLY USE 'no_relevant_updates' ALONE! IT CANNOT BE CONCATENATED WITH OTHER STATUS UPDATES!
@@ -2273,6 +2253,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 ai.generateObject({
             model,
@@ -2290,29 +2273,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: api.SpanStatusCode.OK });
-          return { operations };
+          return { summaries };
         } catch (error) {
           agentsCore.setSpanWithError(span, error);
           logger6.error({ error }, "Failed to generate structured update, using fallback");
-          return { operations: [] };
+          return { summaries: [] };
         } finally {
           span.end();
         }
@@ -2563,6 +2546,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 = z5.z.object({
             name: z5.z.string().max(50).describe("Concise, descriptive name for the artifact"),
@@ -2731,10 +2717,10 @@ var GraphSessionManager = class {
   /**
    * Initialize status updates for a session
    */
-  initializeStatusUpdates(sessionId, config2, summarizerModel) {
+  initializeStatusUpdates(sessionId, config, summarizerModel) {
     const session = this.sessions.get(sessionId);
     if (session) {
-      session.initializeStatusUpdates(config2, summarizerModel);
+      session.initializeStatusUpdates(config, summarizerModel);
     } else {
       logger6.error(
         {
@@ -2844,6 +2830,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("/>")) {
@@ -2893,7 +2880,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 || {}
     };
   }
@@ -2910,10 +2898,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 });
         }
       }
@@ -2925,7 +2914,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 });
       }
     }
@@ -3035,8 +3024,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 = agentsCore.getLogger("IncrementalStreamParser");
-var IncrementalStreamParser = class {
+agentsCore.getLogger("IncrementalStreamParser");
+var _IncrementalStreamParser = class _IncrementalStreamParser {
+  // Max number of streamed component IDs to track
   constructor(streamHelper, tenantId, contextId) {
     __publicField(this, "buffer", "");
     __publicField(this, "pendingTextBuffer", "");
@@ -3046,6 +3036,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);
@@ -3060,7 +3053,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;
     }
@@ -3072,100 +3065,122 @@ var IncrementalStreamParser = class {
     this.buffer = parseResult.remainingBuffer;
   }
   /**
-   * Process a new object chunk for object streaming (handles JSON objects with artifact references)
+   * Process object deltas directly from Vercel AI SDK's fullStream
+   * Accumulates components and streams them when they're stable (unchanged between deltas)
    */
-  async processObjectChunk(chunk) {
-    this.buffer += chunk;
-    const parseResult = await this.parseObjectBuffer();
-    for (const part of parseResult.completeParts) {
-      await this.streamPart(part);
+  async processObjectDelta(delta) {
+    if (!delta || typeof delta !== "object") {
+      return;
     }
-    this.buffer = parseResult.remainingBuffer;
-  }
-  /**
-   * Process tool call stream for structured output, streaming components as they complete
-   */
-  async processToolCallStream(stream2, targetToolName) {
-    let jsonBuffer = "";
-    let componentBuffer = "";
-    let depth = 0;
-    let componentsStreamed = 0;
-    const MAX_BUFFER_SIZE = 5 * 1024 * 1024;
-    for await (const part of stream2) {
-      if (part.type === "tool-call-delta" && part.toolName === targetToolName) {
-        const delta = part.argsTextDelta || "";
-        if (jsonBuffer.length + delta.length > MAX_BUFFER_SIZE) {
-          logger8.warn(
-            { bufferSize: jsonBuffer.length + delta.length, maxSize: MAX_BUFFER_SIZE },
-            "JSON buffer exceeded maximum size, truncating"
-          );
-          jsonBuffer = jsonBuffer.slice(-MAX_BUFFER_SIZE / 2);
+    this.componentAccumulator = this.deepMerge(this.componentAccumulator, delta);
+    if (this.componentAccumulator.dataComponents && Array.isArray(this.componentAccumulator.dataComponents)) {
+      const components = this.componentAccumulator.dataComponents;
+      const currentComponentIds = new Set(components.filter((c) => c?.id).map((c) => c.id));
+      for (const [componentId, snapshot] of this.componentSnapshots.entries()) {
+        if (!currentComponentIds.has(componentId) && !this.lastStreamedComponents.has(componentId)) {
+          try {
+            const component = JSON.parse(snapshot);
+            if (this.isComponentComplete(component)) {
+              await this.streamComponent(component);
+            }
+          } catch (e) {
+          }
         }
-        jsonBuffer += delta;
-        for (const char of delta) {
-          if (componentBuffer.length > MAX_BUFFER_SIZE) {
-            logger8.warn(
-              { bufferSize: componentBuffer.length, maxSize: MAX_BUFFER_SIZE },
-              "Component buffer exceeded maximum size, resetting"
-            );
-            componentBuffer = "";
-            depth = 0;
-            continue;
+      }
+      for (let i = 0; i < components.length; i++) {
+        const component = components[i];
+        if (!component?.id) continue;
+        const componentKey = component.id;
+        const hasBeenStreamed = this.lastStreamedComponents.has(componentKey);
+        if (hasBeenStreamed) continue;
+        const currentSnapshot = JSON.stringify(component);
+        const previousSnapshot = this.componentSnapshots.get(componentKey);
+        this.componentSnapshots.set(componentKey, currentSnapshot);
+        if (this.componentSnapshots.size > _IncrementalStreamParser.MAX_SNAPSHOT_SIZE) {
+          const firstKey = this.componentSnapshots.keys().next().value;
+          if (firstKey) {
+            this.componentSnapshots.delete(firstKey);
           }
-          componentBuffer += char;
-          if (char === "{") {
-            depth++;
-          } else if (char === "}") {
-            depth--;
-            if (depth === 2 && componentBuffer.includes('"id"')) {
-              const componentMatch = componentBuffer.match(/\{[^{}]*(?:\{[^{}]*\}[^{}]*)*\}/);
-              if (componentMatch) {
-                const MAX_COMPONENT_SIZE = 1024 * 1024;
-                if (componentMatch[0].length > MAX_COMPONENT_SIZE) {
-                  logger8.warn(
-                    {
-                      size: componentMatch[0].length,
-                      maxSize: MAX_COMPONENT_SIZE
-                    },
-                    "Component exceeds size limit, skipping"
-                  );
-                  componentBuffer = "";
-                  continue;
-                }
-                try {
-                  const component = JSON.parse(componentMatch[0]);
-                  if (typeof component !== "object" || !component.id) {
-                    logger8.warn({ component }, "Invalid component structure, skipping");
-                    componentBuffer = "";
-                    continue;
-                  }
-                  const parts = await this.artifactParser.parseObject({
-                    dataComponents: [component]
-                  });
-                  for (const part2 of parts) {
-                    await this.streamPart(part2);
-                  }
-                  componentsStreamed++;
-                  componentBuffer = "";
-                } catch (e) {
-                  logger8.debug({ error: e }, "Failed to parse component, continuing to accumulate");
-                }
-              }
+        }
+        if (component.name === "Text" && component.props?.text) {
+          const previousTextContent = previousSnapshot ? JSON.parse(previousSnapshot).props?.text || "" : "";
+          const currentTextContent = component.props.text || "";
+          if (currentTextContent.length > previousTextContent.length) {
+            const newText = currentTextContent.slice(previousTextContent.length);
+            if (!this.hasStartedRole) {
+              await this.streamHelper.writeRole("assistant");
+              this.hasStartedRole = true;
             }
+            await this.streamHelper.streamText(newText, 50);
+            this.collectedParts.push({
+              kind: "text",
+              text: newText
+            });
           }
-          if (componentBuffer.includes('"dataComponents"') && componentBuffer.includes("[")) ;
+          continue;
         }
-      } else if (part.type === "tool-call" && part.toolName === targetToolName) {
-        if (part.args?.dataComponents) {
-          const parts = await this.artifactParser.parseObject(part.args);
-          for (const part2 of parts) {
-            await this.streamPart(part2);
+        if (this.isComponentComplete(component)) {
+          const currentPropsSnapshot = JSON.stringify(component.props);
+          const previousPropsSnapshot = previousSnapshot ? JSON.stringify(JSON.parse(previousSnapshot).props) : null;
+          if (previousPropsSnapshot === currentPropsSnapshot) {
+            await this.streamComponent(component);
           }
         }
-        break;
       }
     }
-    logger8.debug({ componentsStreamed }, "Finished streaming components");
+  }
+  /**
+   * Stream a component and mark it as streamed
+   * Note: Text components are handled separately with incremental streaming
+   */
+  async streamComponent(component) {
+    const parts = await this.artifactParser.parseObject({
+      dataComponents: [component]
+    });
+    for (const part of parts) {
+      await this.streamPart(part);
+    }
+    this.lastStreamedComponents.set(component.id, true);
+    if (this.lastStreamedComponents.size > _IncrementalStreamParser.MAX_STREAMED_SIZE) {
+      const firstKey = this.lastStreamedComponents.keys().next().value;
+      if (firstKey) {
+        this.lastStreamedComponents.delete(firstKey);
+      }
+    }
+    this.componentSnapshots.delete(component.id);
+  }
+  /**
+   * Check if a component has the basic structure required for streaming
+   * Requires id, name, and props object with content
+   */
+  isComponentComplete(component) {
+    if (!component || !component.id || !component.name) {
+      return false;
+    }
+    if (!component.props || typeof component.props !== "object") {
+      return false;
+    }
+    const isArtifact = component.name === "Artifact" || component.props.artifact_id && component.props.task_id;
+    if (isArtifact) {
+      return Boolean(component.props.artifact_id && component.props.task_id);
+    }
+    return true;
+  }
+  /**
+   * Deep merge helper for object deltas
+   */
+  deepMerge(target, source) {
+    if (!source) return target;
+    if (!target) return source;
+    const result = { ...target };
+    for (const key in source) {
+      if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+        result[key] = this.deepMerge(target[key], source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+    return result;
   }
   /**
    * Legacy method for backward compatibility - defaults to text processing
@@ -3177,15 +3192,40 @@ var IncrementalStreamParser = class {
    * Process any remaining buffer content at the end of stream
    */
   async finalize() {
-    if (this.buffer.trim()) {
+    if (this.componentAccumulator.dataComponents && Array.isArray(this.componentAccumulator.dataComponents)) {
+      const components = this.componentAccumulator.dataComponents;
+      for (let i = 0; i < components.length; i++) {
+        const component = components[i];
+        if (!component?.id) continue;
+        const componentKey = component.id;
+        const hasBeenStreamed = this.lastStreamedComponents.has(componentKey);
+        if (!hasBeenStreamed && this.isComponentComplete(component) && component.name !== "Text") {
+          const parts = await this.artifactParser.parseObject({
+            dataComponents: [component]
+          });
+          for (const part of parts) {
+            await this.streamPart(part);
+          }
+          this.lastStreamedComponents.set(componentKey, true);
+          if (this.lastStreamedComponents.size > _IncrementalStreamParser.MAX_STREAMED_SIZE) {
+            const firstKey = this.lastStreamedComponents.keys().next().value;
+            if (firstKey) {
+              this.lastStreamedComponents.delete(firstKey);
+            }
+          }
+          this.componentSnapshots.delete(componentKey);
+        }
+      }
+    }
+    if (this.buffer) {
       const part = {
         kind: "text",
-        text: this.buffer.trim()
+        text: this.buffer
       };
       await this.streamPart(part);
     }
-    if (this.pendingTextBuffer.trim()) {
-      const cleanedText = this.pendingTextBuffer.replace(/<\/?artifact:ref(?:\s[^>]*)?>\/?>/g, "").replace(/<\/?artifact(?:\s[^>]*)?>\/?>/g, "").replace(/<\/(?:\w+:)?artifact>/g, "").trim();
+    if (this.pendingTextBuffer) {
+      const cleanedText = this.pendingTextBuffer.replace(/<\/?artifact:ref(?:\s[^>]*)?>\/?>/g, "").replace(/<\/?artifact(?:\s[^>]*)?>\/?>/g, "").replace(/<\/(?:\w+:)?artifact>/g, "");
       if (cleanedText) {
         this.collectedParts.push({
           kind: "text",
@@ -3195,6 +3235,9 @@ var IncrementalStreamParser = class {
       }
       this.pendingTextBuffer = "";
     }
+    this.componentSnapshots.clear();
+    this.lastStreamedComponents.clear();
+    this.componentAccumulator = {};
   }
   /**
    * Get all collected parts for building the final response
@@ -3241,30 +3284,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
    */
@@ -3285,7 +3304,7 @@ var IncrementalStreamParser = class {
       this.pendingTextBuffer += part.text;
       if (!this.artifactParser.hasIncompleteArtifact(this.pendingTextBuffer)) {
         const cleanedText = this.pendingTextBuffer.replace(/<\/?artifact:ref(?:\s[^>]*)?>\/?>/g, "").replace(/<\/?artifact(?:\s[^>]*)?>\/?>/g, "").replace(/<\/(?:\w+:)?artifact>/g, "");
-        if (cleanedText.trim()) {
+        if (cleanedText) {
           await this.streamHelper.streamText(cleanedText, 50);
         }
         this.pendingTextBuffer = "";
@@ -3293,7 +3312,7 @@ var IncrementalStreamParser = class {
     } else if (part.kind === "data" && part.data) {
       if (this.pendingTextBuffer) {
         const cleanedText = this.pendingTextBuffer.replace(/<\/?artifact:ref(?:\s[^>]*)?>\/?>/g, "").replace(/<\/?artifact(?:\s[^>]*)?>\/?>/g, "").replace(/<\/(?:\w+:)?artifact>/g, "");
-        if (cleanedText.trim()) {
+        if (cleanedText) {
           await this.streamHelper.streamText(cleanedText, 50);
         }
         this.pendingTextBuffer = "";
@@ -3307,6 +3326,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 = agentsCore.getLogger("ResponseFormatter");
@@ -3598,7 +3622,7 @@ function analyzeSelectorFailure(data, selector) {
           if (keyNestingMap.has(part)) {
             const allPaths = keyNestingMap.get(part);
             const relevantPaths = allPaths.filter(
-              (path2) => path2.includes(validPath) || validPath === ""
+              (path) => path.includes(validPath) || validPath === ""
             );
             if (relevantPaths.length > 0) {
               suggestions.push(`"${part}" exists at: ${relevantPaths.slice(0, 3).join(", ")}`);
@@ -3615,7 +3639,7 @@ function analyzeSelectorFailure(data, selector) {
       analysis.push("PATH VALID BUT FILTER FAILED");
       const allPaths = keyNestingMap.get(targetKey);
       const deeperPaths = allPaths.filter(
-        (path2) => path2.length > selector.replace(/\[.*?\]/g, "").length
+        (path) => path.length > selector.replace(/\[.*?\]/g, "").length
       );
       if (deeperPaths.length > 0) {
         suggestions.push(
@@ -4116,17 +4140,17 @@ var A2AClient = class {
    * Retry utility functions
    */
   async retry(fetchFn) {
-    const config2 = this.options.retryConfig;
-    if (!config2 || config2.strategy === "none") {
+    const config = this.options.retryConfig;
+    if (!config || config.strategy === "none") {
       return await fetchFn();
     }
-    const statusCodes = config2.statusCodes || DEFAULT_RETRY_STATUS_CODES;
+    const statusCodes = config.statusCodes || DEFAULT_RETRY_STATUS_CODES;
     return this.retryBackoff(
       this.wrapFetcher(fetchFn, {
         statusCodes,
-        retryConnectionErrors: !!config2.retryConnectionErrors
+        retryConnectionErrors: !!config.retryConnectionErrors
       }),
-      config2.backoff ?? DEFAULT_BACKOFF
+      config.backoff ?? DEFAULT_BACKOFF
     );
   }
   wrapFetcher(fn, options) {
@@ -4591,25 +4615,25 @@ var A2AClient = class {
 init_conversations();
 init_dbClient();
 var logger13 = agentsCore.getLogger("relationships Tools");
-var generateTransferToolDescription = (config2) => {
-  return `Hand off the conversation to agent ${config2.id}.
+var generateTransferToolDescription = (config) => {
+  return `Hand off the conversation to agent ${config.id}.
 
 Agent Information:
-- ID: ${config2.id}
-- Name: ${config2.name ?? "No name provided"}
-- Description: ${config2.description ?? "No description provided"}
+- ID: ${config.id}
+- Name: ${config.name ?? "No name provided"}
+- Description: ${config.description ?? "No description provided"}
 
-Hand off the conversation to agent ${config2.id} when the user's request would be better handled by this specialized agent.`;
+Hand off the conversation to agent ${config.id} when the user's request would be better handled by this specialized agent.`;
 };
-var generateDelegateToolDescription = (config2) => {
+var generateDelegateToolDescription = (config) => {
   return `Delegate a specific task to another agent.
 
 Agent Information:
-- ID: ${config2.id}
-- Name: ${config2.name}
-- Description: ${config2.description || "No description provided"}
+- ID: ${config.id}
+- Name: ${config.name}
+- Description: ${config.description || "No description provided"}
 
-Delegate a specific task to agent ${config2.id} when it seems like the agent can do relevant work.`;
+Delegate a specific task to agent ${config.id} when it seems like the agent can do relevant work.`;
 };
 var createTransferToAgentTool = ({
   transferConfig,
@@ -4695,7 +4719,8 @@ function createDelegateToAgentTool({
         const externalAgent = await agentsCore.getExternalAgent(dbClient_default)({
           scopes: {
             tenantId,
-            projectId
+            projectId,
+            graphId
           },
           agentId: delegateConfig.config.id
         });
@@ -4863,16 +4888,16 @@ var SystemPromptBuilder = class {
       throw new Error(`Template loading failed: ${error}`);
     }
   }
-  buildSystemPrompt(config2) {
+  buildSystemPrompt(config) {
     this.loadTemplates();
-    this.validateTemplateVariables(config2);
-    return this.versionConfig.assemble(this.templates, config2);
+    this.validateTemplateVariables(config);
+    return this.versionConfig.assemble(this.templates, config);
   }
-  validateTemplateVariables(config2) {
-    if (!config2) {
+  validateTemplateVariables(config) {
+    if (!config) {
       throw new Error("Configuration object is required");
     }
-    if (typeof config2 !== "object") {
+    if (typeof config !== "object") {
       throw new Error("Configuration must be an object");
     }
   }
@@ -4985,20 +5010,20 @@ var V1Config = class _V1Config {
     const firstItem = tools[0];
     return "usageGuidelines" in firstItem && !("config" in firstItem);
   }
-  assemble(templates, config2) {
+  assemble(templates, config) {
     const systemPromptTemplate = templates.get("system-prompt");
     if (!systemPromptTemplate) {
       throw new Error("System prompt template not loaded");
     }
     let systemPrompt = systemPromptTemplate;
-    systemPrompt = systemPrompt.replace("{{CORE_INSTRUCTIONS}}", config2.corePrompt);
-    const graphContextSection = this.generateGraphContextSection(config2.graphPrompt);
+    systemPrompt = systemPrompt.replace("{{CORE_INSTRUCTIONS}}", config.corePrompt);
+    const graphContextSection = this.generateGraphContextSection(config.graphPrompt);
     systemPrompt = systemPrompt.replace("{{GRAPH_CONTEXT_SECTION}}", graphContextSection);
-    const toolData = this.isToolDataArray(config2.tools) ? config2.tools : _V1Config.convertMcpToolsToToolData(config2.tools);
-    const hasDataComponents = config2.dataComponents && config2.dataComponents.length > 0;
+    const toolData = this.isToolDataArray(config.tools) ? config.tools : _V1Config.convertMcpToolsToToolData(config.tools);
+    const hasDataComponents = config.dataComponents && config.dataComponents.length > 0;
     const artifactsSection = this.generateArtifactsSection(
       templates,
-      config2.artifacts,
+      config.artifacts,
       hasDataComponents
     );
     systemPrompt = systemPrompt.replace("{{ARTIFACTS_SECTION}}", artifactsSection);
@@ -5006,20 +5031,20 @@ var V1Config = class _V1Config {
     systemPrompt = systemPrompt.replace("{{TOOLS_SECTION}}", toolsSection);
     const dataComponentsSection = this.generateDataComponentsSection(
       templates,
-      config2.dataComponents
+      config.dataComponents
     );
     systemPrompt = systemPrompt.replace("{{DATA_COMPONENTS_SECTION}}", dataComponentsSection);
     const thinkingPreparationSection = this.generateThinkingPreparationSection(
       templates,
-      config2.isThinkingPreparation
+      config.isThinkingPreparation
     );
     systemPrompt = systemPrompt.replace(
       "{{THINKING_PREPARATION_INSTRUCTIONS}}",
       thinkingPreparationSection
     );
-    const transferSection = this.generateTransferInstructions(config2.hasTransferRelations);
+    const transferSection = this.generateTransferInstructions(config.hasTransferRelations);
     systemPrompt = systemPrompt.replace("{{TRANSFER_INSTRUCTIONS}}", transferSection);
-    const delegationSection = this.generateDelegationInstructions(config2.hasDelegateRelations);
+    const delegationSection = this.generateDelegationInstructions(config.hasDelegateRelations);
     systemPrompt = systemPrompt.replace("{{DELEGATION_INSTRUCTIONS}}", delegationSection);
     return systemPrompt;
   }
@@ -5283,7 +5308,7 @@ function isValidTool(tool4) {
   return tool4 && typeof tool4 === "object" && typeof tool4.description === "string" && tool4.inputSchema && typeof tool4.execute === "function";
 }
 var Agent = class {
-  constructor(config2, credentialStoreRegistry) {
+  constructor(config, credentialStoreRegistry) {
     __publicField(this, "config");
     __publicField(this, "systemPromptBuilder", new SystemPromptBuilder("v1", new V1Config()));
     __publicField(this, "responseFormatter");
@@ -5295,26 +5320,43 @@ var Agent = class {
     __publicField(this, "isDelegatedAgent", false);
     __publicField(this, "contextResolver");
     __publicField(this, "credentialStoreRegistry");
-    this.artifactComponents = config2.artifactComponents || [];
-    let processedDataComponents = config2.dataComponents || [];
-    if (this.artifactComponents.length > 0 && config2.dataComponents && config2.dataComponents.length > 0) {
+    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(config2.tenantId, config2.projectId),
+        ArtifactReferenceSchema.getDataComponent(config.tenantId, config.projectId),
         ...processedDataComponents
       ];
     }
     this.config = {
-      ...config2,
+      ...config,
       dataComponents: processedDataComponents,
       // Set default conversation history if not provided
-      conversationHistoryConfig: config2.conversationHistoryConfig || createDefaultConversationHistoryConfig()
+      conversationHistoryConfig: config.conversationHistoryConfig || createDefaultConversationHistoryConfig()
     };
-    this.responseFormatter = new ResponseFormatter(config2.tenantId);
+    this.responseFormatter = new ResponseFormatter(config.tenantId);
     this.credentialStoreRegistry = credentialStoreRegistry;
     if (credentialStoreRegistry) {
       this.contextResolver = new agentsCore.ContextResolver(
-        config2.tenantId,
-        config2.projectId,
+        config.tenantId,
+        config.projectId,
         dbClient_default,
         credentialStoreRegistry
       );
@@ -5567,8 +5609,12 @@ var Agent = class {
   async getMcpTool(tool4) {
     const credentialReferenceId = tool4.credentialReferenceId;
     const toolsForAgent = await agentsCore.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;
@@ -5715,9 +5761,9 @@ var Agent = class {
       const graphDefinition = await agentsCore.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) {
@@ -5739,14 +5785,16 @@ var Agent = class {
       const graphDefinition = await agentsCore.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(
         {
@@ -5774,7 +5822,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.
@@ -5782,7 +5831,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.
@@ -5792,7 +5842,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;
@@ -5862,7 +5912,7 @@ Key requirements:
         );
       }
     }
-    const config2 = {
+    const config = {
       corePrompt: processedPrompt,
       graphPrompt,
       tools: toolDefinitions,
@@ -5872,7 +5922,7 @@ Key requirements:
       hasTransferRelations: (this.config.transferRelations?.length ?? 0) > 0,
       hasDelegateRelations: (this.config.delegateRelations?.length ?? 0) > 0
     };
-    return await this.systemPromptBuilder.buildSystemPrompt(config2);
+    return await this.systemPromptBuilder.buildSystemPrompt(config);
   }
   getArtifactTools() {
     return ai.tool({
@@ -5943,9 +5993,9 @@ Key requirements:
       return await agentsCore.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(
@@ -6291,35 +6341,94 @@ ${output}`;
               this.getStructuredOutputModel()
             );
             const phase2TimeoutMs = structuredModelSettings.maxDuration ? structuredModelSettings.maxDuration * 1e3 : CONSTANTS.PHASE_2_TIMEOUT_MS;
-            const structuredResponse = await ai.generateObject({
-              ...structuredModelSettings,
-              messages: [
-                { role: "user", content: userMessage },
-                ...reasoningFlow,
-                {
-                  role: "user",
-                  content: await this.buildPhase2SystemPrompt()
-                }
-              ],
-              schema: z5.z.object({
-                dataComponents: z5.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 = ai.streamObject({
+                ...structuredModelSettings,
+                messages: [
+                  { role: "user", content: userMessage },
+                  ...reasoningFlow,
+                  {
+                    role: "user",
+                    content: await this.buildPhase2SystemPrompt()
+                  }
+                ],
+                schema: z5.z.object({
+                  dataComponents: z5.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 ai.generateObject({
+                ...structuredModelSettings,
+                messages: [
+                  { role: "user", content: userMessage },
+                  ...reasoningFlow,
+                  {
+                    role: "user",
+                    content: await this.buildPhase2SystemPrompt()
+                  }
+                ],
+                schema: z5.z.object({
+                  dataComponents: z5.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 || "";
           }
@@ -6365,42 +6474,6 @@ ${output}`;
   }
 };
 
-// src/utils/model-resolver.ts
-init_dbClient();
-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 agentsCore.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 agentsCore.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) {
   return traverse__default.default(data).map(function(x) {
@@ -6413,7 +6486,7 @@ function parseEmbeddedJson(data) {
   });
 }
 var logger16 = agentsCore.getLogger("generateTaskHandler");
-var createTaskHandler = (config2, credentialStoreRegistry) => {
+var createTaskHandler = (config, credentialStoreRegistry) => {
   return async (task) => {
     try {
       const userMessage = task.input.parts.filter((part) => part.text).map((part) => part.text).join(" ");
@@ -6434,32 +6507,35 @@ var createTaskHandler = (config2, credentialStoreRegistry) => {
       ] = await Promise.all([
         agentsCore.getRelatedAgentsForGraph(dbClient_default)({
           scopes: {
-            tenantId: config2.tenantId,
-            projectId: config2.projectId
+            tenantId: config.tenantId,
+            projectId: config.projectId,
+            graphId: config.graphId
           },
-          graphId: config2.graphId,
-          agentId: config2.agentId
+          agentId: config.agentId
         }),
         agentsCore.getToolsForAgent(dbClient_default)({
           scopes: {
-            tenantId: config2.tenantId,
-            projectId: config2.projectId
-          },
-          agentId: config2.agentId
+            tenantId: config.tenantId,
+            projectId: config.projectId,
+            graphId: config.graphId,
+            agentId: config.agentId
+          }
         }),
         agentsCore.getDataComponentsForAgent(dbClient_default)({
           scopes: {
-            tenantId: config2.tenantId,
-            projectId: config2.projectId
-          },
-          agentId: config2.agentId
+            tenantId: config.tenantId,
+            projectId: config.projectId,
+            graphId: config.graphId,
+            agentId: config.agentId
+          }
         }),
         agentsCore.getArtifactComponentsForAgent(dbClient_default)({
           scopes: {
-            tenantId: config2.tenantId,
-            projectId: config2.projectId
-          },
-          agentId: config2.agentId
+            tenantId: config.tenantId,
+            projectId: config.projectId,
+            graphId: config.graphId,
+            agentId: config.agentId
+          }
         })
       ]);
       logger16.info({ toolsForAgent, internalRelations, externalRelations }, "agent stuff");
@@ -6467,13 +6543,16 @@ var createTaskHandler = (config2, credentialStoreRegistry) => {
         internalRelations.map(async (relation) => {
           try {
             const relatedAgent = await agentsCore.getAgentById(dbClient_default)({
-              scopes: { tenantId: config2.tenantId, projectId: config2.projectId },
+              scopes: {
+                tenantId: config.tenantId,
+                projectId: config.projectId,
+                graphId: config.graphId
+              },
               agentId: relation.id
             });
             if (relatedAgent) {
               const relatedAgentRelations = await agentsCore.getRelatedAgentsForGraph(dbClient_default)({
-                scopes: { tenantId: config2.tenantId, projectId: config2.projectId },
-                graphId: config2.graphId,
+                scopes: { tenantId: config.tenantId, projectId: config.projectId, graphId: config.graphId },
                 agentId: relation.id
               });
               const enhancedDescription = generateDescriptionWithTransfers(
@@ -6489,29 +6568,29 @@ var createTaskHandler = (config2, credentialStoreRegistry) => {
           return relation;
         })
       );
-      const agentPrompt = "prompt" in config2.agentSchema ? config2.agentSchema.prompt : "";
-      const models = "models" in config2.agentSchema ? config2.agentSchema.models : void 0;
-      const stopWhen = "stopWhen" in config2.agentSchema ? config2.agentSchema.stopWhen : void 0;
+      const agentPrompt = "prompt" in config.agentSchema ? config.agentSchema.prompt : "";
+      const models = "models" in config.agentSchema ? config.agentSchema.models : void 0;
+      const stopWhen = "stopWhen" in config.agentSchema ? config.agentSchema.stopWhen : void 0;
       const agent = new Agent(
         {
-          id: config2.agentId,
-          tenantId: config2.tenantId,
-          projectId: config2.projectId,
-          graphId: config2.graphId,
-          baseUrl: config2.baseUrl,
-          apiKey: config2.apiKey,
-          name: config2.name,
-          description: config2.description || "",
+          id: config.agentId,
+          tenantId: config.tenantId,
+          projectId: config.projectId,
+          graphId: config.graphId,
+          baseUrl: config.baseUrl,
+          apiKey: config.apiKey,
+          name: config.name,
+          description: config.description || "",
           agentPrompt,
           models: models || void 0,
           stopWhen: stopWhen || void 0,
           agentRelations: enhancedInternalRelations.map((relation) => ({
             id: relation.id,
-            tenantId: config2.tenantId,
-            projectId: config2.projectId,
-            graphId: config2.graphId,
-            baseUrl: config2.baseUrl,
-            apiKey: config2.apiKey,
+            tenantId: config.tenantId,
+            projectId: config.projectId,
+            graphId: config.graphId,
+            baseUrl: config.baseUrl,
+            apiKey: config.apiKey,
             name: relation.name,
             description: relation.description,
             agentPrompt: "",
@@ -6520,12 +6599,12 @@ var createTaskHandler = (config2, credentialStoreRegistry) => {
             transferRelations: []
           })),
           transferRelations: enhancedInternalRelations.filter((relation) => relation.relationType === "transfer").map((relation) => ({
-            baseUrl: config2.baseUrl,
-            apiKey: config2.apiKey,
+            baseUrl: config.baseUrl,
+            apiKey: config.apiKey,
             id: relation.id,
-            tenantId: config2.tenantId,
-            projectId: config2.projectId,
-            graphId: config2.graphId,
+            tenantId: config.tenantId,
+            projectId: config.projectId,
+            graphId: config.graphId,
             name: relation.name,
             description: relation.description,
             agentPrompt: "",
@@ -6539,11 +6618,11 @@ var createTaskHandler = (config2, credentialStoreRegistry) => {
               type: "internal",
               config: {
                 id: relation.id,
-                tenantId: config2.tenantId,
-                projectId: config2.projectId,
-                graphId: config2.graphId,
-                baseUrl: config2.baseUrl,
-                apiKey: config2.apiKey,
+                tenantId: config.tenantId,
+                projectId: config.projectId,
+                graphId: config.graphId,
+                baseUrl: config.baseUrl,
+                apiKey: config.apiKey,
                 name: relation.name,
                 description: relation.description,
                 agentPrompt: "",
@@ -6578,8 +6657,8 @@ var createTaskHandler = (config2, credentialStoreRegistry) => {
           // All tools are now handled via MCP servers
           dataComponents,
           artifactComponents,
-          contextConfigId: config2.contextConfigId || void 0,
-          conversationHistoryConfig: config2.conversationHistoryConfig
+          contextConfigId: config.contextConfigId || void 0,
+          conversationHistoryConfig: config.conversationHistoryConfig
         },
         credentialStoreRegistry
       );
@@ -6592,7 +6671,7 @@ var createTaskHandler = (config2, credentialStoreRegistry) => {
             {
               taskId: task.id,
               extractedContextId: contextId,
-              agentId: config2.agentId
+              agentId: config.agentId
             },
             "Extracted contextId from task ID for delegation"
           );
@@ -6605,7 +6684,7 @@ var createTaskHandler = (config2, credentialStoreRegistry) => {
       agent.setDelegationStatus(isDelegation);
       if (isDelegation) {
         logger16.info(
-          { agentId: config2.agentId, taskId: task.id },
+          { agentId: config.agentId, taskId: task.id },
           "Delegated agent - streaming disabled"
         );
       }
@@ -6617,7 +6696,7 @@ var createTaskHandler = (config2, credentialStoreRegistry) => {
           threadId: contextId,
           // using conversationId as threadId for now
           streamRequestId,
-          ...config2.apiKey ? { apiKey: config2.apiKey } : {}
+          ...config.apiKey ? { apiKey: config.apiKey } : {}
         }
       });
       const stepContents = response.steps && Array.isArray(response.steps) ? response.steps.flatMap((step) => {
@@ -6696,16 +6775,17 @@ var createTaskHandlerConfig = async (params) => {
   const agent = await agentsCore.getAgentById(dbClient_default)({
     scopes: {
       tenantId: params.tenantId,
-      projectId: params.projectId
+      projectId: params.projectId,
+      graphId: params.graphId
     },
     agentId: params.agentId
   });
-  const agentGraph = await agentsCore.getAgentGraph(dbClient_default)({
+  const agentGraph = await agentsCore.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}`);
@@ -6745,10 +6825,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 agentsCore.getAgentById(dbClient_default)({
       scopes: {
         tenantId: dbGraph.tenantId,
-        projectId: dbGraph.projectId
+        projectId: dbGraph.projectId,
+        graphId: dbGraph.id
       },
       agentId: dbGraph.defaultAgentId
     });
@@ -6803,7 +6887,7 @@ async function hydrateGraph({
 }
 async function getRegisteredGraph(executionContext) {
   const { tenantId, projectId, graphId, baseUrl, apiKey } = executionContext;
-  const dbGraph = await agentsCore.getAgentGraph(dbClient_default)({ scopes: { tenantId, projectId }, graphId });
+  const dbGraph = await agentsCore.getAgentGraphById(dbClient_default)({ scopes: { tenantId, projectId, graphId } });
   if (!dbGraph) {
     return null;
   }
@@ -6862,6 +6946,7 @@ app.openapi(
     );
     const executionContext = agentsCore.getRequestExecutionContext(c);
     const { tenantId, projectId, graphId, agentId } = executionContext;
+    console.dir("executionContext", executionContext);
     if (agentId) {
       logger17.info(
         {
@@ -6877,7 +6962,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 agentsCore.createApiError({
+          code: "not_found",
+          message: "Agent not found"
+        });
       }
       return c.json(agent.agentCard);
     } else {
@@ -6892,7 +6980,10 @@ app.openapi(
       );
       const graph = await getRegisteredGraph(executionContext);
       if (!graph) {
-        return c.json({ error: "Graph not found" }, 404);
+        throw agentsCore.createApiError({
+          code: "not_found",
+          message: "Graph not found"
+        });
       }
       return c.json(graph.agentCard);
     }
@@ -6949,8 +7040,7 @@ app.post("/a2a", async (c) => {
       "graph-level a2a endpoint"
     );
     const graph = await agentsCore.getAgentGraphWithDefaultAgent(dbClient_default)({
-      scopes: { tenantId, projectId },
-      graphId
+      scopes: { tenantId, projectId, graphId }
     });
     if (!graph) {
       return c.json(
@@ -6962,6 +7052,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);
@@ -7005,6 +7105,9 @@ function isTransferResponse(result) {
     (artifact) => artifact.parts.some((part) => part.kind === "data" && part.data?.type === "transfer")
   );
 }
+
+// src/handlers/executionHandler.ts
+init_dbClient();
 var SSEStreamHelper = class {
   constructor(stream2, requestId2, timestamp) {
     this.stream = stream2;
@@ -7012,7 +7115,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
@@ -7077,9 +7180,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}`);
@@ -7103,22 +7207,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({
@@ -7137,16 +7225,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();
@@ -7156,15 +7251,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);
@@ -7184,7 +7295,7 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
     __publicField(this, "isCompleted", false);
     // Stream queuing for proper event ordering
     __publicField(this, "isTextStreaming", false);
-    __publicField(this, "queuedOperations", []);
+    __publicField(this, "queuedEvents", []);
     // Timing tracking for text sequences (text-end to text-start gap)
     __publicField(this, "lastTextEndTimestamp", 0);
     __publicField(this, "TEXT_GAP_THRESHOLD", 50);
@@ -7296,15 +7407,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));
@@ -7316,20 +7436,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
@@ -7343,7 +7449,7 @@ var _VercelDataStreamHelper = class _VercelDataStreamHelper {
     this.sentItems.clear();
     this.completedItems.clear();
     this.textId = null;
-    this.queuedOperations = [];
+    this.queuedEvents = [];
     this.isTextStreaming = false;
   }
   /**
@@ -7409,7 +7515,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) {
@@ -7432,23 +7540,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();
@@ -7462,19 +7580,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);
@@ -7487,6 +7619,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");
@@ -7505,18 +7638,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
    */
@@ -7535,7 +7677,6 @@ function createMCPStreamHelper() {
 }
 
 // src/handlers/executionHandler.ts
-init_dbClient();
 var logger19 = agentsCore.getLogger("ExecutionHandler");
 var ExecutionHandler = class {
   constructor() {
@@ -7564,7 +7705,7 @@ var ExecutionHandler = class {
     logger19.info({ sessionId: requestId2, graphId }, "Created GraphSession for message execution");
     let graphConfig = null;
     try {
-      graphConfig = await agentsCore.getFullGraph(dbClient_default)({ scopes: { tenantId, projectId }, graphId });
+      graphConfig = await agentsCore.getFullGraph(dbClient_default)({ scopes: { tenantId, projectId, graphId } });
       if (graphConfig?.statusUpdates && graphConfig.statusUpdates.enabled !== false) {
         graphSessionManager.initializeStatusUpdates(
           requestId2,
@@ -7718,7 +7859,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 agentsCore.updateTask(dbClient_default)({
@@ -7859,7 +7999,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 agentsCore.updateTask(dbClient_default)({
@@ -7881,7 +8020,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 agentsCore.updateTask(dbClient_default)({
@@ -7902,8 +8040,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 agentsCore.updateTask(dbClient_default)({
           taskId: task.id,
@@ -8065,8 +8202,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
     const body = c.get("requestBody") || {};
     const conversationId = body.conversationId || nanoid.nanoid();
     const fullGraph = await agentsCore.getFullGraph(dbClient_default)({
-      scopes: { tenantId, projectId },
-      graphId
+      scopes: { tenantId, projectId, graphId }
     });
     let agentGraph;
     let defaultAgentId;
@@ -8083,16 +8219,21 @@ app2.openapi(chatCompletionsRoute, async (c) => {
       defaultAgentId = fullGraph.defaultAgentId || firstAgentId;
     } else {
       agentGraph = await agentsCore.getAgentGraphWithDefaultAgent(dbClient_default)({
-        scopes: { tenantId, projectId },
-        graphId
+        scopes: { tenantId, projectId, graphId }
       });
       if (!agentGraph) {
-        return c.json({ error: "Agent graph not found" }, 404);
+        throw agentsCore.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 agentsCore.createApiError({
+        code: "not_found",
+        message: "No default agent found in graph"
+      });
     }
     await agentsCore.createOrGetConversation(dbClient_default)({
       tenantId,
@@ -8113,26 +8254,30 @@ app2.openapi(chatCompletionsRoute, async (c) => {
     }
     const agentId = activeAgent?.activeAgentId || defaultAgentId;
     const agentInfo = await agentsCore.getAgentById(dbClient_default)({
-      scopes: { tenantId, projectId },
+      scopes: { tenantId, projectId, graphId },
       agentId
     });
     if (!agentInfo) {
-      return c.json({ error: "Agent not found" }, 404);
+      throw agentsCore.createApiError({
+        code: "not_found",
+        message: "Agent not found"
+      });
     }
     const validatedContext = c.get("validatedContext") || body.requestContext || {};
     const credentialStores = c.get("credentialStores");
-    await agentsCore.handleContextResolution(
+    await agentsCore.handleContextResolution({
       tenantId,
       projectId,
-      conversationId,
       graphId,
-      validatedContext,
-      dbClient_default,
+      conversationId,
+      requestContext: validatedContext,
+      dbClient: dbClient_default,
       credentialStores
-    );
+    });
     logger20.info(
       {
         tenantId,
+        projectId,
         graphId,
         conversationId,
         defaultAgentId,
@@ -8174,41 +8319,69 @@ app2.openapi(chatCompletionsRoute, async (c) => {
       });
     }
     return streaming.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 agentsCore.createApiError({
+      code: "internal_server_error",
+      message: error instanceof Error ? error.message : "Failed to process chat completion"
+    });
   }
 });
 var getMessageText = (content) => {
@@ -8275,6 +8448,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
   try {
     const executionContext = agentsCore.getRequestExecutionContext(c);
     const { tenantId, projectId, graphId } = executionContext;
+    agentsCore.loggerFactory.getLogger("chatDataStream").debug({ tenantId, projectId, graphId }, "Extracted chatDataStream parameters");
     const body = c.get("requestBody") || {};
     const conversationId = body.conversationId || nanoid.nanoid();
     const activeSpan = api.trace.getActiveSpan();
@@ -8287,14 +8461,22 @@ app3.openapi(chatDataStreamRoute, async (c) => {
       });
     }
     const agentGraph = await agentsCore.getAgentGraphWithDefaultAgent(dbClient_default)({
-      scopes: { tenantId, projectId },
-      graphId
+      scopes: { tenantId, projectId, graphId }
     });
     if (!agentGraph) {
-      return c.json({ error: "Agent graph not found" }, 404);
+      throw agentsCore.createApiError({
+        code: "not_found",
+        message: "Agent graph not found"
+      });
     }
     const defaultAgentId = agentGraph.defaultAgentId;
     const graphName = agentGraph.name;
+    if (!defaultAgentId) {
+      throw agentsCore.createApiError({
+        code: "bad_request",
+        message: "Graph does not have a default agent configured"
+      });
+    }
     const activeAgent = await agentsCore.getActiveAgentForConversation(dbClient_default)({
       scopes: { tenantId, projectId },
       conversationId
@@ -8308,23 +8490,26 @@ app3.openapi(chatDataStreamRoute, async (c) => {
     }
     const agentId = activeAgent?.activeAgentId || defaultAgentId;
     const agentInfo = await agentsCore.getAgentById(dbClient_default)({
-      scopes: { tenantId, projectId },
+      scopes: { tenantId, projectId, graphId },
       agentId
     });
     if (!agentInfo) {
-      return c.json({ error: "Agent not found" }, 404);
+      throw agentsCore.createApiError({
+        code: "not_found",
+        message: "Agent not found"
+      });
     }
     const validatedContext = c.get("validatedContext") || body.requestContext || {};
     const credentialStores = c.get("credentialStores");
-    await agentsCore.handleContextResolution(
+    await agentsCore.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");
@@ -8366,11 +8551,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();
@@ -8391,7 +8576,10 @@ app3.openapi(chatDataStreamRoute, async (c) => {
     );
   } catch (error) {
     logger21.error({ error }, "chatDataStream error");
-    return c.json({ error: "Failed to process chat completion" }, 500);
+    throw agentsCore.createApiError({
+      code: "internal_server_error",
+      message: "Failed to process chat completion"
+    });
   }
 });
 var chatDataStream_default = app3;
@@ -8596,8 +8784,7 @@ var getServer = async (requestContext, executionContext, conversationId, credent
   const { tenantId, projectId, graphId } = executionContext;
   setupTracing(conversationId, tenantId, graphId);
   const agentGraph = await agentsCore.getAgentGraphWithDefaultAgent(dbClient_default)({
-    scopes: { tenantId, projectId },
-    graphId
+    scopes: { tenantId, projectId, graphId }
   });
   if (!agentGraph) {
     throw new Error("Agent graph not found");
@@ -8617,9 +8804,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 agentsCore.getAgentById(dbClient_default)({
-          scopes: { tenantId, projectId },
+          scopes: { tenantId, projectId, graphId },
           agentId: defaultAgentId
         });
         if (!agentInfo) {
@@ -8633,18 +8831,19 @@ var getServer = async (requestContext, executionContext, conversationId, credent
             isError: true
           };
         }
-        const resolvedContext = await agentsCore.handleContextResolution(
+        const resolvedContext = await agentsCore.handleContextResolution({
           tenantId,
           projectId,
-          conversationId,
           graphId,
+          conversationId,
           requestContext,
-          dbClient_default,
+          dbClient: dbClient_default,
           credentialStores
-        );
+        });
         logger22.info(
           {
             tenantId,
+            projectId,
             graphId,
             conversationId,
             hasContextConfig: !!agentGraph.contextConfigId,
@@ -8706,8 +8905,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
   logger22.info({ body }, "Received initialization request");
   const sessionId = nanoid.nanoid();
   const agentGraph = await agentsCore.getAgentGraphWithDefaultAgent(dbClient_default)({
-    scopes: { tenantId, projectId },
-    graphId
+    scopes: { tenantId, projectId, graphId }
   });
   if (!agentGraph) {
     return c.json(
@@ -8719,6 +8917,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 agentsCore.createOrGetConversation(dbClient_default)({
     id: sessionId,
     tenantId,
@@ -8915,6 +9123,8 @@ app4.delete("/", async (c) => {
   );
 });
 var mcp_default = app4;
+
+// src/app.ts
 var logger23 = agentsCore.getLogger("agents-run-api");
 function createExecutionHono(serverConfig, credentialStores) {
   const app6 = new zodOpenapi.OpenAPIHono();
@@ -9139,9 +9349,9 @@ var defaultStores = agentsCore.createDefaultCredentialStores();
 var defaultRegistry = new agentsCore.CredentialStoreRegistry(defaultStores);
 var app5 = createExecutionHono(defaultConfig, defaultRegistry);
 var index_default = app5;
-function createExecutionApp(config2) {
-  const serverConfig = config2?.serverConfig ?? defaultConfig;
-  const stores = config2?.credentialStores ?? defaultStores;
+function createExecutionApp(config) {
+  const serverConfig = config?.serverConfig ?? defaultConfig;
+  const stores = config?.credentialStores ?? defaultStores;
   const registry = new agentsCore.CredentialStoreRegistry(stores);
   return createExecutionHono(serverConfig, registry);
 }