@inkeep/agents-run-api 0.26.2 → 0.28.0

package/dist/index.js

@@ -1,10 +1,10 @@
-import { flushBatchProcessor } from './chunk-TVLDBLRZ.js';
-import { getFormattedConversationHistory, createDefaultConversationHistoryConfig, saveA2AMessageResponse } from './chunk-XLUE6U2L.js';
-import { dbClient_default } from './chunk-IBMWBEXH.js';
-import { env } from './chunk-LHCIBW34.js';
+import { flushBatchProcessor } from './chunk-DWEFKQTA.js';
+import { getFormattedConversationHistory, createDefaultConversationHistoryConfig, saveA2AMessageResponse } from './chunk-IMJLQGAX.js';
+import { dbClient_default } from './chunk-TRNLEUK2.js';
+import { env } from './chunk-Z4TYO3W3.js';
 import { getLogger } from './chunk-A2S7GSHL.js';
 import { __publicField } from './chunk-PKBMQBKP.js';
-import { getTracer, HeadersScopeSchema, getRequestExecutionContext, createApiError, getAgentWithDefaultSubAgent, contextValidationMiddleware, getConversationId, getFullAgent, createOrGetConversation, getActiveAgentForConversation, setActiveAgentForConversation, getSubAgentById, handleContextResolution, createMessage, generateId, commonGetErrorResponses, loggerFactory, getDataComponent, getProject, createDefaultCredentialStores, CredentialStoreRegistry, listTaskIdsByContextId, getTask, getLedgerArtifacts, upsertLedgerArtifact, createTask, updateTask, setSpanWithError, updateConversation, handleApiError, TaskState, setActiveAgentForThread, getConversation, getAgentById, getRelatedAgentsForAgent, getExternalAgentsForSubAgent, getToolsForAgent, getDataComponentsForAgent, getArtifactComponentsForAgent, dbResultToMcpTool, validateAndGetApiKey, ContextResolver, CredentialStuffer, MCPServerType, getCredentialReference, McpClient, getFunctionToolsForSubAgent, getFunction, getContextConfigById, getFullAgentDefinition, TemplateEngine, agentHasArtifactComponents, MCPTransportType, SPAN_KEYS } from '@inkeep/agents-core';
+import { getTracer, HeadersScopeSchema, getRequestExecutionContext, createApiError, getAgentWithDefaultSubAgent, contextValidationMiddleware, getConversationId, getFullAgent, createOrGetConversation, getActiveAgentForConversation, setActiveAgentForConversation, getSubAgentById, handleContextResolution, createMessage, generateId, commonGetErrorResponses, loggerFactory, getDataComponent, getProject, createDefaultCredentialStores, CredentialStoreRegistry, listTaskIdsByContextId, getTask, getLedgerArtifacts, upsertLedgerArtifact, createTask, updateTask, setSpanWithError, updateConversation, handleApiError, TaskState, setActiveAgentForThread, getConversation, getAgentById, getRelatedAgentsForAgent, getExternalAgentsForSubAgent, getTeamAgentsForSubAgent, getToolsForAgent, getDataComponentsForAgent, getArtifactComponentsForAgent, dbResultToMcpTool, validateAndGetApiKey, verifyServiceToken, validateTargetAgent, ContextResolver, CredentialStuffer, MCPServerType, getCredentialReference, McpClient, getFunctionToolsForSubAgent, getFunction, getContextConfigById, getFullAgentDefinition, TemplateEngine, agentHasArtifactComponents, MCPTransportType, SPAN_KEYS, headers, generateServiceToken } from '@inkeep/agents-core';
 import { otel } from '@hono/otel';
 import { OpenAPIHono, createRoute, z as z$1 } from '@hono/zod-openapi';
 import { trace, propagation, context, SpanStatusCode } from '@opentelemetry/api';
@@ -40,7 +40,8 @@ function createExecutionContext(params) {
     agentId: params.agentId,
     baseUrl: params.baseUrl || process.env.API_URL || "http://localhost:3003",
     apiKeyId: params.apiKeyId,
-    subAgentId: params.subAgentId
+    subAgentId: params.subAgentId,
+    metadata: params.metadata || {}
   };
 }
 
