@inkeep/agents-run-api 0.26.2 → 0.28.0

package/dist/index.cjs

@@ -82,6 +82,7 @@ var init_env = __esm({
       OPENAI_API_KEY: z6.z.string().optional(),
       GOOGLE_GENERATIVE_AI_API_KEY: z6.z.string().optional(),
       INKEEP_AGENTS_RUN_API_BYPASS_SECRET: z6.z.string().optional(),
+      INKEEP_AGENTS_JWT_SIGNING_SECRET: z6.z.string().optional(),
       OTEL_BSP_SCHEDULE_DELAY: z6.z.coerce.number().optional().default(500),
       OTEL_BSP_MAX_EXPORT_BATCH_SIZE: z6.z.coerce.number().optional().default(64)
     });
@@ -357,8 +358,8 @@ async function getConversationScopedArtifacts(params) {
       });
       referenceArtifacts.push(...artifacts);
     }
-    const logger29 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
-    logger29.debug(
+    const logger30 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
+    logger30.debug(
       {
         conversationId,
         visibleMessages: visibleMessages.length,
@@ -370,8 +371,8 @@ async function getConversationScopedArtifacts(params) {
     );
     return referenceArtifacts;
   } catch (error) {
-    const logger29 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
-    logger29.error(
+    const logger30 = (await Promise.resolve().then(() => (init_logger(), logger_exports))).getLogger("conversations");
+    logger30.error(
       {
         error: error instanceof Error ? error.message : "Unknown error",
         conversationId
@@ -412,14 +413,14 @@ const execute = ${executeCode}
 })();
 `;
 }
-function parseExecutionResult(stdout, functionId, logger29) {
+function parseExecutionResult(stdout, functionId, logger30) {
   try {
     const outputLines = stdout.split("\n").filter((line) => line.trim());
     const resultLine = outputLines[outputLines.length - 1];
     return JSON.parse(resultLine);
   } catch (parseError) {
-    if (logger29) {
-      logger29.warn(
+    if (logger30) {
+      logger30.warn(
         {
           functionId,
           stdout,
@@ -1459,7 +1460,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 || {}
   };
 }
 
@@ -1481,28 +1483,36 @@ var apiKeyAuth = () => factory.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") {
+    logger2.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;
         }
-        logger2.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
-        });
-        logger2.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);
+          logger2.info(
+            {},
+            "Development/test environment - fallback to default context due to invalid API key"
+          );
+        }
       }
     } else {
       executionContext = createExecutionContext({
@@ -1514,12 +1524,12 @@ var apiKeyAuth = () => factory.createMiddleware(async (c, next) => {
         baseUrl,
         subAgentId
       });
+      c.set("executionContext", executionContext);
       logger2.info(
         {},
         "Development/test environment - no API key provided, using default context"
       );
     }
-    c.set("executionContext", executionContext);
     await next();
     return;
   }
@@ -1550,12 +1560,21 @@ var apiKeyAuth = () => factory.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);
+        logger2.info({}, "API key authenticated successfully");
+      } catch {
+        const executionContext = await extractContextFromTeamAgentToken(
+          apiKey,
+          baseUrl,
+          subAgentId
+        );
+        c.set("executionContext", executionContext);
       }
-      c.set("executionContext", executionContext);
-      logger2.info({}, "API key authenticated successfully");
       await next();
       return;
     } else {
@@ -1585,14 +1604,24 @@ var apiKeyAuth = () => factory.createMiddleware(async (c, next) => {
       "API key authenticated successfully"
     );
     await next();
-  } catch (error) {
-    if (error instanceof httpException.HTTPException) {
-      throw error;
+  } catch {
+    try {
+      const executionContext = await extractContextFromTeamAgentToken(
+        apiKey,
+        baseUrl,
+        subAgentId
+      );
+      c.set("executionContext", executionContext);
+      await next();
+    } catch (error) {
+      if (error instanceof httpException.HTTPException) {
+        throw error;
+      }
+      logger2.error({ error }, "API key authentication error");
+      throw new httpException.HTTPException(500, {
+        message: "Authentication failed"
+      });
     }
-    logger2.error({ error }, "API key authentication error");
-    throw new httpException.HTTPException(500, {
-      message: "Authentication failed"
-    });
   }
 });
 var extractContextFromApiKey = async (apiKey, baseUrl) => {
@@ -1614,8 +1643,15 @@ var extractContextFromApiKey = async (apiKey, baseUrl) => {
       message: "Invalid or expired API key"
     });
   }
-  logger2.info({ agent }, "agent");
-  logger2.info({ defaultSubAgentId: agent.defaultSubAgentId }, "agent.defaultSubAgentId");
+  logger2.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,
@@ -1626,6 +1662,53 @@ var extractContextFromApiKey = async (apiKey, baseUrl) => {
     subAgentId: agent.defaultSubAgentId || void 0
   });
 };
+var extractContextFromTeamAgentToken = async (token, baseUrl, expectedSubAgentId) => {
+  const result = await agentsCore.verifyServiceToken(token);
+  if (!result.valid || !result.payload) {
+    logger2.warn({ error: result.error }, "Invalid team agent JWT token");
+    throw new httpException.HTTPException(401, {
+      message: `Invalid team agent token: ${result.error || "Unknown error"}`
+    });
+  }
+  const payload = result.payload;
+  if (expectedSubAgentId && !agentsCore.validateTargetAgent(payload, expectedSubAgentId)) {
+    logger2.error(
+      {
+        tokenTargetAgentId: payload.aud,
+        expectedSubAgentId,
+        originAgentId: payload.sub
+      },
+      "Team agent token target mismatch"
+    );
+    throw new httpException.HTTPException(403, {
+      message: "Token not valid for the requested agent"
+    });
+  }
+  logger2.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
+    }
+  });
+};
 
 // src/openapi.ts
 init_env();
@@ -1813,7 +1896,7 @@ async function handleMessageSend(c, agent, request) {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
     logger3.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 = {
@@ -1835,13 +1918,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 agentsCore.createMessage(dbClient_default)(messageData);
         logger3.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
@@ -1854,6 +1942,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
           },
@@ -2800,9 +2889,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,
@@ -2825,6 +2916,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,
@@ -2833,7 +2933,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,
@@ -2943,32 +3043,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)";
+        logger7.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)";
+          logger7.debug(
+            { artifactId, toolCallId, dataSource },
+            "Using fallback data source for artifact summary"
+          );
+        } else {
+          data = {};
+          dataSource = "empty (no data found)";
+          logger7.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)";
+        logger7.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)";
+          logger7.debug(
+            { artifactId, toolCallId, dataSource },
+            "Using fallback data source for artifact full data"
+          );
+        } else {
+          data = {};
+          dataSource = "empty (no data found)";
+          logger7.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.`
+      );
+      logger7.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) {
+      logger7.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) {
+      logger7.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(
@@ -2990,6 +3241,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,
@@ -4484,7 +4740,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) => {
@@ -6715,8 +6993,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 agentsCore.ContextResolver(
             tenantId,
@@ -6754,6 +7034,23 @@ function createDelegateToAgentTool({
             headers: delegateConfig.config.headers || void 0
           });
         }
+      } else if (isTeam) {
+        const contextResolver = new agentsCore.ContextResolver(
+          tenantId,
+          projectId,
+          dbClient_default,
+          credentialStoreRegistry
+        );
+        const context2 = await contextResolver.resolveHeaders(metadata.conversationId, contextId);
+        for (const [key, value] of Object.entries(agentsCore.headers)) {
+          resolvedHeaders[key] = agentsCore.TemplateEngine.render(value, context2, { strict: true });
+        }
+        resolvedHeaders.Authorization = `Bearer ${await agentsCore.generateServiceToken({
+          tenantId,
+          projectId,
+          originAgentId: agentId,
+          targetAgentId: delegateConfig.config.id
+        })}`;
       } else {
         resolvedHeaders = {
           Authorization: `Bearer ${metadata.apiKey}`,
@@ -8616,7 +8913,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) {
         logger19.debug({ agentId: this.config.agentId }, "No context config found for agent");
@@ -8640,7 +8937,7 @@ var Agent = class {
       const result = await this.contextResolver.resolve(contextConfig, {
         triggerEvent: "invocation",
         conversationId,
-        headers: headers || {},
+        headers: headers2 || {},
         tenantId: this.config.tenantId
       });
       const contextWithBuiltins = {
@@ -9742,6 +10039,7 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
       const [
         internalRelations,
         externalRelations,
+        teamRelations,
         toolsForAgent,
         dataComponents,
         artifactComponents
@@ -9762,6 +10060,14 @@ var createTaskHandler = (config, credentialStoreRegistry) => {
             subAgentId: config.subAgentId
           }
         }),
+        agentsCore.getTeamAgentsForSubAgent(dbClient_default)({
+          scopes: {
+            tenantId: config.tenantId,
+            projectId: config.projectId,
+            agentId: config.agentId,
+            subAgentId: config.subAgentId
+          }
+        }),
         agentsCore.getToolsForAgent(dbClient_default)({
           scopes: {
             tenantId: config.tenantId,
@@ -9910,6 +10216,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,
@@ -10131,7 +10448,9 @@ var createTaskHandlerConfig = async (params) => {
 };
 
 // src/data/agents.ts
+init_logger();
 init_dbClient();
+var logger21 = agentsCore.getLogger("agents");
 function createAgentCard({
   dbAgent,
   baseUrl
@@ -10233,13 +10552,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 agentsCore.getAgentWithDefaultSubAgent(dbClient_default)({
+      scopes: { tenantId, projectId, agentId }
+    });
+    logger21.info({ agent }, "agent with default sub agent");
+    if (!agent || !agent.defaultSubAgent) {
+      return null;
+    }
+    dbAgent = agent.defaultSubAgent;
+  } else {
+    const response = await agentsCore.getSubAgentById(dbClient_default)({
+      scopes: { tenantId, projectId, agentId },
+      subAgentId
+    });
+    if (!response) {
+      return null;
+    }
+    dbAgent = response;
   }
-  const dbAgent = await agentsCore.getSubAgentById(dbClient_default)({
-    scopes: { tenantId, projectId, agentId },
-    subAgentId
-  });
   if (!dbAgent) {
     return null;
   }
@@ -10258,7 +10590,7 @@ async function getRegisteredAgent(params) {
 init_dbClient();
 init_logger();
 var app = new zodOpenapi.OpenAPIHono();
-var logger21 = agentsCore.getLogger("agents");
+var logger22 = agentsCore.getLogger("agents");
 app.openapi(
   zodOpenapi.createRoute({
     method: "get",
@@ -10296,7 +10628,7 @@ app.openapi(
       tracestate: c.req.header("tracestate"),
       baggage: c.req.header("baggage")
     };
-    logger21.info(
+    logger22.info(
       {
         otelHeaders,
         path: c.req.path,
@@ -10306,56 +10638,32 @@ app.openapi(
     );
     const executionContext = agentsCore.getRequestExecutionContext(c);
     const { tenantId, projectId, agentId, subAgentId } = executionContext;
-    logger21.info({ executionContext }, "executionContext");
-    if (subAgentId) {
-      logger21.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
-      });
-      logger21.info({ agent }, "agent registered: well-known agent.json");
-      if (!agent) {
-        throw agentsCore.createApiError({
-          code: "not_found",
-          message: "Agent not found"
-        });
-      }
-      return c.json(agent.agentCard);
-    } else {
-      logger21.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
+    logger22.info({ executionContext }, "executionContext");
+    logger22.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
+    });
+    logger22.info({ agent }, "agent registered: well-known agent.json");
+    if (!agent) {
+      throw agentsCore.createApiError({
+        code: "not_found",
+        message: "Agent not found"
       });
-      if (!agent) {
-        throw agentsCore.createApiError({
-          code: "not_found",
-          message: "Agent not found"
-        });
-      }
-      return c.json(agent.agentCard);
     }
+    return c.json(agent.agentCard);
   }
 );
 app.post("/a2a", async (c) => {
@@ -10364,7 +10672,7 @@ app.post("/a2a", async (c) => {
     tracestate: c.req.header("tracestate"),
     baggage: c.req.header("baggage")
   };
-  logger21.info(
+  logger22.info(
     {
       otelHeaders,
       path: c.req.path,
@@ -10375,7 +10683,7 @@ app.post("/a2a", async (c) => {
   const executionContext = agentsCore.getRequestExecutionContext(c);
   const { tenantId, projectId, agentId, subAgentId } = executionContext;
   if (subAgentId) {
-    logger21.info(
+    logger22.info(
       {
         message: "a2a (agent-level)",
         tenantId,
@@ -10404,7 +10712,7 @@ app.post("/a2a", async (c) => {
     }
     return a2aHandler(c, agent);
   } else {
-    logger21.info(
+    logger22.info(
       {
         message: "a2a (agent-level)",
         tenantId,
@@ -10514,14 +10822,14 @@ function extractTransferData(task) {
 }
 
 // src/a2a/transfer.ts
-var logger22 = agentsCore.getLogger("Transfer");
+var logger23 = agentsCore.getLogger("Transfer");
 async function executeTransfer({
   tenantId,
   threadId,
   projectId,
   targetSubAgentId
 }) {
-  logger22.info(
+  logger23.info(
     {
       targetAgent: targetSubAgentId,
       threadId,
@@ -10536,12 +10844,12 @@ async function executeTransfer({
       threadId,
       subAgentId: targetSubAgentId
     });
-    logger22.info(
+    logger23.info(
       { targetAgent: targetSubAgentId, threadId },
       "Successfully updated active_sub_agent_id in database"
     );
   } catch (error) {
-    logger22.error(
+    logger23.error(
       { error, targetAgent: targetSubAgentId, threadId },
       "Failed to update active_sub_agent_id"
     );
@@ -11116,7 +11424,7 @@ function createMCPStreamHelper() {
 }
 
 // src/handlers/executionHandler.ts
-var logger23 = agentsCore.getLogger("ExecutionHandler");
+var logger24 = agentsCore.getLogger("ExecutionHandler");
 var ExecutionHandler = class {
   constructor() {
     __publicField(this, "MAX_ERRORS", 3);
@@ -11151,7 +11459,7 @@ var ExecutionHandler = class {
     if (emitOperations) {
       agentSessionManager.enableEmitOperations(requestId2);
     }
-    logger23.info(
+    logger24.info(
       { sessionId: requestId2, agentId, conversationId, emitOperations },
       "Created AgentSession for message execution"
     );
@@ -11168,7 +11476,7 @@ var ExecutionHandler = class {
         );
       }
     } catch (error) {
-      logger23.error(
+      logger24.error(
         {
           error: error instanceof Error ? error.message : "Unknown error",
           stack: error instanceof Error ? error.stack : void 0
@@ -11184,7 +11492,7 @@ var ExecutionHandler = class {
     try {
       await sseHelper.writeOperation(agentInitializingOp(requestId2, agentId));
       const taskId = `task_${conversationId}-${requestId2}`;
-      logger23.info(
+      logger24.info(
         { taskId, currentAgentId, conversationId, requestId: requestId2 },
         "Attempting to create or reuse existing task"
       );
@@ -11208,7 +11516,7 @@ var ExecutionHandler = class {
             sub_agent_id: currentAgentId
           }
         });
-        logger23.info(
+        logger24.info(
           {
             taskId,
             createdTaskMetadata: Array.isArray(task) ? task[0]?.metadata : task?.metadata
@@ -11217,27 +11525,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") {
-          logger23.info(
+          logger24.info(
             { taskId, error: error.message },
             "Task already exists, fetching existing task"
           );
           const existingTask = await agentsCore.getTask(dbClient_default)({ id: taskId });
           if (existingTask) {
             task = existingTask;
-            logger23.info(
+            logger24.info(
               { taskId, existingTask },
               "Successfully reused existing task from race condition"
             );
           } else {
-            logger23.error({ taskId, error }, "Task constraint failed but task not found");
+            logger24.error({ taskId, error }, "Task constraint failed but task not found");
             throw error;
           }
         } else {
-          logger23.error({ taskId, error }, "Failed to create task due to non-constraint error");
+          logger24.error({ taskId, error }, "Failed to create task due to non-constraint error");
           throw error;
         }
       }
-      logger23.debug(
+      logger24.debug(
         {
           timestamp: (/* @__PURE__ */ new Date()).toISOString(),
           executionType: "create_initial_task",
@@ -11256,7 +11564,7 @@ var ExecutionHandler = class {
       const maxTransfers = agentConfig?.stopWhen?.transferCountIs ?? 10;
       while (iterations < maxTransfers) {
         iterations++;
-        logger23.info(
+        logger24.info(
           { iterations, currentAgentId, agentId, conversationId, fromSubAgentId },
           `Execution loop iteration ${iterations} with agent ${currentAgentId}, transfer from: ${fromSubAgentId || "none"}`
         );
@@ -11264,10 +11572,10 @@ var ExecutionHandler = class {
           scopes: { tenantId, projectId },
           conversationId
         });
-        logger23.info({ activeAgent }, "activeAgent");
+        logger24.info({ activeAgent }, "activeAgent");
         if (activeAgent && activeAgent.activeSubAgentId !== currentAgentId) {
           currentAgentId = activeAgent.activeSubAgentId;
-          logger23.info({ currentAgentId }, `Updated current agent to: ${currentAgentId}`);
+          logger24.info({ currentAgentId }, `Updated current agent to: ${currentAgentId}`);
         }
         const agentBaseUrl = `${baseUrl}/agents`;
         const a2aClient = new A2AClient(agentBaseUrl, {
@@ -11308,13 +11616,13 @@ var ExecutionHandler = class {
         });
         if (!messageResponse?.result) {
           errorCount++;
-          logger23.error(
+          logger24.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`;
-            logger23.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
+            logger24.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
             await sseHelper.writeOperation(errorOp(errorMessage2, currentAgentId || "system"));
             if (task) {
               await agentsCore.updateTask(dbClient_default)({
@@ -11338,7 +11646,7 @@ var ExecutionHandler = class {
         if (isTransferTask(messageResponse.result)) {
           const transferData = extractTransferData(messageResponse.result);
           if (!transferData) {
-            logger23.error(
+            logger24.error(
               { result: messageResponse.result },
               "Transfer detected but no transfer data found"
             );
@@ -11347,7 +11655,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";
-          logger23.info({ targetSubAgentId, transferReason, transferFromAgent }, "Transfer response");
+          logger24.info({ targetSubAgentId, transferReason, transferFromAgent }, "Transfer response");
           currentMessage = `<transfer_context> ${transferReason} </transfer_context>`;
           const { success, targetSubAgentId: newAgentId } = await executeTransfer({
             projectId,
@@ -11358,7 +11666,7 @@ var ExecutionHandler = class {
           if (success) {
             fromSubAgentId = currentAgentId;
             currentAgentId = newAgentId;
-            logger23.info(
+            logger24.info(
               {
                 transferFrom: fromSubAgentId,
                 transferTo: currentAgentId,
@@ -11372,7 +11680,7 @@ var ExecutionHandler = class {
         let responseParts = [];
         if (messageResponse.result.streamedContent?.parts) {
           responseParts = messageResponse.result.streamedContent.parts;
-          logger23.info(
+          logger24.info(
             { partsCount: responseParts.length },
             "Using streamed content for conversation history"
           );
@@ -11380,7 +11688,7 @@ var ExecutionHandler = class {
           responseParts = messageResponse.result.artifacts?.flatMap(
             (artifact) => artifact.parts || []
           ) || [];
-          logger23.info(
+          logger24.info(
             { partsCount: responseParts.length },
             "Using artifacts for conversation history (fallback)"
           );
@@ -11389,7 +11697,7 @@ var ExecutionHandler = class {
           const agentSessionData = agentSessionManager.getSession(requestId2);
           if (agentSessionData) {
             const sessionSummary = agentSessionData.getSummary();
-            logger23.info(sessionSummary, "AgentSession data after completion");
+            logger24.info(sessionSummary, "AgentSession data after completion");
           }
           let textContent = "";
           for (const part of responseParts) {
@@ -11442,22 +11750,22 @@ var ExecutionHandler = class {
                 }
               });
               const updateTaskEnd = Date.now();
-              logger23.info(
+              logger24.info(
                 { duration: updateTaskEnd - updateTaskStart },
                 "Completed updateTask operation"
               );
               await sseHelper.writeOperation(completionOp(currentAgentId, iterations));
               await sseHelper.complete();
-              logger23.info({}, "Ending AgentSession and cleaning up");
+              logger24.info({}, "Ending AgentSession and cleaning up");
               agentSessionManager.endSession(requestId2);
-              logger23.info({}, "Cleaning up streamHelper");
+              logger24.info({}, "Cleaning up streamHelper");
               unregisterStreamHelper(requestId2);
               let response;
               if (sseHelper instanceof MCPStreamHelper) {
                 const captured = sseHelper.getCapturedResponse();
                 response = captured.text || "No response content";
               }
-              logger23.info({}, "ExecutionHandler returning success");
+              logger24.info({}, "ExecutionHandler returning success");
               return { success: true, iterations, response };
             } catch (error) {
               agentsCore.setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
@@ -11468,13 +11776,13 @@ var ExecutionHandler = class {
           });
         }
         errorCount++;
-        logger23.warn(
+        logger24.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`;
-          logger23.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
+          logger24.error({ maxErrors: this.MAX_ERRORS, errorCount }, errorMessage2);
           await sseHelper.writeOperation(errorOp(errorMessage2, currentAgentId || "system"));
           if (task) {
             await agentsCore.updateTask(dbClient_default)({
@@ -11495,7 +11803,7 @@ var ExecutionHandler = class {
         }
       }
       const errorMessage = `Maximum transfer limit (${maxTransfers}) reached without completion`;
-      logger23.error({ maxTransfers, iterations }, errorMessage);
+      logger24.error({ maxTransfers, iterations }, errorMessage);
       await sseHelper.writeOperation(errorOp(errorMessage, currentAgentId || "system"));
       if (task) {
         await agentsCore.updateTask(dbClient_default)({
@@ -11514,7 +11822,7 @@ var ExecutionHandler = class {
       unregisterStreamHelper(requestId2);
       return { success: false, error: errorMessage, iterations };
     } catch (error) {
-      logger23.error({ error }, "Error in execution handler");
+      logger24.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")
@@ -11542,7 +11850,7 @@ var ExecutionHandler = class {
 // src/routes/chat.ts
 init_logger();
 var app2 = new zodOpenapi.OpenAPIHono();
-var logger24 = agentsCore.getLogger("completionsHandler");
+var logger25 = agentsCore.getLogger("completionsHandler");
 var chatCompletionsRoute = zodOpenapi.createRoute({
   method: "post",
   path: "/completions",
@@ -11660,7 +11968,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
     tracestate: c.req.header("tracestate"),
     baggage: c.req.header("baggage")
   };
-  logger24.info(
+  logger25.info(
     {
       otelHeaders,
       path: c.req.path,
@@ -11769,7 +12077,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
         dbClient: dbClient_default,
         credentialStores
       });
-      logger24.info(
+      logger25.info(
         {
           tenantId,
           projectId,
@@ -11817,7 +12125,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
         try {
           const sseHelper = createSSEStreamHelper(stream3, requestId2, timestamp);
           await sseHelper.writeRole();
-          logger24.info({ subAgentId }, "Starting execution");
+          logger25.info({ subAgentId }, "Starting execution");
           const emitOperationsHeader = c.req.header("x-emit-operations");
           const emitOperations = emitOperationsHeader === "true";
           const executionHandler = new ExecutionHandler();
@@ -11830,7 +12138,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
             sseHelper,
             emitOperations
           });
-          logger24.info(
+          logger25.info(
             { result },
             `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
           );
@@ -11844,7 +12152,7 @@ app2.openapi(chatCompletionsRoute, async (c) => {
           }
           await sseHelper.complete();
         } catch (error) {
-          logger24.error(
+          logger25.error(
             {
               error: error instanceof Error ? error.message : error,
               stack: error instanceof Error ? error.stack : void 0
@@ -11861,13 +12169,13 @@ app2.openapi(chatCompletionsRoute, async (c) => {
             );
             await sseHelper.complete();
           } catch (streamError) {
-            logger24.error({ streamError }, "Failed to write error to stream");
+            logger25.error({ streamError }, "Failed to write error to stream");
           }
         }
       });
     });
   } catch (error) {
-    logger24.error(
+    logger25.error(
       {
         error: error instanceof Error ? error.message : error,
         stack: error instanceof Error ? error.stack : void 0
@@ -11895,7 +12203,7 @@ var chat_default = app2;
 init_dbClient();
 init_logger();
 var app3 = new zodOpenapi.OpenAPIHono();
-var logger25 = agentsCore.getLogger("chatDataStream");
+var logger26 = agentsCore.getLogger("chatDataStream");
 var chatDataStreamRoute = zodOpenapi.createRoute({
   method: "post",
   path: "/chat",
@@ -12019,7 +12327,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("") || "";
-      logger25.info({ userText, lastUserMessage }, "userText");
+      logger26.info({ userText, lastUserMessage }, "userText");
       const messageSpan = api.trace.getActiveSpan();
       if (messageSpan) {
         messageSpan.setAttributes({
@@ -12064,7 +12372,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
               await streamHelper.writeOperation(errorOp("Unable to process request", "system"));
             }
           } catch (err) {
-            logger25.error({ err }, "Streaming error");
+            logger26.error({ err }, "Streaming error");
             await streamHelper.writeOperation(errorOp("Internal server error", "system"));
           } finally {
             if ("cleanup" in streamHelper && typeof streamHelper.cleanup === "function") {
@@ -12086,7 +12394,7 @@ app3.openapi(chatDataStreamRoute, async (c) => {
       );
     });
   } catch (error) {
-    logger25.error({ error }, "chatDataStream error");
+    logger26.error({ error }, "chatDataStream error");
     throw agentsCore.createApiError({
       code: "internal_server_error",
       message: "Failed to process chat completion"
@@ -12096,14 +12404,14 @@ app3.openapi(chatDataStreamRoute, async (c) => {
 var chatDataStream_default = app3;
 init_dbClient();
 init_logger();
-var logger26 = agentsCore.getLogger("dataComponentPreview");
+var logger27 = agentsCore.getLogger("dataComponentPreview");
 var app4 = new zodOpenapi.OpenAPIHono();
 var generatePreviewRoute = zodOpenapi.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: z6.z.object({
       tenantId: z6.z.string(),
@@ -12142,7 +12450,7 @@ app4.openapi(generatePreviewRoute, async (c) => {
   const { tenantId, projectId, id } = c.req.valid("param");
   const body = c.req.valid("json");
   const { instructions, existingCode } = body;
-  logger26.info(
+  logger27.info(
     {
       tenantId,
       projectId,
@@ -12174,38 +12482,38 @@ app4.openapi(generatePreviewRoute, async (c) => {
   const prompt = buildGenerationPrompt(dataComponent, instructions, existingCode);
   try {
     const modelConfig = ModelFactory.prepareGenerationConfig(project.models.base);
-    const previewSchema = z6.z.object({
-      code: z6.z.string().describe("The React component code"),
-      data: z6.z.any().describe("Sample data matching the props schema")
+    const renderSchema = z6.z.object({
+      component: z6.z.string().describe("The React component code"),
+      mockData: z6.z.any().describe("Sample data matching the props schema")
     });
     const result = ai.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 streaming.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) {
-        logger26.error(
+        logger27.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) {
-    logger26.error(
+    logger27.error(
       { error, tenantId, projectId, dataComponentId: id },
       "Error generating component preview"
     );
@@ -12248,13 +12556,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.`;
@@ -12308,13 +12616,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"
@@ -12342,7 +12650,7 @@ init_logger();
 function createMCPSchema(schema) {
   return schema;
 }
-var logger27 = agentsCore.getLogger("mcp");
+var logger28 = agentsCore.getLogger("mcp");
 var _MockResponseSingleton = class _MockResponseSingleton {
   constructor() {
     __publicField(this, "mockRes");
@@ -12397,21 +12705,21 @@ var createSpoofInitMessage = (mcpProtocolVersion) => ({
   id: 0
 });
 var spoofTransportInitialization = async (transport, req, sessionId, mcpProtocolVersion) => {
-  logger27.info({ sessionId }, "Spoofing initialization message to set transport state");
+  logger28.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);
-    logger27.info({ sessionId }, "Successfully spoofed initialization");
+    logger28.info({ sessionId }, "Successfully spoofed initialization");
   } catch (spoofError) {
-    logger27.warn({ sessionId, error: spoofError }, "Spoof initialization failed, continuing anyway");
+    logger28.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"];
-  logger27.info({ sessionId }, "Received MCP session ID");
+  logger28.info({ sessionId }, "Received MCP session ID");
   if (!sessionId) {
-    logger27.info({ body }, "Missing session ID");
+    logger28.info({ body }, "Missing session ID");
     res.writeHead(400).end(
       JSON.stringify({
         jsonrpc: "2.0",
@@ -12437,7 +12745,7 @@ var validateSession = async (req, res, body, tenantId, projectId, agentId) => {
     scopes: { tenantId, projectId },
     conversationId: sessionId
   });
-  logger27.info(
+  logger28.info(
     {
       sessionId,
       conversationFound: !!conversation,
@@ -12448,7 +12756,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) {
-    logger27.info(
+    logger28.info(
       { sessionId, conversationId: conversation?.id },
       "MCP session not found or invalid"
     );
@@ -12509,7 +12817,7 @@ var executeAgentQuery = async (executionContext, conversationId, query, defaultS
     requestId: requestId2,
     sseHelper: mcpStreamHelper
   });
-  logger27.info(
+  logger28.info(
     { result },
     `Execution completed: ${result.success ? "success" : "failed"} after ${result.iterations} iterations`
   );
@@ -12533,7 +12841,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 agentsCore.getAgentWithDefaultSubAgent(dbClient_default)({
@@ -12589,18 +12897,18 @@ var getServer = async (headers, executionContext, conversationId, credentialStor
           projectId,
           agentId,
           conversationId,
-          headers,
+          headers: headers2,
           dbClient: dbClient_default,
           credentialStores
         });
-        logger27.info(
+        logger28.info(
           {
             tenantId,
             projectId,
             agentId,
             conversationId,
             hasContextConfig: !!agent.contextConfigId,
-            hasHeaders: !!headers,
+            hasHeaders: !!headers2,
             hasValidatedContext: !!resolvedContext
           },
           "parameters"
@@ -12655,7 +12963,7 @@ var validateRequestParameters = (c) => {
 };
 var handleInitializationRequest = async (body, executionContext, validatedContext, req, res, c, credentialStores) => {
   const { tenantId, projectId, agentId } = executionContext;
-  logger27.info({ body }, "Received initialization request");
+  logger28.info({ body }, "Received initialization request");
   const sessionId = agentsCore.getConversationId();
   const activeSpan = api.trace.getActiveSpan();
   if (activeSpan) {
@@ -12711,7 +13019,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
         }
       }
     });
-    logger27.info(
+    logger28.info(
       { sessionId, conversationId: conversation.id },
       "Created MCP session as conversation"
     );
@@ -12720,9 +13028,9 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
     });
     const server = await getServer(validatedContext, executionContext, sessionId, credentialStores);
     await server.connect(transport);
-    logger27.info({ sessionId }, "Server connected for initialization");
+    logger28.info({ sessionId }, "Server connected for initialization");
     res.setHeader("Mcp-Session-Id", sessionId);
-    logger27.info(
+    logger28.info(
       {
         sessionId,
         bodyMethod: body?.method,
@@ -12731,7 +13039,7 @@ var handleInitializationRequest = async (body, executionContext, validatedContex
       "About to handle initialization request"
     );
     await transport.handleRequest(req, res, body);
-    logger27.info({ sessionId }, "Successfully handled initialization request");
+    logger28.info({ sessionId }, "Successfully handled initialization request");
     return fetchToNode.toFetchResponse(res);
   });
 };
@@ -12758,8 +13066,8 @@ var handleExistingSessionRequest = async (body, executionContext, validatedConte
     sessionId,
     conversation.metadata?.session_data?.mcpProtocolVersion
   );
-  logger27.info({ sessionId }, "Server connected and transport initialized");
-  logger27.info(
+  logger28.info({ sessionId }, "Server connected and transport initialized");
+  logger28.info(
     {
       sessionId,
       bodyKeys: Object.keys(body || {}),
@@ -12773,9 +13081,9 @@ var handleExistingSessionRequest = async (body, executionContext, validatedConte
   );
   try {
     await transport.handleRequest(req, res, body);
-    logger27.info({ sessionId }, "Successfully handled MCP request");
+    logger28.info({ sessionId }, "Successfully handled MCP request");
   } catch (transportError) {
-    logger27.error(
+    logger28.error(
       {
         sessionId,
         error: transportError,
@@ -12826,13 +13134,13 @@ app5.openapi(
       }
       const { executionContext } = paramValidation;
       const body = c.get("requestBody") || {};
-      logger27.info({ body, bodyKeys: Object.keys(body || {}) }, "Parsed request body");
+      logger28.info({ body, bodyKeys: Object.keys(body || {}) }, "Parsed request body");
       const isInitRequest = body.method === "initialize";
       const { req, res } = fetchToNode.toReqRes(c.req.raw);
       const validatedContext = c.get("validatedContext") || {};
       const credentialStores = c.get("credentialStores");
-      logger27.info({ validatedContext }, "Validated context");
-      logger27.info({ req }, "request");
+      logger28.info({ validatedContext }, "Validated context");
+      logger28.info({ req }, "request");
       if (isInitRequest) {
         return await handleInitializationRequest(
           body,
@@ -12854,7 +13162,7 @@ app5.openapi(
         );
       }
     } catch (e) {
-      logger27.error(
+      logger28.error(
         {
           error: e instanceof Error ? e.message : e,
           stack: e instanceof Error ? e.stack : void 0
@@ -12866,7 +13174,7 @@ app5.openapi(
   }
 );
 app5.get("/", async (c) => {
-  logger27.info({}, "Received GET MCP request");
+  logger28.info({}, "Received GET MCP request");
   return c.json(
     {
       jsonrpc: "2.0",
@@ -12880,7 +13188,7 @@ app5.get("/", async (c) => {
   );
 });
 app5.delete("/", async (c) => {
-  logger27.info({}, "Received DELETE MCP request");
+  logger28.info({}, "Received DELETE MCP request");
   return c.json(
     {
       jsonrpc: "2.0",
@@ -12893,7 +13201,7 @@ app5.delete("/", async (c) => {
 var mcp_default = app5;
 
 // src/app.ts
-var logger28 = agentsCore.getLogger("agents-run-api");
+var logger29 = agentsCore.getLogger("agents-run-api");
 function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
   const app7 = new zodOpenapi.OpenAPIHono();
   app7.use("*", otel.otel());
@@ -12912,7 +13220,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
         const body = await c.req.json();
         c.set("requestBody", body);
       } catch (error) {
-        logger28.debug({ error }, "Failed to parse JSON body, continuing without parsed body");
+        logger29.debug({ error }, "Failed to parse JSON body, continuing without parsed body");
       }
     }
     return next();
@@ -12963,8 +13271,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 (logger28) {
-          logger28.error(
+        if (logger29) {
+          logger29.error(
             {
               error: err,
               message: errorMessage,
@@ -12976,8 +13284,8 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
           );
         }
       } else {
-        if (logger28) {
-          logger28.error(
+        if (logger29) {
+          logger29.error(
             {
               error: err,
               path: c.req.path,
@@ -12994,8 +13302,8 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
         const response = err.getResponse();
         return response;
       } catch (responseError) {
-        if (logger28) {
-          logger28.error({ error: responseError }, "Error while handling HTTPException response");
+        if (logger29) {
+          logger29.error({ error: responseError }, "Error while handling HTTPException response");
         }
       }
     }
@@ -13029,7 +13337,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
   app7.use("*", async (c, next) => {
     const executionContext = c.get("executionContext");
     if (!executionContext) {
-      logger28.debug({}, "Empty execution context");
+      logger29.debug({}, "Empty execution context");
       return next();
     }
     const { tenantId, projectId, agentId } = executionContext;
@@ -13038,7 +13346,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
     if (requestBody) {
       conversationId = requestBody.conversationId;
       if (!conversationId) {
-        logger28.debug({ requestBody }, "No conversation ID found in request body");
+        logger29.debug({ requestBody }, "No conversation ID found in request body");
       }
     }
     const entries = Object.fromEntries(
@@ -13053,7 +13361,7 @@ function createExecutionHono(serverConfig, credentialStores, sandboxConfig) {
       })
     );
     if (!Object.keys(entries).length) {
-      logger28.debug({}, "Empty entries for baggage");
+      logger29.debug({}, "Empty entries for baggage");
       return next();
     }
     const bag = Object.entries(entries).reduce(