@@ -62,28 +63,36 @@ var apiKeyAuth = () => createMiddleware(async (c, next) => {
   const reqUrl = new URL(c.req.url);
   const baseUrl = proto && host ? `${proto}://${host}` : host ? `${reqUrl.protocol}//${host}` : `${reqUrl.origin}`;
   if (process.env.ENVIRONMENT === "development" || process.env.ENVIRONMENT === "test") {
+    logger.info({}, "development environment");
     let executionContext;
     if (authHeader?.startsWith("Bearer ")) {
+      const apiKey2 = authHeader.substring(7);
       try {
-        executionContext = await extractContextFromApiKey(authHeader.substring(7), baseUrl);
+        executionContext = await extractContextFromApiKey(apiKey2, baseUrl);
         if (subAgentId) {
           executionContext.subAgentId = subAgentId;
         }
-        logger.info({}, "Development/test environment - API key authenticated successfully");
+        c.set("executionContext", executionContext);
       } catch {
-        executionContext = createExecutionContext({
-          apiKey: "development",
-          tenantId: tenantId || "test-tenant",
-          projectId: projectId || "test-project",
-          agentId: agentId || "test-agent",
-          apiKeyId: "test-key",
-          baseUrl,
-          subAgentId
-        });
-        logger.info(
-          {},
-          "Development/test environment - fallback to default context due to invalid API key"
-        );
+        try {
+          executionContext = await extractContextFromTeamAgentToken(apiKey2, baseUrl, subAgentId);
+          c.set("executionContext", executionContext);
+        } catch {
+          executionContext = createExecutionContext({
+            apiKey: "development",
+            tenantId: tenantId || "test-tenant",
+            projectId: projectId || "test-project",
+            agentId: agentId || "test-agent",
+            apiKeyId: "test-key",
+            baseUrl,
+            subAgentId
+          });
+          c.set("executionContext", executionContext);
+          logger.info(
+            {},
+            "Development/test environment - fallback to default context due to invalid API key"
+          );
+        }
       }
     } else {
       executionContext = createExecutionContext({
@@ -95,12 +104,12 @@ var apiKeyAuth = () => createMiddleware(async (c, next) => {
         baseUrl,
         subAgentId
       });
+      c.set("executionContext", executionContext);
       logger.info(
         {},
         "Development/test environment - no API key provided, using default context"
       );
     }
-    c.set("executionContext", executionContext);
     await next();
     return;
   }
@@ -131,12 +140,21 @@ var apiKeyAuth = () => createMiddleware(async (c, next) => {
       await next();
       return;
     } else if (apiKey) {
-      const executionContext = await extractContextFromApiKey(apiKey, baseUrl);
-      if (subAgentId) {
-        executionContext.subAgentId = subAgentId;
+      try {
+        const executionContext = await extractContextFromApiKey(apiKey, baseUrl);
+        if (subAgentId) {
+          executionContext.subAgentId = subAgentId;
+        }
+        c.set("executionContext", executionContext);
+        logger.info({}, "API key authenticated successfully");
+      } catch {
+        const executionContext = await extractContextFromTeamAgentToken(
+          apiKey,
+          baseUrl,
+          subAgentId
+        );
+        c.set("executionContext", executionContext);
       }
-      c.set("executionContext", executionContext);
-      logger.info({}, "API key authenticated successfully");
       await next();
       return;
     } else {
@@ -166,14 +184,24 @@ var apiKeyAuth = () => createMiddleware(async (c, next) => {
       "API key authenticated successfully"
     );
     await next();
-  } catch (error) {
-    if (error instanceof HTTPException) {
-      throw error;
+  } catch {
+    try {
+      const executionContext = await extractContextFromTeamAgentToken(
+        apiKey,
+        baseUrl,
+        subAgentId
+      );
+      c.set("executionContext", executionContext);
+      await next();
+    } catch (error) {
+      if (error instanceof HTTPException) {
+        throw error;
+      }
+      logger.error({ error }, "API key authentication error");
+      throw new HTTPException(500, {
+        message: "Authentication failed"
+      });
     }
-    logger.error({ error }, "API key authentication error");
-    throw new HTTPException(500, {
-      message: "Authentication failed"
-    });
   }
 });
 var extractContextFromApiKey = async (apiKey, baseUrl) => {
@@ -195,8 +223,15 @@ var extractContextFromApiKey = async (apiKey, baseUrl) => {
       message: "Invalid or expired API key"
     });
   }
-  logger.info({ agent }, "agent");
-  logger.info({ defaultSubAgentId: agent.defaultSubAgentId }, "agent.defaultSubAgentId");
+  logger.debug(
+    {
+      tenantId: apiKeyRecord.tenantId,
+      projectId: apiKeyRecord.projectId,
+      agentId: apiKeyRecord.agentId,
+      subAgentId: agent.defaultSubAgentId || void 0
+    },
+    "API key authenticated successfully"
+  );
   return createExecutionContext({
     apiKey,
     tenantId: apiKeyRecord.tenantId,
@@ -207,6 +242,53 @@ var extractContextFromApiKey = async (apiKey, baseUrl) => {
     subAgentId: agent.defaultSubAgentId || void 0
   });
 };
+var extractContextFromTeamAgentToken = async (token, baseUrl, expectedSubAgentId) => {
+  const result = await verifyServiceToken(token);
+  if (!result.valid || !result.payload) {
+    logger.warn({ error: result.error }, "Invalid team agent JWT token");
+    throw new HTTPException(401, {
+      message: `Invalid team agent token: ${result.error || "Unknown error"}`
+    });
+  }
+  const payload = result.payload;
+  if (expectedSubAgentId && !validateTargetAgent(payload, expectedSubAgentId)) {
+    logger.error(
+      {
+        tokenTargetAgentId: payload.aud,
+        expectedSubAgentId,
+        originAgentId: payload.sub
+      },
+      "Team agent token target mismatch"
+    );
+    throw new HTTPException(403, {
+      message: "Token not valid for the requested agent"
+    });
+  }
+  logger.info(
+    {
+      originAgentId: payload.sub,
+      targetAgentId: payload.aud,
+      tenantId: payload.tenantId,
+      projectId: payload.projectId
+    },
+    "Team agent JWT token authenticated successfully"
+  );
+  return createExecutionContext({
+    apiKey: "team-agent-jwt",
+    // Not an actual API key
+    tenantId: payload.tenantId,
+    projectId: payload.projectId,
+    agentId: payload.aud,
+    // Target agent ID
+    apiKeyId: "team-agent-token",
+    baseUrl,
+    subAgentId: void 0,
+    metadata: {
+      teamDelegation: true,
+      originAgentId: payload.sub
+    }
+  });
+};
 function setupOpenAPIRoutes(app7) {
   app7.get("/openapi.json", (c) => {
     try {
@@ -387,7 +469,7 @@ async function handleMessageSend(c, agent, request) {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     logger2.info({ metadata: params.message.metadata }, "message metadata");
-    if (params.message.metadata?.fromSubAgentId || params.message.metadata?.fromExternalAgentId) {
+    if (params.message.metadata?.fromSubAgentId || params.message.metadata?.fromExternalAgentId || params.message.metadata?.fromTeamAgentId) {
       const messageText = params.message.parts.filter((part) => part.kind === "text" && "text" in part && part.text).map((part) => part.text).join(" ");
       try {
         const messageData = {
@@ -409,13 +491,18 @@ async function handleMessageSend(c, agent, request) {
         } else if (params.message.metadata?.fromExternalAgentId) {
           messageData.fromExternalAgentId = params.message.metadata.fromExternalAgentId;
           messageData.toSubAgentId = agent.subAgentId;
+        } else if (params.message.metadata?.fromTeamAgentId) {
+          messageData.fromTeamAgentId = params.message.metadata.fromTeamAgentId;
+          messageData.toTeamAgentId = agent.subAgentId;
         }
         await createMessage(dbClient_default)(messageData);
         logger2.info(
           {
             fromSubAgentId: params.message.metadata.fromSubAgentId,
             fromExternalAgentId: params.message.metadata.fromExternalAgentId,
+            fromTeamAgentId: params.message.metadata.fromTeamAgentId,
             toSubAgentId: agent.subAgentId,
+            toTeamAgentId: params.message.metadata.fromTeamAgentId ? agent.subAgentId : void 0,
             conversationId: effectiveContextId,
             messageType: "a2a-request",
             taskId: task.id
@@ -428,6 +515,7 @@ async function handleMessageSend(c, agent, request) {
             error,
             fromSubAgentId: params.message.metadata.fromSubAgentId,
             fromExternalAgentId: params.message.metadata.fromExternalAgentId,
+            fromTeamAgentId: params.message.metadata.fromTeamAgentId,
             toSubAgentId: agent.subAgentId,
             conversationId: effectiveContextId
           },
@@ -1353,9 +1441,11 @@ var _ArtifactService = class _ArtifactService {
       const component = this.context.artifactComponents?.find((ac) => ac.name === request.type);
       let summaryData = {};
       let fullData = {};
+      let previewSchema = null;
+      let fullSchema = null;
       if (component?.props) {
-        const previewSchema = extractPreviewFields(component.props);
-        const fullSchema = extractFullFields(component.props);
+        previewSchema = extractPreviewFields(component.props);
+        fullSchema = extractFullFields(component.props);
         summaryData = this.extractPropsFromSchema(
           selectedData,
           previewSchema,
@@ -1378,6 +1468,15 @@ var _ArtifactService = class _ArtifactService {
       }
       const cleanedSummaryData = this.cleanEscapedContent(summaryData);
       const cleanedFullData = this.cleanEscapedContent(fullData);
+      const schemaValidation = this.validateExtractedData(
+        request.artifactId,
+        request.type,
+        cleanedSummaryData,
+        cleanedFullData,
+        previewSchema,
+        fullSchema,
+        component?.props
+      );
       const artifactData = {
         artifactId: request.artifactId,
         toolCallId: request.toolCallId,
@@ -1386,7 +1485,7 @@ var _ArtifactService = class _ArtifactService {
         type: request.type,
         data: cleanedSummaryData
       };
-      await this.persistArtifact(request, cleanedSummaryData, cleanedFullData, subAgentId);
+      await this.persistArtifact(request, cleanedSummaryData, cleanedFullData, subAgentId, schemaValidation);
       await this.cacheArtifact(
         request.artifactId,
         request.toolCallId,
@@ -1496,32 +1595,183 @@ var _ArtifactService = class _ArtifactService {
    * Format raw artifact to standardized summary data format
    */
   formatArtifactSummaryData(artifact, artifactId, toolCallId) {
+    let data = artifact.parts?.[0]?.data?.summary;
+    let dataSource = "parts[0].data.summary";
+    if (!data || typeof data === "object" && Object.keys(data).length === 0) {
+      data = artifact.parts?.[0]?.data;
+      if (data && !(typeof data === "object" && Object.keys(data).length === 0)) {
+        dataSource = "parts[0].data (fallback)";
+        logger6.debug(
+          { artifactId, toolCallId, dataSource },
+          "Using fallback data source for artifact summary"
+        );
+      } else {
+        data = artifact.data;
+        if (data && !(typeof data === "object" && Object.keys(data).length === 0)) {
+          dataSource = "artifact.data (fallback)";
+          logger6.debug(
+            { artifactId, toolCallId, dataSource },
+            "Using fallback data source for artifact summary"
+          );
+        } else {
+          data = {};
+          dataSource = "empty (no data found)";
+          logger6.warn(
+            {
+              artifactId,
+              toolCallId,
+              artifactStructure: {
+                hasParts: !!artifact.parts,
+                partsLength: artifact.parts?.length,
+                hasPartsData: !!artifact.parts?.[0]?.data,
+                hasPartsSummary: !!artifact.parts?.[0]?.data?.summary,
+                hasArtifactData: !!artifact.data,
+                artifactKeys: Object.keys(artifact || {})
+              }
+            },
+            "No valid data found for artifact summary - using empty object"
+          );
+        }
+      }
+    }
     return {
       artifactId,
       toolCallId,
       name: artifact.name || "Processing...",
       description: artifact.description || "Name and description being generated...",
       type: artifact.metadata?.artifactType || artifact.artifactType,
-      data: artifact.parts?.[0]?.data?.summary || {}
+      data
     };
   }
   /**
    * Format raw artifact to standardized full data format
    */
   formatArtifactFullData(artifact, artifactId, toolCallId) {
+    let data = artifact.parts?.[0]?.data?.full;
+    let dataSource = "parts[0].data.full";
+    if (!data || typeof data === "object" && Object.keys(data).length === 0) {
+      data = artifact.parts?.[0]?.data;
+      if (data && !(typeof data === "object" && Object.keys(data).length === 0)) {
+        dataSource = "parts[0].data (fallback)";
+        logger6.debug(
+          { artifactId, toolCallId, dataSource },
+          "Using fallback data source for artifact full data"
+        );
+      } else {
+        data = artifact.data;
+        if (data && !(typeof data === "object" && Object.keys(data).length === 0)) {
+          dataSource = "artifact.data (fallback)";
+          logger6.debug(
+            { artifactId, toolCallId, dataSource },
+            "Using fallback data source for artifact full data"
+          );
+        } else {
+          data = {};
+          dataSource = "empty (no data found)";
+          logger6.warn(
+            {
+              artifactId,
+              toolCallId,
+              artifactStructure: {
+                hasParts: !!artifact.parts,
+                partsLength: artifact.parts?.length,
+                hasPartsData: !!artifact.parts?.[0]?.data,
+                hasPartsFull: !!artifact.parts?.[0]?.data?.full,
+                hasArtifactData: !!artifact.data,
+                artifactKeys: Object.keys(artifact || {})
+              }
+            },
+            "No valid data found for artifact full data - using empty object"
+          );
+        }
+      }
+    }
     return {
       artifactId,
       toolCallId,
       name: artifact.name || "Processing...",
       description: artifact.description || "Name and description being generated...",
       type: artifact.metadata?.artifactType || artifact.artifactType,
-      data: artifact.parts?.[0]?.data?.full || {}
+      data
+    };
+  }
+  /**
+   * Validate extracted data against the schemas used for extraction
+   */
+  validateExtractedData(artifactId, artifactType, summaryData, fullData, previewSchema, fullSchema, originalProps) {
+    const validateAgainstSchema = (data, schema) => {
+      const actualFields = Object.keys(data || {});
+      const expectedFields = schema?.properties ? Object.keys(schema.properties) : [];
+      const missingFields = expectedFields.filter((field) => !(field in (data || {})));
+      const extraFields = actualFields.filter((field) => !expectedFields.includes(field));
+      const requiredFields = schema?.required || [];
+      const missingRequired = requiredFields.filter((field) => !(field in (data || {})));
+      return {
+        hasExpectedFields: missingFields.length === 0,
+        missingFields,
+        extraFields,
+        expectedFields,
+        actualFields,
+        hasRequiredFields: missingRequired.length === 0,
+        missingRequired
+      };
+    };
+    const summaryValidation = validateAgainstSchema(summaryData, previewSchema);
+    const fullValidation = validateAgainstSchema(fullData, fullSchema);
+    if (!summaryValidation.hasRequiredFields) {
+      const error = new Error(
+        `Cannot save artifact: Missing required fields [${summaryValidation.missingRequired.join(", ")}] for '${artifactType}' schema. Required: [${summaryValidation.missingRequired.join(", ")}]. Found: [${summaryValidation.actualFields.join(", ")}]. Consider using a different artifact component type that matches your data structure.`
+      );
+      logger6.error(
+        {
+          artifactId,
+          artifactType,
+          requiredFields: summaryValidation.missingRequired,
+          actualFields: summaryValidation.actualFields,
+          schemaExpected: previewSchema?.properties ? Object.keys(previewSchema.properties) : []
+        },
+        "Blocking artifact save due to missing required fields"
+      );
+      throw error;
+    }
+    if (!summaryValidation.hasExpectedFields || summaryValidation.extraFields.length > 0) {
+      logger6.warn(
+        {
+          artifactId,
+          artifactType,
+          dataType: "summary",
+          expectedFields: summaryValidation.expectedFields,
+          actualFields: summaryValidation.actualFields,
+          missingFields: summaryValidation.missingFields,
+          extraFields: summaryValidation.extraFields
+        },
+        "Summary data structure does not match preview schema"
+      );
+    }
+    if (!fullValidation.hasExpectedFields || fullValidation.extraFields.length > 0) {
+      logger6.warn(
+        {
+          artifactId,
+          artifactType,
+          dataType: "full",
+          expectedFields: fullValidation.expectedFields,
+          actualFields: fullValidation.actualFields,
+          missingFields: fullValidation.missingFields,
+          extraFields: fullValidation.extraFields
+        },
+        "Full data structure does not match full schema"
+      );
+    }
+    return {
+      summary: summaryValidation,
+      full: fullValidation,
+      schemaFound: !!originalProps
     };
   }
   /**
    * Persist artifact to database vian agent session
    */
-  async persistArtifact(request, summaryData, fullData, subAgentId) {
+  async persistArtifact(request, summaryData, fullData, subAgentId, schemaValidation) {
     const effectiveAgentId = subAgentId || this.context.subAgentId;
     if (this.context.streamRequestId && effectiveAgentId && this.context.taskId) {
       await agentSessionManager.recordEvent(
@@ -1543,6 +1793,11 @@ var _ArtifactService = class _ArtifactService {
             sessionId: this.context.sessionId,
             artifactType: request.type
           },
+          schemaValidation: schemaValidation || {
+            summary: { hasExpectedFields: true, missingFields: [], extraFields: [], expectedFields: [], actualFields: [], hasRequiredFields: true, missingRequired: [] },
+            full: { hasExpectedFields: true, missingFields: [], extraFields: [], expectedFields: [], actualFields: [], hasRequiredFields: true, missingRequired: [] },
+            schemaFound: false
+          },
           tenantId: this.context.tenantId,
           projectId: this.context.projectId,
           contextId: this.context.contextId,
@@ -3037,7 +3292,29 @@ ${this.statusUpdateState?.config.prompt?.trim() || ""}`;
           has_context_id: !!artifactData.contextId,
           has_metadata: !!artifactData.metadata,
           tool_call_id: artifactData.metadata?.toolCallId || "missing",
-          pending_generation: !!artifactData.pendingGeneration
+          pending_generation: !!artifactData.pendingGeneration,
+          // Schema validation attributes
+          "schema_validation.schema_found": artifactData.schemaValidation?.schemaFound || false,
+          "schema_validation.summary.has_expected_fields": artifactData.schemaValidation?.summary?.hasExpectedFields || true,
+          "schema_validation.summary.missing_fields_count": artifactData.schemaValidation?.summary?.missingFields?.length || 0,
+          "schema_validation.summary.extra_fields_count": artifactData.schemaValidation?.summary?.extraFields?.length || 0,
+          "schema_validation.summary.expected_fields": JSON.stringify(artifactData.schemaValidation?.summary?.expectedFields || []),
+          "schema_validation.summary.actual_fields": JSON.stringify(artifactData.schemaValidation?.summary?.actualFields || []),
+          "schema_validation.summary.missing_fields": JSON.stringify(artifactData.schemaValidation?.summary?.missingFields || []),
+          "schema_validation.summary.extra_fields": JSON.stringify(artifactData.schemaValidation?.summary?.extraFields || []),
+          "schema_validation.summary.has_required_fields": artifactData.schemaValidation?.summary?.hasRequiredFields || true,
+          "schema_validation.summary.missing_required_count": artifactData.schemaValidation?.summary?.missingRequired?.length || 0,
+          "schema_validation.summary.missing_required": JSON.stringify(artifactData.schemaValidation?.summary?.missingRequired || []),
+          "schema_validation.full.has_expected_fields": artifactData.schemaValidation?.full?.hasExpectedFields || true,
+          "schema_validation.full.missing_fields_count": artifactData.schemaValidation?.full?.missingFields?.length || 0,
+          "schema_validation.full.extra_fields_count": artifactData.schemaValidation?.full?.extraFields?.length || 0,
+          "schema_validation.full.expected_fields": JSON.stringify(artifactData.schemaValidation?.full?.expectedFields || []),
+          "schema_validation.full.actual_fields": JSON.stringify(artifactData.schemaValidation?.full?.actualFields || []),
+          "schema_validation.full.missing_fields": JSON.stringify(artifactData.schemaValidation?.full?.missingFields || []),
+          "schema_validation.full.extra_fields": JSON.stringify(artifactData.schemaValidation?.full?.extraFields || []),
+          "schema_validation.full.has_required_fields": artifactData.schemaValidation?.full?.hasRequiredFields || true,
+          "schema_validation.full.missing_required_count": artifactData.schemaValidation?.full?.missingRequired?.length || 0,
+          "schema_validation.full.missing_required": JSON.stringify(artifactData.schemaValidation?.full?.missingRequired || [])
         }
       },
       async (span) => {
@@ -5245,8 +5522,10 @@ function createDelegateToAgentTool({
         );
       }
       const isInternal = delegateConfig.type === "internal";
+      const isExternal = delegateConfig.type === "external";
+      const isTeam = delegateConfig.type === "team";
       let resolvedHeaders = {};
-      if (!isInternal) {
+      if (isExternal) {
         if ((delegateConfig.config.credentialReferenceId || delegateConfig.config.headers) && credentialStoreRegistry) {
           const contextResolver = new ContextResolver(
             tenantId,
@@ -5284,6 +5563,23 @@ function createDelegateToAgentTool({
             headers: delegateConfig.config.headers || void 0
           });
         }
+      } else if (isTeam) {
+        const contextResolver = new ContextResolver(
+          tenantId,
+          projectId,
+          dbClient_default,
+          credentialStoreRegistry
+        );
+        const context2 = await contextResolver.resolveHeaders(metadata.conversationId, contextId);
+        for (const [key, value] of Object.entries(headers)) {
+          resolvedHeaders[key] = TemplateEngine.render(value, context2, { strict: true });
+        }
+        resolvedHeaders.Authorization = `Bearer ${await generateServiceToken({
+          tenantId,
+          projectId,
+          originAgentId: agentId,
+          targetAgentId: delegateConfig.config.id
+        })}`;
       } else {
         resolvedHeaders = {
           Authorization: `Bearer ${metadata.apiKey}`,
@@ -7144,7 +7440,7 @@ var Agent = class {
   /**
    * Get resolved context using ContextResolver - will return cached data or fetch fresh data as needed
    */
-  async getResolvedContext(conversationId, headers) {
+  async getResolvedContext(conversationId, headers2) {
     try {
       if (!this.config.contextConfigId) {
         logger15.debug({ agentId: this.config.agentId }, "No context config found for agent");
@@ -7168,7 +7464,7 @@ var Agent = class {
       const result = await this.contextResolver.resolve(contextConfig, {
         triggerEvent: "invocation",
         conversationId,
-        headers: headers || {},
+        headers: headers2 || {},
         tenantId: this.config.tenantId
       });
       const contextWithBuiltins = {
@@ -7355,7 +7651,7 @@ var Agent = class {
       inputSchema: tool3.inputSchema || tool3.parameters || {},
       usageGuidelines: name.startsWith("transfer_to_") || name.startsWith("delegate_to_") ? `Use this tool to ${name.startsWith("transfer_to_") ? "transfer" : "delegate"} to another agent when appropriate.` : "Use this tool when appropriate for the task at hand."
     }));
-    const { getConversationScopedArtifacts } = await import('./conversations-H2TSLD3U.js');
+    const { getConversationScopedArtifacts } = await import('./conversations-V6DNH5MW.js');
     const historyConfig = this.config.conversationHistoryConfig ?? createDefaultConversationHistoryConfig();
     const referenceArtifacts = await getConversationScopedArtifacts({
       tenantId: this.config.tenantId,
@@ -8270,6 +8566,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
       const [
         internalRelations,
         externalRelations,
+        teamRelations,
         toolsForAgent,
         dataComponents,
         artifactComponents
@@ -8290,6 +8587,14 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
             subAgentId: config.subAgentId
           }
         }),
+        getTeamAgentsForSubAgent(dbClient_default)({
+          scopes: {
+            tenantId: config.tenantId,
+            projectId: config.projectId,
+            agentId: config.agentId,
+            subAgentId: config.subAgentId
+          }
+        }),
         getToolsForAgent(dbClient_default)({
           scopes: {
             tenantId: config.tenantId,
@@ -8438,6 +8743,17 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
                 relationId: relation.id,
                 relationType: "delegate"
               }
+            })),
+            ...teamRelations.data.map((relation) => ({
+              type: "team",
+              config: {
+                id: relation.targetAgent.id,
+                name: relation.targetAgent.name,
+                description: relation.targetAgent.description || "",
+                baseUrl: config.baseUrl,
+                headers: relation.headers,
+                relationId: relation.id
+              }
             }))
           ],
           tools: toolsForAgentResult,
@@ -8659,6 +8975,7 @@ var createTaskHandlerConfig = async (params) => {
 };
 
 // src/data/agents.ts
+var logger17 = getLogger("agents");
 function createAgentCard({
   dbAgent,
   baseUrl
@@ -8760,13 +9077,26 @@ async function hydrateAgent({
 async function getRegisteredAgent(params) {
   const { executionContext, credentialStoreRegistry, sandboxConfig } = params;
   const { tenantId, projectId, agentId, subAgentId, baseUrl, apiKey } = executionContext;
+  let dbAgent;
   if (!subAgentId) {
-    throw new Error("Agent ID is required");
+    const agent = await getAgentWithDefaultSubAgent(dbClient_default)({
+      scopes: { tenantId, projectId, agentId }
+    });
+    logger17.info({ agent }, "agent with default sub agent");
+    if (!agent || !agent.defaultSubAgent) {
+      return null;
+    }
+    dbAgent = agent.defaultSubAgent;
+  } else {
+    const response = await getSubAgentById(dbClient_default)({
+      scopes: { tenantId, projectId, agentId },
+      subAgentId
+    });
+    if (!response) {
+      return null;
+    }
+    dbAgent = response;
   }
-  const dbAgent = await getSubAgentById(dbClient_default)({
-    scopes: { tenantId, projectId, agentId },
-    subAgentId
-  });
   if (!dbAgent) {
     return null;
   }
@@ -8783,7 +9113,7 @@ async function getRegisteredAgent(params) {
 
 // src/routes/agents.ts
 var app = new OpenAPIHono();
-var logger17 = getLogger("agents");
+var logger18 = getLogger("agents");
 app.openapi(
   createRoute({
     method: "get",
@@ -8821,7 +9151,7 @@ app.openapi(
       tracestate: c.req.header("tracestate"),
       baggage: c.req.header("baggage")
     };
-    logger17.info(
+    logger18.info(
       {
         otelHeaders,
         path: c.req.path,
@@ -8831,56 +9161,32 @@ app.openapi(
     );
     const executionContext = getRequestExecutionContext(c);
     const { tenantId, projectId, agentId, subAgentId } = executionContext;
-    logger17.info({ executionContext }, "executionContext");
-    if (subAgentId) {
-      logger17.info(
-        {
-          message: "getRegisteredAgent (agent-level)",
-          tenantId,
-          projectId,
-          agentId,
-          subAgentId
-        },
-        "agent-level well-known agent.json"
-      );
-      const credentialStores = c.get("credentialStores");
-      const sandboxConfig = c.get("sandboxConfig");
-      const agent = await getRegisteredAgent({
-        executionContext,
-        credentialStoreRegistry: credentialStores,
-        sandboxConfig
-      });
-      logger17.info({ agent }, "agent registered: well-known agent.json");
-      if (!agent) {
-        throw createApiError({
-          code: "not_found",
-          message: "Agent not found"
-        });
-      }
-      return c.json(agent.agentCard);
-    } else {
-      logger17.info(
-        {
-          message: "getRegisteredAgent (agent-level)",
-          tenantId,
-          projectId,
-          agentId
-        },
-        "agent-level well-known agent.json"
-      );
-      const sandboxConfig = c.get("sandboxConfig");
-      const agent = await getRegisteredAgent({
-        executionContext,
-        sandboxConfig
+    logger18.info({ executionContext }, "executionContext");
+    logger18.info(
+      {
+        message: "getRegisteredAgent (agent-level)",
+        tenantId,
+        projectId,
+        agentId,
+        subAgentId
+      },
+      "agent-level well-known agent.json"
+    );
+    const credentialStores = c.get("credentialStores");
+    const sandboxConfig = c.get("sandboxConfig");
+    const agent = await getRegisteredAgent({
+      executionContext,
+      credentialStoreRegistry: credentialStores,
+      sandboxConfig
+    });
+    logger18.info({ agent }, "agent registered: well-known agent.json");
+    if (!agent) {
+      throw createApiError({
+        code: "not_found",
+        message: "Agent not found"
       });
-      if (!agent) {
-        throw createApiError({
-          code: "not_found",
-          message: "Agent not found"
-        });
-      }
-      return c.json(agent.agentCard);
     }
+    return c.json(agent.agentCard);
   }
 );
 app.post("/a2a", async (c) => {
@@ -8889,7 +9195,7 @@ app.post("/a2a", async (c) => {
     tracestate: c.req.header("tracestate"),
     baggage: c.req.header("baggage")
   };
-  logger17.info(
+  logger18.info(
     {
       otelHeaders,
       path: c.req.path,
@@ -8900,7 +9206,7 @@ app.post("/a2a", async (c) => {
   const executionContext = getRequestExecutionContext(c);
   const { tenantId, projectId, agentId, subAgentId } = executionContext;
   if (subAgentId) {
-    logger17.info(
+    logger18.info(
       {
         message: "a2a (agent-level)",
         tenantId,
@@ -8929,7 +9235,7 @@ app.post("/a2a", async (c) => {
     }
     return a2aHandler(c, agent);
   } else {
-    logger17.info(
+    logger18.info(
       {
         message: "a2a (agent-level)",
         tenantId,
@@ -9032,14 +9338,14 @@ function extractTransferData(task) {
 }
 
 // src/a2a/transfer.ts
-var logger18 = getLogger("Transfer");
+var logger19 = getLogger("Transfer");
 async function executeTransfer({
   tenantId,
   threadId,
   projectId,
   targetSubAgentId
 }) {
-  logger18.info(
+  logger19.info(
     {
       targetAgent: targetSubAgentId,
       threadId,
@@ -9054,12 +9360,12 @@ async function executeTransfer({
       threadId,
       subAgentId: targetSubAgentId
     });
-    logger18.info(
+    logger19.info(
       { targetAgent: targetSubAgentId, threadId },
       "Successfully updated active_sub_agent_id in database"
     );
   } catch (error) {
-    logger18.error(
+    logger19.error(
       { error, targetAgent: targetSubAgentId, threadId },
       "Failed to update active_sub_agent_id"
     );
@@ -9630,7 +9936,7 @@ function createMCPStreamHelper() {
 }
 
 // src/handlers/executionHandler.ts
-var logger19 = getLogger("ExecutionHandler");
+var logger20 = getLogger("ExecutionHandler");
 var ExecutionHandler = class {
   constructor() {
     __publicField(this, "MAX_ERRORS", 3);
@@ -9665,7 +9971,7 @@ var ExecutionHandler = class {
     if (emitOperations) {
       agentSessionManager.enableEmitOperations(requestId2);
     }
-    logger19.info(
+    logger20.info(
       { sessionId: requestId2, agentId, conversationId, emitOperations },
       "Created AgentSession for message execution"
     );
@@ -9682,7 +9988,7 @@ var ExecutionHandler = class {
         );
       }
     } catch (error) {
-      logger19.error(
+      logger20.error(
         {
           error: error instanceof Error ? error.message : "Unknown error",
           stack: error instanceof Error ? error.stack : void 0
@@ -9698,7 +10004,7 @@ var ExecutionHandler = class {
     try {
       await sseHelper.writeOperation(agentInitializingOp(requestId2, agentId));
       const taskId = `task_${conversationId}-${requestId2}`;
-      logger19.info(
+      logger20.info(
         { taskId, currentAgentId, conversationId, requestId: requestId2 },
         "Attempting to create or reuse existing task"
       );
@@ -9722,7 +10028,7 @@ var ExecutionHandler = class {
             sub_agent_id: currentAgentId
           }
         });
-        logger19.info(
+        logger20.info(
           {
             taskId,
             createdTaskMetadata: Array.isArray(task) ? task[0]?.metadata : task?.metadata
@@ -9731,27 +10037,27 @@ var ExecutionHandler = class {
         );
       } catch (error) {
         if (error?.message?.includes("UNIQUE constraint failed") || error?.message?.includes("PRIMARY KEY constraint failed") || error?.code === "SQLITE_CONSTRAINT_PRIMARYKEY") {
-          logger19.info(
+          logger20.info(
             { taskId, error: error.message },
             "Task already exists, fetching existing task"
           );
           const existingTask = await getTask(dbClient_default)({ id: taskId });
           if (existingTask) {
             task = existingTask;
-            logger19.info(
+            logger20.info(
               { taskId, existingTask },
               "Successfully reused existing task from race condition"
             );
           } else {
-            logger19.error({ taskId, error }, "Task constraint failed but task not found");
+            logger20.error({ taskId, error }, "Task constraint failed but task not found");
             throw error;
           }
         } else {
-          logger19.error({ taskId, error }, "Failed to create task due to non-constraint error");
+          logger20.error({ taskId, error }, "Failed to create task due to non-constraint error");
           throw error;
         }
       }
-      logger19.debug(
+      logger20.debug(
         {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           executionType: "create_initial_task",
@@ -9770,7 +10076,7 @@ var ExecutionHandler = class {
       const maxTransfers = agentConfig?.stopWhen?.transferCountIs ?? 10;
       while (iterations < maxTransfers) {
         iterations++;
-        logger19.info(
+        logger20.info(
           { iterations, currentAgentId, agentId, conversationId, fromSubAgentId },
           `Execution loop iteration ${iterations} with agent ${currentAgentId}, transfer from: ${fromSubAgentId || "none"}`
         );
@@ -9778,10 +10084,10 @@ var ExecutionHandler = class {
           scopes: { tenantId, projectId },
           conversationId
         });
-        logger19.info({ activeAgent }, "activeAgent");
+        logger20.info({ activeAgent }, "activeAgent");
         if (activeAgent && activeAgent.activeSubAgentId !== currentAgentId) {
           currentAgentId = activeAgent.activeSubAgentId;
-          logger19.info({ currentAgentId }, `Updated current agent to: ${currentAgentId}`);
+          logger20.info({ currentAgentId }, `Updated current agent to: ${currentAgentId}`);
         }
         const agentBaseUrl = `${baseUrl}/agents`;
         const a2aClient = new A2AClient(agentBaseUrl, {
@@ -9822,13 +10128,13 @@ var ExecutionHandler = class {
         });
         if (!messageResponse?.result) {
           errorCount++;
-          logger19.error(
+          logger20.error(
             { currentAgentId, iterations, errorCount },
             `No response from agent ${currentAgentId} on iteration ${iterations} (error ${errorCount}/${this.MAX_ERRORS})`
           );
           if (errorCount >= this.MAX_ERRORS) {
             const errorMessage2 = `Maximum error limit (${this.MAX_ERRORS}) reached`;
-            logger19.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
+            logger20.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
             await sseHelper.writeOperation(errorOp(errorMessage2, currentAgentId || "system"));
             if (task) {
               await updateTask(dbClient_default)({
@@ -9852,7 +10158,7 @@ var ExecutionHandler = class {
         if (isTransferTask(messageResponse.result)) {
           const transferData = extractTransferData(messageResponse.result);
           if (!transferData) {
-            logger19.error(
+            logger20.error(
               { result: messageResponse.result },
               "Transfer detected but no transfer data found"
             );
@@ -9861,7 +10167,7 @@ var ExecutionHandler = class {
           const { targetSubAgentId, fromSubAgentId: transferFromAgent } = transferData;
           const firstArtifact = messageResponse.result.artifacts[0];
           const transferReason = firstArtifact?.parts[1]?.kind === "text" ? firstArtifact.parts[1].text : "Transfer initiated";
-          logger19.info({ targetSubAgentId, transferReason, transferFromAgent }, "Transfer response");
+          logger20.info({ targetSubAgentId, transferReason, transferFromAgent }, "Transfer response");
           currentMessage = `<transfer_context> ${transferReason} </transfer_context>`;
           const { success, targetSubAgentId: newAgentId } = await executeTransfer({
             projectId,
@@ -9872,7 +10178,7 @@ var ExecutionHandler = class {
           if (success) {
             fromSubAgentId = currentAgentId;
             currentAgentId = newAgentId;
-            logger19.info(
+            logger20.info(
               {
                 transferFrom: fromSubAgentId,
                 transferTo: currentAgentId,
@@ -9886,7 +10192,7 @@ var ExecutionHandler = class {
         let responseParts = [];
         if (messageResponse.result.streamedContent?.parts) {
           responseParts = messageResponse.result.streamedContent.parts;
-          logger19.info(
+          logger20.info(
             { partsCount: responseParts.length },
             "Using streamed content for conversation history"
           );
@@ -9894,7 +10200,7 @@ var ExecutionHandler = class {
           responseParts = messageResponse.result.artifacts?.flatMap(
             (artifact) => artifact.parts || []
           ) || [];
-          logger19.info(
+          logger20.info(
             { partsCount: responseParts.length },
             "Using artifacts for conversation history (fallback)"
           );
@@ -9903,7 +10209,7 @@ var ExecutionHandler = class {
           const agentSessionData = agentSessionManager.getSession(requestId2);
           if (agentSessionData) {
             const sessionSummary = agentSessionData.getSummary();
-            logger19.info(sessionSummary, "AgentSession data after completion");
+            logger20.info(sessionSummary, "AgentSession data after completion");
           }
           let textContent = "";
           for (const part of responseParts) {
@@ -9956,22 +10262,22 @@ var ExecutionHandler = class {
                 }
               });
               const updateTaskEnd = Date.now();
-              logger19.info(
+              logger20.info(
                 { duration: updateTaskEnd - updateTaskStart },
                 "Completed updateTask operation"
               );
               await sseHelper.writeOperation(completionOp(currentAgentId, iterations));
               await sseHelper.complete();
-              logger19.info({}, "Ending AgentSession and cleaning up");
+              logger20.info({}, "Ending AgentSession and cleaning up");
               agentSessionManager.endSession(requestId2);
-              logger19.info({}, "Cleaning up streamHelper");
+              logger20.info({}, "Cleaning up streamHelper");
               unregisterStreamHelper(requestId2);
               let response;
               if (sseHelper instanceof MCPStreamHelper) {
                 const captured = sseHelper.getCapturedResponse();
                 response = captured.text || "No response content";
               }
-              logger19.info({}, "ExecutionHandler returning success");
+              logger20.info({}, "ExecutionHandler returning success");
               return { success: true, iterations, response };
             } catch (error) {
               setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
@@ -9982,13 +10288,13 @@ var ExecutionHandler = class {
           });
         }
         errorCount++;
-        logger19.warn(
+        logger20.warn(
           { iterations, errorCount },
           `No valid response or transfer on iteration ${iterations} (error ${errorCount}/${this.MAX_ERRORS})`
         );
         if (errorCount >= this.MAX_ERRORS) {
           const errorMessage2 = `Maximum error limit (${this.MAX_ERRORS}) reached`;
-          logger19.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
+          logger20.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
           await sseHelper.writeOperation(errorOp(errorMessage2, currentAgentId || "system"));
           if (task) {
             await updateTask(dbClient_default)({
@@ -10009,7 +10315,7 @@ var ExecutionHandler = class {
         }
       }
       const errorMessage = `Maximum transfer limit (${maxTransfers}) reached without completion`;
-      logger19.error({ maxTransfers, iterations }, errorMessage);
+      logger20.error({ maxTransfers, iterations }, errorMessage);
       await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || "system"));
       if (task) {
         await updateTask(dbClient_default)({
@@ -10028,7 +10334,7 @@ var ExecutionHandler = class {
       unregisterStreamHelper(requestId2);
       return { success: false, error: errorMessage, iterations };
     } catch (error) {
-      logger19.error({ error }, "Error in execution handler");
+      logger20.error({ error }, "Error in execution handler");
       const errorMessage = error instanceof Error ? error.message : "Unknown execution error";
       await sseHelper.writeOperation(
         errorOp(`Execution error: ${errorMessage}`, currentAgentId || "system")
@@ -10055,7 +10361,7 @@ var ExecutionHandler = class {
 
 // src/routes/chat.ts
 var app2 = new OpenAPIHono();
-var logger20 = getLogger("completionsHandler");
+var logger21 = getLogger("completionsHandler");
 var chatCompletionsRoute = createRoute({
   method: "post",
   path: "/completions",
@@ -10173,7 +10479,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
     tracestate: c.req.header("tracestate"),
     baggage: c.req.header("baggage")
   };
-  logger20.info(
+  logger21.info(
     {
       otelHeaders,
       path: c.req.path,
@@ -10282,7 +10588,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
         dbClient: dbClient_default,
         credentialStores
       });
-      logger20.info(
+      logger21.info(
         {
           tenantId,
           projectId,
@@ -10330,7 +10636,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
         try {
           const sseHelper = createSSEStreamHelper(stream3, requestId2, timestamp);
           await sseHelper.writeRole();
-          logger20.info({ subAgentId }, "Starting execution");
+          logger21.info({ subAgentId }, "Starting execution");
           const emitOperationsHeader = c.req.header("x-emit-operations");
           const emitOperations = emitOperationsHeader === "true";
           const executionHandler = new ExecutionHandler();
@@ -10343,7 +10649,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
             sseHelper,
             emitOperations
           });
-          logger20.info(
+          logger21.info(
             { result },
             `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
           );
@@ -10357,7 +10663,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
           }
           await sseHelper.complete();
         } catch (error) {
-          logger20.error(
+          logger21.error(
             {
               error: error instanceof Error ? error.message : error,
               stack: error instanceof Error ? error.stack : void 0
@@ -10374,13 +10680,13 @@ app2.openapi(chatCompletionsRoute, async (c) => {
             );
             await sseHelper.complete();
           } catch (streamError) {
-            logger20.error({ streamError }, "Failed to write error to stream");
+            logger21.error({ streamError }, "Failed to write error to stream");
           }
         }
       });
     });
   } catch (error) {
-    logger20.error(
+    logger21.error(
       {
         error: error instanceof Error ? error.message : error,
         stack: error instanceof Error ? error.stack : void 0
@@ -10404,7 +10710,7 @@ var getMessageText = (content) => {
 };
 var chat_default = app2;
 var app3 = new OpenAPIHono();
-var logger21 = getLogger("chatDataStream");
+var logger22 = getLogger("chatDataStream");
 var chatDataStreamRoute = createRoute({
   method: "post",
   path: "/chat",
@@ -10528,7 +10834,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
       });
       const lastUserMessage = body.messages.filter((m) => m.role === "user").slice(-1)[0];
       const userText = typeof lastUserMessage?.content === "string" ? lastUserMessage.content : lastUserMessage?.parts?.map((p) => p.text).join("") || "";
-      logger21.info({ userText, lastUserMessage }, "userText");
+      logger22.info({ userText, lastUserMessage }, "userText");
       const messageSpan = trace.getActiveSpan();
       if (messageSpan) {
         messageSpan.setAttributes({
@@ -10573,7 +10879,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
               await streamHelper.writeOperation(errorOp("Unable to process request", "system"));
             }
           } catch (err) {
-            logger21.error({ err }, "Streaming error");
+            logger22.error({ err }, "Streaming error");
             await streamHelper.writeOperation(errorOp("Internal server error", "system"));
           } finally {
             if ("cleanup" in streamHelper && typeof streamHelper.cleanup === "function") {
@@ -10595,7 +10901,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
       );
     });
   } catch (error) {
-    logger21.error({ error }, "chatDataStream error");
+    logger22.error({ error }, "chatDataStream error");
     throw createApiError({
       code: "internal_server_error",
       message: "Failed to process chat completion"
@@ -10603,14 +10909,14 @@ app3.openapi(chatDataStreamRoute, async (c) => {
   }
 });
 var chatDataStream_default = app3;
-var logger22 = getLogger("dataComponentPreview");
+var logger23 = getLogger("dataComponentPreview");
 var app4 = new OpenAPIHono();
 var generatePreviewRoute = createRoute({
   method: "post",
-  path: "/:tenantId/projects/:projectId/data-components/:id/generate-preview",
+  path: "/:tenantId/projects/:projectId/data-components/:id/generate-render",
   tags: ["Data Component Preview"],
-  summary: "Generate Component Preview",
-  description: "Generate a React/Tailwind component preview using AI based on the data component schema",
+  summary: "Generate Component Render",
+  description: "Generate a React/Tailwind component render using AI based on the data component schema",
   request: {
     params: z.object({
       tenantId: z.string(),
@@ -10649,7 +10955,7 @@ app4.openapi(generatePreviewRoute, async (c) => {
   const { tenantId, projectId, id } = c.req.valid("param");
   const body = c.req.valid("json");
   const { instructions, existingCode } = body;
-  logger22.info(
+  logger23.info(
     {
       tenantId,
       projectId,
@@ -10681,38 +10987,38 @@ app4.openapi(generatePreviewRoute, async (c) => {
   const prompt = buildGenerationPrompt(dataComponent, instructions, existingCode);
   try {
     const modelConfig = ModelFactory.prepareGenerationConfig(project.models.base);
-    const previewSchema = z.object({
-      code: z.string().describe("The React component code"),
-      data: z.any().describe("Sample data matching the props schema")
+    const renderSchema = z.object({
+      component: z.string().describe("The React component code"),
+      mockData: z.any().describe("Sample data matching the props schema")
     });
     const result = streamObject({
       ...modelConfig,
       prompt,
-      schema: previewSchema,
+      schema: renderSchema,
       temperature: 0.7
     });
     c.header("Content-Type", "text/plain; charset=utf-8");
     c.header("Cache-Control", "no-cache");
     c.header("Connection", "keep-alive");
-    const existingData = existingCode && dataComponent.preview?.data ? dataComponent.preview.data : null;
+    const existingData = existingCode && dataComponent.render && typeof dataComponent.render === "object" && "mockData" in dataComponent.render ? dataComponent.render.mockData : null;
     return stream(c, async (stream3) => {
       try {
         for await (const partialObject of result.partialObjectStream) {
-          const outputObject = instructions && existingData ? { ...partialObject, data: existingData } : partialObject;
+          const outputObject = instructions && existingData ? { ...partialObject, mockData: existingData } : partialObject;
           await stream3.write(JSON.stringify(outputObject) + "\n");
         }
       } catch (error) {
-        logger22.error(
+        logger23.error(
           { error, tenantId, projectId, dataComponentId: id },
           "Error streaming preview generation"
         );
         await stream3.write(
-          JSON.stringify({ code: "// Error generating component preview", data: {} }) + "\n"
+          JSON.stringify({ component: "// Error generating component preview", mockData: {} }) + "\n"
         );
       }
     });
   } catch (error) {
-    logger22.error(
+    logger23.error(
       { error, tenantId, projectId, dataComponentId: id },
       "Error generating component preview"
     );
@@ -10755,13 +11061,13 @@ REQUIREMENTS:
 
 OUTPUT FORMAT:
 You need to generate only one thing:
-1. "code": The modified React component code as a string
+1. "component": The modified React component code as a string
 
-Return ONLY the code field, the data field will be reused from the existing preview.
+Return ONLY the component field, the mockData field will be reused from the existing render.
 
 EXAMPLE OUTPUT:
 {
-  "code": "import { Mail, User } from 'lucide-react';\\n\\nfunction ${componentName}(props) {\\n  // Modified component code here\\n}"
+  "component": "import { Mail, User } from 'lucide-react';\\n\\nfunction ${componentName}(props) {\\n  // Modified component code here\\n}"
 }
 
 Focus on making the requested changes while maintaining the component's quality and design principles.`;
@@ -10815,13 +11121,13 @@ AVAILABLE SEMANTIC COLOR CLASSES:
 
 OUTPUT FORMAT:
 You need to generate two things:
-1. "code": The complete React component code as a string
-2. "data": Realistic sample data that matches the props schema (as a JSON object)
+1. "component": The complete React component code as a string
+2. "mockData": Realistic sample data that matches the props schema (as a JSON object)
 
 EXAMPLE OUTPUT (for a user profile schema with name, email, role):
 {
-  "code": "import { Mail, User } from 'lucide-react';\\n\\nfunction ${componentName}(props) {\\n  return (\\n    <div className=\\"p-4 rounded-lg border border-border bg-card\\">\\n      <div className=\\"flex items-center gap-2.5 mb-2\\">\\n        <User className=\\"size-4 text-muted-foreground\\" />\\n        <span className=\\"text-base font-medium text-foreground\\">{props.name}</span>\\n      </div>\\n      <div className=\\"flex items-center gap-2 text-sm text-muted-foreground\\">\\n        <Mail className=\\"size-4\\" />\\n        <span>{props.email}</span>\\n      </div>\\n      <div className=\\"text-xs text-muted-foreground mt-2\\">Role: {props.role}</div>\\n    </div>\\n  );\\n}",
-  "data": {
+  "component": "import { Mail, User } from 'lucide-react';\\n\\nfunction ${componentName}(props) {\\n  return (\\n    <div className=\\"p-4 rounded-lg border border-border bg-card\\">\\n      <div className=\\"flex items-center gap-2.5 mb-2\\">\\n        <User className=\\"size-4 text-muted-foreground\\" />\\n        <span className=\\"text-base font-medium text-foreground\\">{props.name}</span>\\n      </div>\\n      <div className=\\"flex items-center gap-2 text-sm text-muted-foreground\\">\\n        <Mail className=\\"size-4\\" />\\n        <span>{props.email}</span>\\n      </div>\\n      <div className=\\"text-xs text-muted-foreground mt-2\\">Role: {props.role}</div>\\n    </div>\\n  );\\n}",
+  "mockData": {
     "name": "Sarah Chen",
     "email": "sarah.chen@example.com",
     "role": "Product Manager"
@@ -10845,7 +11151,7 @@ var dataComponentPreview_default = app4;
 function createMCPSchema(schema) {
   return schema;
 }
-var logger23 = getLogger("mcp");
+var logger24 = getLogger("mcp");
 var _MockResponseSingleton = class _MockResponseSingleton {
   constructor() {
     __publicField(this, "mockRes");
@@ -10900,21 +11206,21 @@ var createSpoofInitMessage = (mcpProtocolVersion) => ({
   id: 0
 });
 var spoofTransportInitialization = async (transport, req, sessionId, mcpProtocolVersion) => {
-  logger23.info({ sessionId }, "Spoofing initialization message to set transport state");
+  logger24.info({ sessionId }, "Spoofing initialization message to set transport state");
   const spoofInitMessage = createSpoofInitMessage(mcpProtocolVersion);
   const mockRes = MockResponseSingleton.getInstance().getMockResponse();
   try {
     await transport.handleRequest(req, mockRes, spoofInitMessage);
-    logger23.info({ sessionId }, "Successfully spoofed initialization");
+    logger24.info({ sessionId }, "Successfully spoofed initialization");
   } catch (spoofError) {
-    logger23.warn({ sessionId, error: spoofError }, "Spoof initialization failed, continuing anyway");
+    logger24.warn({ sessionId, error: spoofError }, "Spoof initialization failed, continuing anyway");
   }
 };
 var validateSession = async (req, res, body, tenantId, projectId, agentId) => {
   const sessionId = req.headers["mcp-session-id"];
-  logger23.info({ sessionId }, "Received MCP session ID");
+  logger24.info({ sessionId }, "Received MCP session ID");
   if (!sessionId) {
-    logger23.info({ body }, "Missing session ID");
+    logger24.info({ body }, "Missing session ID");
     res.writeHead(400).end(
       JSON.stringify({
         jsonrpc: "2.0",
@@ -10940,7 +11246,7 @@ var validateSession = async (req, res, body, tenantId, projectId, agentId) => {
     scopes: { tenantId, projectId },
     conversationId: sessionId
   });
-  logger23.info(
+  logger24.info(
     {
       sessionId,
       conversationFound: !!conversation,
@@ -10951,7 +11257,7 @@ var validateSession = async (req, res, body, tenantId, projectId, agentId) => {
     "Conversation lookup result"
   );
   if (!conversation || conversation.metadata?.sessionData?.sessionType !== "mcp" || conversation.metadata?.sessionData?.agentId !== agentId) {
-    logger23.info(
+    logger24.info(
       { sessionId, conversationId: conversation?.id },
       "MCP session not found or invalid"
     );
@@ -11012,7 +11318,7 @@ var executeAgentQuery = async (executionContext, conversationId, query, defaultS
     requestId: requestId2,
     sseHelper: mcpStreamHelper
   });
-  logger23.info(
+  logger24.info(
     { result },
     `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
   );
@@ -11036,7 +11342,7 @@ var executeAgentQuery = async (executionContext, conversationId, query, defaultS
     ]
   };
 };
-var getServer = async (headers, executionContext, conversationId, credentialStores) => {
+var getServer = async (headers2, executionContext, conversationId, credentialStores) => {
   const { tenantId, projectId, agentId } = executionContext;
   setupTracing(conversationId, tenantId, agentId);
   const agent = await getAgentWithDefaultSubAgent(dbClient_default)({
@@ -11092,18 +11398,18 @@ var getServer = async (headers, executionContext, conversationId, credentialStor
           projectId,
           agentId,
           conversationId,
-          headers,
+          headers: headers2,
           dbClient: dbClient_default,
           credentialStores
         });
-        logger23.info(
+        logger24.info(
           {
             tenantId,
             projectId,
             agentId,
             conversationId,
             hasContextConfig: !!agent.contextConfigId,
-            hasHeaders: !!headers,
+            hasHeaders: !!headers2,
             hasValidatedContext: !!resolvedContext
           },
           "parameters"
@@ -11158,7 +11464,7 @@ var validateRequestParameters = (c) => {
 };
 var handleInitializationRequest = async (body, executionContext, validatedContext, req, res, c, credentialStores) => {
   const { tenantId, projectId, agentId } = executionContext;
-  logger23.info({ body }, "Received initialization request");
+  logger24.info({ body }, "Received initialization request");
   const sessionId = getConversationId();
   const activeSpan = trace.getActiveSpan();
   if (activeSpan) {
@@ -11214,7 +11520,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
         }
       }
     });
-    logger23.info(
+    logger24.info(
       { sessionId, conversationId: conversation.id },
       "Created MCP session as conversation"
     );
@@ -11223,9 +11529,9 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
     });
     const server = await getServer(validatedContext, executionContext, sessionId, credentialStores);
     await server.connect(transport);
-    logger23.info({ sessionId }, "Server connected for initialization");
+    logger24.info({ sessionId }, "Server connected for initialization");
     res.setHeader("Mcp-Session-Id", sessionId);
-    logger23.info(
+    logger24.info(
       {
         sessionId,
         bodyMethod: body?.method,
@@ -11234,7 +11540,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
       "About to handle initialization request"
     );
     await transport.handleRequest(req, res, body);
-    logger23.info({ sessionId }, "Successfully handled initialization request");
+    logger24.info({ sessionId }, "Successfully handled initialization request");
     return toFetchResponse(res);
   });
 };
@@ -11261,8 +11567,8 @@ var handleExistingSessionRequest = async (body, executionContext, validatedConte
     sessionId,
     conversation.metadata?.session_data?.mcpProtocolVersion
   );
-  logger23.info({ sessionId }, "Server connected and transport initialized");
-  logger23.info(
+  logger24.info({ sessionId }, "Server connected and transport initialized");
+  logger24.info(
     {
       sessionId,
       bodyKeys: Object.keys(body || {}),
@@ -11276,9 +11582,9 @@ var handleExistingSessionRequest = async (body, executionContext, validatedConte
   );
   try {
     await transport.handleRequest(req, res, body);
-    logger23.info({ sessionId }, "Successfully handled MCP request");
+    logger24.info({ sessionId }, "Successfully handled MCP request");
   } catch (transportError) {
-    logger23.error(
+    logger24.error(
       {
         sessionId,
         error: transportError,
@@ -11329,13 +11635,13 @@ app5.openapi(
       }
       const { executionContext } = paramValidation;
       const body = c.get("requestBody") || {};
-      logger23.info({ body, bodyKeys: Object.keys(body || {}) }, "Parsed request body");
+      logger24.info({ body, bodyKeys: Object.keys(body || {}) }, "Parsed request body");
       const isInitRequest = body.method === "initialize";
       const { req, res } = toReqRes(c.req.raw);
       const validatedContext = c.get("validatedContext") || {};
       const credentialStores = c.get("credentialStores");
-      logger23.info({ validatedContext }, "Validated context");
-      logger23.info({ req }, "request");
+      logger24.info({ validatedContext }, "Validated context");
+      logger24.info({ req }, "request");
       if (isInitRequest) {
         return await handleInitializationRequest(
           body,
@@ -11357,7 +11663,7 @@ app5.openapi(
         );
       }
     } catch (e) {
-      logger23.error(
+      logger24.error(
         {
           error: e instanceof Error ? e.message : e,
           stack: e instanceof Error ? e.stack : void 0
@@ -11369,7 +11675,7 @@ app5.openapi(
   }
 );
 app5.get("/", async (c) => {
-  logger23.info({}, "Received GET MCP request");
+  logger24.info({}, "Received GET MCP request");
   return c.json(
     {
       jsonrpc: "2.0",
@@ -11383,7 +11689,7 @@ app5.get("/", async (c) => {
   );
 });
 app5.delete("/", async (c) => {
-  logger23.info({}, "Received DELETE MCP request");
+  logger24.info({}, "Received DELETE MCP request");
   return c.json(
     {
       jsonrpc: "2.0",
@@ -11396,7 +11702,7 @@ app5.delete("/", async (c) => {
 var mcp_default = app5;
 
 // src/app.ts
-var logger24 = getLogger("agents-run-api");
+var logger25 = getLogger("agents-run-api");
 function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
   const app7 = new OpenAPIHono();
   app7.use("*", otel());
@@ -11415,7 +11721,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
         const body = await c.req.json();
         c.set("requestBody", body);
       } catch (error) {
-        logger24.debug({ error }, "Failed to parse JSON body, continuing without parsed body");
+        logger25.debug({ error }, "Failed to parse JSON body, continuing without parsed body");
       }
     }
     return next();
@@ -11466,8 +11772,8 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
       if (!isExpectedError) {
         const errorMessage = err instanceof Error ? err.message : String(err);
         const errorStack = err instanceof Error ? err.stack : void 0;
-        if (logger24) {
-          logger24.error(
+        if (logger25) {
+          logger25.error(
             {
               error: err,
               message: errorMessage,
@@ -11479,8 +11785,8 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
           );
         }
       } else {
-        if (logger24) {
-          logger24.error(
+        if (logger25) {
+          logger25.error(
             {
               error: err,
               path: c.req.path,
@@ -11497,8 +11803,8 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
         const response = err.getResponse();
         return response;
       } catch (responseError) {
-        if (logger24) {
-          logger24.error({ error: responseError }, "Error while handling HTTPException response");
+        if (logger25) {
+          logger25.error({ error: responseError }, "Error while handling HTTPException response");
         }
       }
     }
@@ -11532,7 +11838,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
   app7.use("*", async (c, next) => {
     const executionContext = c.get("executionContext");
     if (!executionContext) {
-      logger24.debug({}, "Empty execution context");
+      logger25.debug({}, "Empty execution context");
       return next();
     }
     const { tenantId, projectId, agentId } = executionContext;
@@ -11541,7 +11847,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
     if (requestBody) {
       conversationId = requestBody.conversationId;
       if (!conversationId) {
-        logger24.debug({ requestBody }, "No conversation ID found in request body");
+        logger25.debug({ requestBody }, "No conversation ID found in request body");
       }
     }
     const entries = Object.fromEntries(
@@ -11556,7 +11862,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
       })
     );
     if (!Object.keys(entries).length) {
-      logger24.debug({}, "Empty entries for baggage");
+      logger25.debug({}, "Empty entries for baggage");
       return next();
     }
     const bag = Object.entries(entries).reduce(