@inkeep/agents-run-api 0.23.3 → 0.23.5

package/dist/index.cjs

@@ -9149,326 +9149,334 @@ var Agent = class {
     }
   }
   async generate(userMessage, runtimeContext) {
-    return tracer.startActiveSpan("agent.generate", async (span) => {
-      const contextId = runtimeContext?.contextId || "default";
-      const taskId = runtimeContext?.metadata?.taskId || "unknown";
-      const streamRequestId = runtimeContext?.metadata?.streamRequestId;
-      const sessionId = streamRequestId || "fallback-session";
-      try {
-        this.streamRequestId = streamRequestId;
-        this.streamHelper = streamRequestId ? getStreamHelper(streamRequestId) : void 0;
-        const conversationId = runtimeContext?.metadata?.conversationId;
-        if (conversationId) {
-          this.setConversationId(conversationId);
-        }
-        const [
-          mcpTools,
-          systemPrompt,
-          thinkingSystemPrompt,
-          functionTools,
-          relationTools,
-          defaultTools
-        ] = await tracer.startActiveSpan(
-          "agent.load_tools",
-          {
-            attributes: {
-              "subAgent.name": this.config.name,
-              "session.id": sessionId
-            }
-          },
-          async (childSpan) => {
-            try {
-              const result = await Promise.all([
-                this.getMcpTools(sessionId, streamRequestId),
-                this.buildSystemPrompt(runtimeContext, false),
-                // Normal prompt with data components
-                this.buildSystemPrompt(runtimeContext, true),
-                // Thinking prompt without data components
-                this.getFunctionTools(sessionId, streamRequestId),
-                Promise.resolve(this.getRelationTools(runtimeContext, sessionId)),
-                this.getDefaultTools(streamRequestId)
-              ]);
-              childSpan.setStatus({ code: api.SpanStatusCode.OK });
-              return result;
-            } catch (err) {
-              const errorObj = err instanceof Error ? err : new Error(String(err));
-              agentsCore.setSpanWithError(childSpan, errorObj);
-              throw err;
-            } finally {
-              childSpan.end();
-            }
-          }
-        );
-        const allTools = {
-          ...mcpTools,
-          ...functionTools,
-          ...relationTools,
-          ...defaultTools
-        };
-        const sanitizedTools = this.sanitizeToolsForAISDK(allTools);
-        let conversationHistory = "";
-        const historyConfig = this.config.conversationHistoryConfig ?? createDefaultConversationHistoryConfig();
-        if (historyConfig && historyConfig.mode !== "none") {
-          if (historyConfig.mode === "full") {
-            conversationHistory = await getFormattedConversationHistory({
-              tenantId: this.config.tenantId,
-              projectId: this.config.projectId,
-              conversationId: contextId,
-              currentMessage: userMessage,
-              options: historyConfig,
-              filters: {}
-            });
-          } else if (historyConfig.mode === "scoped") {
-            conversationHistory = await getFormattedConversationHistory({
-              tenantId: this.config.tenantId,
-              projectId: this.config.projectId,
-              conversationId: contextId,
-              currentMessage: userMessage,
-              options: historyConfig,
-              filters: {
-                subAgentId: this.config.id,
-                taskId
-              }
-            });
-          }
+    return tracer.startActiveSpan(
+      "agent.generate",
+      {
+        attributes: {
+          "subagent.id": this.config.id,
+          "subagent.name": this.config.name
         }
-        const primaryModelSettings = this.getPrimaryModel();
-        const modelSettings = ModelFactory.prepareGenerationConfig(primaryModelSettings);
-        let response;
-        let textResponse;
-        const hasStructuredOutput = this.config.dataComponents && this.config.dataComponents.length > 0;
-        const shouldStreamPhase1 = this.getStreamingHelper() && !hasStructuredOutput;
-        const MAX_ALLOWED_TIMEOUT_MS = 6e5;
-        const configuredTimeout = modelSettings.maxDuration ? Math.min(modelSettings.maxDuration * 1e3, MAX_ALLOWED_TIMEOUT_MS) : shouldStreamPhase1 ? CONSTANTS.PHASE_1_TIMEOUT_MS : CONSTANTS.NON_STREAMING_PHASE_1_TIMEOUT_MS;
-        const timeoutMs = Math.min(configuredTimeout, MAX_ALLOWED_TIMEOUT_MS);
-        if (modelSettings.maxDuration && modelSettings.maxDuration * 1e3 > MAX_ALLOWED_TIMEOUT_MS) {
-          logger19.warn(
+      },
+      async (span) => {
+        const contextId = runtimeContext?.contextId || "default";
+        const taskId = runtimeContext?.metadata?.taskId || "unknown";
+        const streamRequestId = runtimeContext?.metadata?.streamRequestId;
+        const sessionId = streamRequestId || "fallback-session";
+        try {
+          this.streamRequestId = streamRequestId;
+          this.streamHelper = streamRequestId ? getStreamHelper(streamRequestId) : void 0;
+          const conversationId = runtimeContext?.metadata?.conversationId;
+          if (conversationId) {
+            this.setConversationId(conversationId);
+          }
+          const [
+            mcpTools,
+            systemPrompt,
+            thinkingSystemPrompt,
+            functionTools,
+            relationTools,
+            defaultTools
+          ] = await tracer.startActiveSpan(
+            "agent.load_tools",
             {
-              requestedTimeout: modelSettings.maxDuration * 1e3,
-              appliedTimeout: timeoutMs,
-              maxAllowed: MAX_ALLOWED_TIMEOUT_MS
-            },
-            "Requested timeout exceeded maximum allowed, capping to 10 minutes"
-          );
-        }
-        const phase1SystemPrompt = hasStructuredOutput ? thinkingSystemPrompt : systemPrompt;
-        const messages = [];
-        messages.push({ role: "system", content: phase1SystemPrompt });
-        if (conversationHistory.trim() !== "") {
-          messages.push({ role: "user", content: conversationHistory });
-        }
-        messages.push({
-          role: "user",
-          content: userMessage
-        });
-        if (shouldStreamPhase1) {
-          const streamConfig = {
-            ...modelSettings,
-            toolChoice: "auto"
-            // Allow natural text + tools
-          };
-          const streamResult = ai.streamText({
-            ...streamConfig,
-            messages,
-            tools: sanitizedTools,
-            stopWhen: async ({ steps }) => {
-              const last = steps.at(-1);
-              if (last && "text" in last && last.text) {
-                try {
-                  await agentSessionManager.recordEvent(
-                    this.getStreamRequestId(),
-                    "agent_reasoning",
-                    this.config.id,
-                    {
-                      parts: [{ type: "text", content: last.text }]
-                    }
-                  );
-                } catch (error) {
-                  logger19.debug({ error }, "Failed to track agent reasoning");
-                }
-              }
-              if (steps.length >= 2) {
-                const previousStep = steps[steps.length - 2];
-                if (previousStep && "toolCalls" in previousStep && previousStep.toolCalls) {
-                  const hasTransferCall = previousStep.toolCalls.some(
-                    (tc) => tc.toolName.startsWith("transfer_to_")
-                  );
-                  if (hasTransferCall && "toolResults" in previousStep && previousStep.toolResults) {
-                    return true;
-                  }
-                }
+              attributes: {
+                "subAgent.name": this.config.name,
+                "session.id": sessionId
               }
-              return steps.length >= this.getMaxGenerationSteps();
-            },
-            experimental_telemetry: {
-              isEnabled: true,
-              functionId: this.config.id,
-              recordInputs: true,
-              recordOutputs: true
             },
-            abortSignal: AbortSignal.timeout(timeoutMs)
-          });
-          const streamHelper = this.getStreamingHelper();
-          if (!streamHelper) {
-            throw new Error("Stream helper is unexpectedly undefined in streaming context");
-          }
-          const session = toolSessionManager.getSession(sessionId);
-          const artifactParserOptions = {
-            sessionId,
-            taskId: session?.taskId,
-            projectId: session?.projectId,
-            artifactComponents: this.artifactComponents,
-            streamRequestId: this.getStreamRequestId(),
-            subAgentId: this.config.id
-          };
-          const parser = new IncrementalStreamParser(
-            streamHelper,
-            this.config.tenantId,
-            contextId,
-            artifactParserOptions
+            async (childSpan) => {
+              try {
+                const result = await Promise.all([
+                  this.getMcpTools(sessionId, streamRequestId),
+                  this.buildSystemPrompt(runtimeContext, false),
+                  // Normal prompt with data components
+                  this.buildSystemPrompt(runtimeContext, true),
+                  // Thinking prompt without data components
+                  this.getFunctionTools(sessionId, streamRequestId),
+                  Promise.resolve(this.getRelationTools(runtimeContext, sessionId)),
+                  this.getDefaultTools(streamRequestId)
+                ]);
+                childSpan.setStatus({ code: api.SpanStatusCode.OK });
+                return result;
+              } catch (err) {
+                const errorObj = err instanceof Error ? err : new Error(String(err));
+                agentsCore.setSpanWithError(childSpan, errorObj);
+                throw err;
+              } finally {
+                childSpan.end();
+              }
+            }
           );
-          for await (const event of streamResult.fullStream) {
-            switch (event.type) {
-              case "text-delta":
-                await parser.processTextChunk(event.text);
-                break;
-              case "tool-call":
-                parser.markToolResult();
-                break;
-              case "tool-result":
-                parser.markToolResult();
-                break;
-              case "finish":
-                if (event.finishReason === "tool-calls") {
-                  parser.markToolResult();
-                }
-                break;
-              case "error":
-                if (event.error instanceof Error) {
-                  throw event.error;
-                } else {
-                  const errorMessage = event.error?.error?.message;
-                  throw new Error(errorMessage);
+          const allTools = {
+            ...mcpTools,
+            ...functionTools,
+            ...relationTools,
+            ...defaultTools
+          };
+          const sanitizedTools = this.sanitizeToolsForAISDK(allTools);
+          let conversationHistory = "";
+          const historyConfig = this.config.conversationHistoryConfig ?? createDefaultConversationHistoryConfig();
+          if (historyConfig && historyConfig.mode !== "none") {
+            if (historyConfig.mode === "full") {
+              conversationHistory = await getFormattedConversationHistory({
+                tenantId: this.config.tenantId,
+                projectId: this.config.projectId,
+                conversationId: contextId,
+                currentMessage: userMessage,
+                options: historyConfig,
+                filters: {}
+              });
+            } else if (historyConfig.mode === "scoped") {
+              conversationHistory = await getFormattedConversationHistory({
+                tenantId: this.config.tenantId,
+                projectId: this.config.projectId,
+                conversationId: contextId,
+                currentMessage: userMessage,
+                options: historyConfig,
+                filters: {
+                  subAgentId: this.config.id,
+                  taskId
                 }
+              });
             }
           }
-          await parser.finalize();
-          response = await streamResult;
-          const collectedParts = parser.getCollectedParts();
-          if (collectedParts.length > 0) {
-            response.formattedContent = {
-              parts: collectedParts.map((part) => ({
-                kind: part.kind,
-                ...part.kind === "text" && { text: part.text },
-                ...part.kind === "data" && { data: part.data }
-              }))
-            };
+          const primaryModelSettings = this.getPrimaryModel();
+          const modelSettings = ModelFactory.prepareGenerationConfig(primaryModelSettings);
+          let response;
+          let textResponse;
+          const hasStructuredOutput = this.config.dataComponents && this.config.dataComponents.length > 0;
+          const shouldStreamPhase1 = this.getStreamingHelper() && !hasStructuredOutput;
+          const MAX_ALLOWED_TIMEOUT_MS = 6e5;
+          const configuredTimeout = modelSettings.maxDuration ? Math.min(modelSettings.maxDuration * 1e3, MAX_ALLOWED_TIMEOUT_MS) : shouldStreamPhase1 ? CONSTANTS.PHASE_1_TIMEOUT_MS : CONSTANTS.NON_STREAMING_PHASE_1_TIMEOUT_MS;
+          const timeoutMs = Math.min(configuredTimeout, MAX_ALLOWED_TIMEOUT_MS);
+          if (modelSettings.maxDuration && modelSettings.maxDuration * 1e3 > MAX_ALLOWED_TIMEOUT_MS) {
+            logger19.warn(
+              {
+                requestedTimeout: modelSettings.maxDuration * 1e3,
+                appliedTimeout: timeoutMs,
+                maxAllowed: MAX_ALLOWED_TIMEOUT_MS
+              },
+              "Requested timeout exceeded maximum allowed, capping to 10 minutes"
+            );
           }
-          const streamedContent = parser.getAllStreamedContent();
-          if (streamedContent.length > 0) {
-            response.streamedContent = {
-              parts: streamedContent.map((part) => ({
-                kind: part.kind,
-                ...part.kind === "text" && { text: part.text },
-                ...part.kind === "data" && { data: part.data }
-              }))
-            };
+          const phase1SystemPrompt = hasStructuredOutput ? thinkingSystemPrompt : systemPrompt;
+          const messages = [];
+          messages.push({ role: "system", content: phase1SystemPrompt });
+          if (conversationHistory.trim() !== "") {
+            messages.push({ role: "user", content: conversationHistory });
           }
-        } else {
-          let genConfig;
-          if (hasStructuredOutput) {
-            genConfig = {
-              ...modelSettings,
-              toolChoice: "required"
-              // Force tool usage, prevent text generation
-            };
-          } else {
-            genConfig = {
+          messages.push({
+            role: "user",
+            content: userMessage
+          });
+          if (shouldStreamPhase1) {
+            const streamConfig = {
               ...modelSettings,
               toolChoice: "auto"
-              // Allow both tools and text generation
+              // Allow natural text + tools
             };
-          }
-          response = await ai.generateText({
-            ...genConfig,
-            messages,
-            tools: sanitizedTools,
-            stopWhen: async ({ steps }) => {
-              const last = steps.at(-1);
-              if (last && "text" in last && last.text) {
-                try {
-                  await agentSessionManager.recordEvent(
-                    this.getStreamRequestId(),
-                    "agent_reasoning",
-                    this.config.id,
-                    {
-                      parts: [{ type: "text", content: last.text }]
-                    }
-                  );
-                } catch (error) {
-                  logger19.debug({ error }, "Failed to track agent reasoning");
+            const streamResult = ai.streamText({
+              ...streamConfig,
+              messages,
+              tools: sanitizedTools,
+              stopWhen: async ({ steps }) => {
+                const last = steps.at(-1);
+                if (last && "text" in last && last.text) {
+                  try {
+                    await agentSessionManager.recordEvent(
+                      this.getStreamRequestId(),
+                      "agent_reasoning",
+                      this.config.id,
+                      {
+                        parts: [{ type: "text", content: last.text }]
+                      }
+                    );
+                  } catch (error) {
+                    logger19.debug({ error }, "Failed to track agent reasoning");
+                  }
                 }
-              }
-              if (steps.length >= 2) {
-                const previousStep = steps[steps.length - 2];
-                if (previousStep && "toolCalls" in previousStep && previousStep.toolCalls) {
-                  const hasStopTool = previousStep.toolCalls.some(
-                    (tc) => tc.toolName.startsWith("transfer_to_") || tc.toolName === "thinking_complete"
-                  );
-                  if (hasStopTool && "toolResults" in previousStep && previousStep.toolResults) {
-                    return true;
+                if (steps.length >= 2) {
+                  const previousStep = steps[steps.length - 2];
+                  if (previousStep && "toolCalls" in previousStep && previousStep.toolCalls) {
+                    const hasTransferCall = previousStep.toolCalls.some(
+                      (tc) => tc.toolName.startsWith("transfer_to_")
+                    );
+                    if (hasTransferCall && "toolResults" in previousStep && previousStep.toolResults) {
+                      return true;
+                    }
                   }
                 }
+                return steps.length >= this.getMaxGenerationSteps();
+              },
+              experimental_telemetry: {
+                isEnabled: true,
+                functionId: this.config.id,
+                recordInputs: true,
+                recordOutputs: true
+              },
+              abortSignal: AbortSignal.timeout(timeoutMs)
+            });
+            const streamHelper = this.getStreamingHelper();
+            if (!streamHelper) {
+              throw new Error("Stream helper is unexpectedly undefined in streaming context");
+            }
+            const session = toolSessionManager.getSession(sessionId);
+            const artifactParserOptions = {
+              sessionId,
+              taskId: session?.taskId,
+              projectId: session?.projectId,
+              artifactComponents: this.artifactComponents,
+              streamRequestId: this.getStreamRequestId(),
+              subAgentId: this.config.id
+            };
+            const parser = new IncrementalStreamParser(
+              streamHelper,
+              this.config.tenantId,
+              contextId,
+              artifactParserOptions
+            );
+            for await (const event of streamResult.fullStream) {
+              switch (event.type) {
+                case "text-delta":
+                  await parser.processTextChunk(event.text);
+                  break;
+                case "tool-call":
+                  parser.markToolResult();
+                  break;
+                case "tool-result":
+                  parser.markToolResult();
+                  break;
+                case "finish":
+                  if (event.finishReason === "tool-calls") {
+                    parser.markToolResult();
+                  }
+                  break;
+                case "error":
+                  if (event.error instanceof Error) {
+                    throw event.error;
+                  } else {
+                    const errorMessage = event.error?.error?.message;
+                    throw new Error(errorMessage);
+                  }
               }
-              return steps.length >= this.getMaxGenerationSteps();
-            },
-            experimental_telemetry: {
-              isEnabled: true,
-              functionId: this.config.id,
-              recordInputs: true,
-              recordOutputs: true,
-              metadata: {
-                phase: "planning"
-              }
-            },
-            abortSignal: AbortSignal.timeout(timeoutMs)
-          });
-        }
-        if (response.steps) {
-          const resolvedSteps = await response.steps;
-          response = { ...response, steps: resolvedSteps };
-        }
-        if (hasStructuredOutput && !hasToolCallWithPrefix("transfer_to_")(response)) {
-          const thinkingCompleteCall = response.steps?.flatMap((s) => s.toolCalls || [])?.find((tc) => tc.toolName === "thinking_complete");
-          if (thinkingCompleteCall) {
-            const reasoningFlow = [];
-            if (response.steps) {
-              response.steps.forEach((step) => {
-                if (step.toolCalls && step.toolResults) {
-                  step.toolCalls.forEach((call, index) => {
-                    const result = step.toolResults[index];
-                    if (result) {
-                      const storedResult = toolSessionManager.getToolResult(
-                        sessionId,
-                        result.toolCallId
-                      );
-                      const toolName = storedResult?.toolName || call.toolName;
-                      if (toolName === "thinking_complete") {
-                        return;
+            }
+            await parser.finalize();
+            response = await streamResult;
+            const collectedParts = parser.getCollectedParts();
+            if (collectedParts.length > 0) {
+              response.formattedContent = {
+                parts: collectedParts.map((part) => ({
+                  kind: part.kind,
+                  ...part.kind === "text" && { text: part.text },
+                  ...part.kind === "data" && { data: part.data }
+                }))
+              };
+            }
+            const streamedContent = parser.getAllStreamedContent();
+            if (streamedContent.length > 0) {
+              response.streamedContent = {
+                parts: streamedContent.map((part) => ({
+                  kind: part.kind,
+                  ...part.kind === "text" && { text: part.text },
+                  ...part.kind === "data" && { data: part.data }
+                }))
+              };
+            }
+          } else {
+            let genConfig;
+            if (hasStructuredOutput) {
+              genConfig = {
+                ...modelSettings,
+                toolChoice: "required"
+                // Force tool usage, prevent text generation
+              };
+            } else {
+              genConfig = {
+                ...modelSettings,
+                toolChoice: "auto"
+                // Allow both tools and text generation
+              };
+            }
+            response = await ai.generateText({
+              ...genConfig,
+              messages,
+              tools: sanitizedTools,
+              stopWhen: async ({ steps }) => {
+                const last = steps.at(-1);
+                if (last && "text" in last && last.text) {
+                  try {
+                    await agentSessionManager.recordEvent(
+                      this.getStreamRequestId(),
+                      "agent_reasoning",
+                      this.config.id,
+                      {
+                        parts: [{ type: "text", content: last.text }]
                       }
-                      const actualResult = storedResult?.result || result.result || result;
-                      const actualArgs = storedResult?.args || call.args;
-                      const cleanResult = actualResult && typeof actualResult === "object" && !Array.isArray(actualResult) ? Object.fromEntries(
-                        Object.entries(actualResult).filter(
-                          ([key]) => key !== "_structureHints"
-                        )
-                      ) : actualResult;
-                      const input = actualArgs ? JSON.stringify(actualArgs, null, 2) : "No input";
-                      const output = typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, null, 2);
-                      let structureHintsFormatted = "";
-                      if (actualResult?._structureHints && this.artifactComponents && this.artifactComponents.length > 0) {
-                        const hints = actualResult._structureHints;
-                        structureHintsFormatted = `
+                    );
+                  } catch (error) {
+                    logger19.debug({ error }, "Failed to track agent reasoning");
+                  }
+                }
+                if (steps.length >= 2) {
+                  const previousStep = steps[steps.length - 2];
+                  if (previousStep && "toolCalls" in previousStep && previousStep.toolCalls) {
+                    const hasStopTool = previousStep.toolCalls.some(
+                      (tc) => tc.toolName.startsWith("transfer_to_") || tc.toolName === "thinking_complete"
+                    );
+                    if (hasStopTool && "toolResults" in previousStep && previousStep.toolResults) {
+                      return true;
+                    }
+                  }
+                }
+                return steps.length >= this.getMaxGenerationSteps();
+              },
+              experimental_telemetry: {
+                isEnabled: true,
+                functionId: this.config.id,
+                recordInputs: true,
+                recordOutputs: true,
+                metadata: {
+                  phase: "planning"
+                }
+              },
+              abortSignal: AbortSignal.timeout(timeoutMs)
+            });
+          }
+          if (response.steps) {
+            const resolvedSteps = await response.steps;
+            response = { ...response, steps: resolvedSteps };
+          }
+          if (hasStructuredOutput && !hasToolCallWithPrefix("transfer_to_")(response)) {
+            const thinkingCompleteCall = response.steps?.flatMap((s) => s.toolCalls || [])?.find((tc) => tc.toolName === "thinking_complete");
+            if (thinkingCompleteCall) {
+              const reasoningFlow = [];
+              if (response.steps) {
+                response.steps.forEach((step) => {
+                  if (step.toolCalls && step.toolResults) {
+                    step.toolCalls.forEach((call, index) => {
+                      const result = step.toolResults[index];
+                      if (result) {
+                        const storedResult = toolSessionManager.getToolResult(
+                          sessionId,
+                          result.toolCallId
+                        );
+                        const toolName = storedResult?.toolName || call.toolName;
+                        if (toolName === "thinking_complete") {
+                          return;
+                        }
+                        const actualResult = storedResult?.result || result.result || result;
+                        const actualArgs = storedResult?.args || call.args;
+                        const cleanResult = actualResult && typeof actualResult === "object" && !Array.isArray(actualResult) ? Object.fromEntries(
+                          Object.entries(actualResult).filter(
+                            ([key]) => key !== "_structureHints"
+                          )
+                        ) : actualResult;
+                        const input = actualArgs ? JSON.stringify(actualArgs, null, 2) : "No input";
+                        const output = typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, null, 2);
+                        let structureHintsFormatted = "";
+                        if (actualResult?._structureHints && this.artifactComponents && this.artifactComponents.length > 0) {
+                          const hints = actualResult._structureHints;
+                          structureHintsFormatted = `
 ### \u{1F4CA} Structure Hints for Artifact Creation
 
 **Terminal Field Paths (${hints.terminalPaths?.length || 0} found):**
@@ -9492,8 +9500,8 @@ ${hints.commonFields?.map((field) => `  \u2022 ${field}`).join("\n") || "  None
 
 **Forbidden Syntax:** ${hints.forbiddenSyntax || "Use these paths for artifact base selectors."}
 `;
-                      }
-                      const formattedResult = `## Tool: ${call.toolName}
+                        }
+                        const formattedResult = `## Tool: ${call.toolName}
 
 ### \u{1F527} TOOL_CALL_ID: ${result.toolCallId}
 
@@ -9502,130 +9510,61 @@ ${input}
 
 ### Output
 ${output}${structureHintsFormatted}`;
-                      reasoningFlow.push({
-                        role: "assistant",
-                        content: formattedResult
-                      });
-                    }
-                  });
-                }
-              });
-            }
-            const componentSchemas = [];
-            if (this.config.dataComponents && this.config.dataComponents.length > 0) {
-              this.config.dataComponents.forEach((dc) => {
-                const propsSchema = jsonSchemaToZod(dc.props);
-                componentSchemas.push(
-                  z6.z.object({
-                    id: z6.z.string(),
-                    name: z6.z.literal(dc.name),
-                    props: propsSchema
-                  })
-                );
-              });
-            }
-            if (this.artifactComponents.length > 0) {
-              const artifactCreateSchemas = ArtifactCreateSchema.getSchemas(
-                this.artifactComponents
-              );
-              componentSchemas.push(...artifactCreateSchemas);
-              componentSchemas.push(ArtifactReferenceSchema.getSchema());
-            }
-            let dataComponentsSchema;
-            if (componentSchemas.length === 1) {
-              dataComponentsSchema = componentSchemas[0];
-            } else {
-              dataComponentsSchema = z6.z.union(
-                componentSchemas
-              );
-            }
-            const structuredModelSettings = ModelFactory.prepareGenerationConfig(
-              this.getStructuredOutputModel()
-            );
-            const phase2TimeoutMs = structuredModelSettings.maxDuration ? structuredModelSettings.maxDuration * 1e3 : CONSTANTS.PHASE_2_TIMEOUT_MS;
-            const shouldStreamPhase2 = this.getStreamingHelper();
-            if (shouldStreamPhase2) {
-              const phase2Messages = [
-                {
-                  role: "system",
-                  content: await this.buildPhase2SystemPrompt(runtimeContext)
-                }
-              ];
-              if (conversationHistory.trim() !== "") {
-                phase2Messages.push({ role: "user", content: conversationHistory });
-              }
-              phase2Messages.push({ role: "user", content: userMessage });
-              phase2Messages.push(...reasoningFlow);
-              const streamResult = ai.streamObject({
-                ...structuredModelSettings,
-                messages: phase2Messages,
-                schema: z6.z.object({
-                  dataComponents: z6.z.array(dataComponentsSchema)
-                }),
-                experimental_telemetry: {
-                  isEnabled: true,
-                  functionId: this.config.id,
-                  recordInputs: true,
-                  recordOutputs: true,
-                  metadata: {
-                    phase: "structured_generation"
+                        reasoningFlow.push({
+                          role: "assistant",
+                          content: formattedResult
+                        });
+                      }
+                    });
                   }
-                },
-                abortSignal: AbortSignal.timeout(phase2TimeoutMs)
-              });
-              const streamHelper = this.getStreamingHelper();
-              if (!streamHelper) {
-                throw new Error("Stream helper is unexpectedly undefined in streaming context");
+                });
               }
-              const session = toolSessionManager.getSession(sessionId);
-              const artifactParserOptions = {
-                sessionId,
-                taskId: session?.taskId,
-                projectId: session?.projectId,
-                artifactComponents: this.artifactComponents,
-                streamRequestId: this.getStreamRequestId(),
-                subAgentId: this.config.id
-              };
-              const parser = new IncrementalStreamParser(
-                streamHelper,
-                this.config.tenantId,
-                contextId,
-                artifactParserOptions
-              );
-              for await (const delta of streamResult.partialObjectStream) {
-                if (delta) {
-                  await parser.processObjectDelta(delta);
-                }
+              const componentSchemas = [];
+              if (this.config.dataComponents && this.config.dataComponents.length > 0) {
+                this.config.dataComponents.forEach((dc) => {
+                  const propsSchema = jsonSchemaToZod(dc.props);
+                  componentSchemas.push(
+                    z6.z.object({
+                      id: z6.z.string(),
+                      name: z6.z.literal(dc.name),
+                      props: propsSchema
+                    })
+                  );
+                });
               }
-              await parser.finalize();
-              const structuredResponse = await streamResult;
-              const collectedParts = parser.getCollectedParts();
-              if (collectedParts.length > 0) {
-                response.formattedContent = {
-                  parts: collectedParts.map((part) => ({
-                    kind: part.kind,
-                    ...part.kind === "text" && { text: part.text },
-                    ...part.kind === "data" && { data: part.data }
-                  }))
-                };
+              if (this.artifactComponents.length > 0) {
+                const artifactCreateSchemas = ArtifactCreateSchema.getSchemas(
+                  this.artifactComponents
+                );
+                componentSchemas.push(...artifactCreateSchemas);
+                componentSchemas.push(ArtifactReferenceSchema.getSchema());
               }
-              response = {
-                ...response,
-                object: structuredResponse.object
-              };
-              textResponse = JSON.stringify(structuredResponse.object, null, 2);
-            } else {
-              const { withJsonPostProcessing: withJsonPostProcessing2 } = await Promise.resolve().then(() => (init_json_postprocessor(), json_postprocessor_exports));
-              const phase2Messages = [
-                { role: "system", content: await this.buildPhase2SystemPrompt(runtimeContext) }
-              ];
-              if (conversationHistory.trim() !== "") {
-                phase2Messages.push({ role: "user", content: conversationHistory });
+              let dataComponentsSchema;
+              if (componentSchemas.length === 1) {
+                dataComponentsSchema = componentSchemas[0];
+              } else {
+                dataComponentsSchema = z6.z.union(
+                  componentSchemas
+                );
               }
-              phase2Messages.push({ role: "user", content: userMessage });
-              phase2Messages.push(...reasoningFlow);
-              const structuredResponse = await ai.generateObject(
-                withJsonPostProcessing2({
+              const structuredModelSettings = ModelFactory.prepareGenerationConfig(
+                this.getStructuredOutputModel()
+              );
+              const phase2TimeoutMs = structuredModelSettings.maxDuration ? structuredModelSettings.maxDuration * 1e3 : CONSTANTS.PHASE_2_TIMEOUT_MS;
+              const shouldStreamPhase2 = this.getStreamingHelper();
+              if (shouldStreamPhase2) {
+                const phase2Messages = [
+                  {
+                    role: "system",
+                    content: await this.buildPhase2SystemPrompt(runtimeContext)
+                  }
+                ];
+                if (conversationHistory.trim() !== "") {
+                  phase2Messages.push({ role: "user", content: conversationHistory });
+                }
+                phase2Messages.push({ role: "user", content: userMessage });
+                phase2Messages.push(...reasoningFlow);
+                const streamResult = ai.streamObject({
                   ...structuredModelSettings,
                   messages: phase2Messages,
                   schema: z6.z.object({
@@ -9641,65 +9580,135 @@ ${output}${structureHintsFormatted}`;
                     }
                   },
                   abortSignal: AbortSignal.timeout(phase2TimeoutMs)
-                })
-              );
-              response = {
-                ...response,
-                object: structuredResponse.object
-              };
-              textResponse = JSON.stringify(structuredResponse.object, null, 2);
+                });
+                const streamHelper = this.getStreamingHelper();
+                if (!streamHelper) {
+                  throw new Error("Stream helper is unexpectedly undefined in streaming context");
+                }
+                const session = toolSessionManager.getSession(sessionId);
+                const artifactParserOptions = {
+                  sessionId,
+                  taskId: session?.taskId,
+                  projectId: session?.projectId,
+                  artifactComponents: this.artifactComponents,
+                  streamRequestId: this.getStreamRequestId(),
+                  subAgentId: this.config.id
+                };
+                const parser = new IncrementalStreamParser(
+                  streamHelper,
+                  this.config.tenantId,
+                  contextId,
+                  artifactParserOptions
+                );
+                for await (const delta of streamResult.partialObjectStream) {
+                  if (delta) {
+                    await parser.processObjectDelta(delta);
+                  }
+                }
+                await parser.finalize();
+                const structuredResponse = await streamResult;
+                const collectedParts = parser.getCollectedParts();
+                if (collectedParts.length > 0) {
+                  response.formattedContent = {
+                    parts: collectedParts.map((part) => ({
+                      kind: part.kind,
+                      ...part.kind === "text" && { text: part.text },
+                      ...part.kind === "data" && { data: part.data }
+                    }))
+                  };
+                }
+                response = {
+                  ...response,
+                  object: structuredResponse.object
+                };
+                textResponse = JSON.stringify(structuredResponse.object, null, 2);
+              } else {
+                const { withJsonPostProcessing: withJsonPostProcessing2 } = await Promise.resolve().then(() => (init_json_postprocessor(), json_postprocessor_exports));
+                const phase2Messages = [
+                  { role: "system", content: await this.buildPhase2SystemPrompt(runtimeContext) }
+                ];
+                if (conversationHistory.trim() !== "") {
+                  phase2Messages.push({ role: "user", content: conversationHistory });
+                }
+                phase2Messages.push({ role: "user", content: userMessage });
+                phase2Messages.push(...reasoningFlow);
+                const structuredResponse = await ai.generateObject(
+                  withJsonPostProcessing2({
+                    ...structuredModelSettings,
+                    messages: phase2Messages,
+                    schema: z6.z.object({
+                      dataComponents: z6.z.array(dataComponentsSchema)
+                    }),
+                    experimental_telemetry: {
+                      isEnabled: true,
+                      functionId: this.config.id,
+                      recordInputs: true,
+                      recordOutputs: true,
+                      metadata: {
+                        phase: "structured_generation"
+                      }
+                    },
+                    abortSignal: AbortSignal.timeout(phase2TimeoutMs)
+                  })
+                );
+                response = {
+                  ...response,
+                  object: structuredResponse.object
+                };
+                textResponse = JSON.stringify(structuredResponse.object, null, 2);
+              }
+            } else {
+              textResponse = response.text || "";
             }
           } else {
-            textResponse = response.text || "";
+            textResponse = response.steps[response.steps.length - 1].text || "";
           }
-        } else {
-          textResponse = response.steps[response.steps.length - 1].text || "";
-        }
-        span.setStatus({ code: api.SpanStatusCode.OK });
-        span.end();
-        let formattedContent = response.formattedContent || null;
-        if (!formattedContent) {
-          const session = toolSessionManager.getSession(sessionId);
-          const responseFormatter = new ResponseFormatter(this.config.tenantId, {
-            sessionId,
-            taskId: session?.taskId,
-            projectId: session?.projectId,
-            contextId,
-            artifactComponents: this.artifactComponents,
-            streamRequestId: this.getStreamRequestId(),
-            subAgentId: this.config.id
-          });
-          if (response.object) {
-            formattedContent = await responseFormatter.formatObjectResponse(
-              response.object,
-              contextId
-            );
-          } else if (textResponse) {
-            formattedContent = await responseFormatter.formatResponse(textResponse, contextId);
+          span.setStatus({ code: api.SpanStatusCode.OK });
+          span.end();
+          let formattedContent = response.formattedContent || null;
+          if (!formattedContent) {
+            const session = toolSessionManager.getSession(sessionId);
+            const responseFormatter = new ResponseFormatter(this.config.tenantId, {
+              sessionId,
+              taskId: session?.taskId,
+              projectId: session?.projectId,
+              contextId,
+              artifactComponents: this.artifactComponents,
+              streamRequestId: this.getStreamRequestId(),
+              subAgentId: this.config.id
+            });
+            if (response.object) {
+              formattedContent = await responseFormatter.formatObjectResponse(
+                response.object,
+                contextId
+              );
+            } else if (textResponse) {
+              formattedContent = await responseFormatter.formatResponse(textResponse, contextId);
+            }
           }
+          const formattedResponse = {
+            ...response,
+            formattedContent
+          };
+          if (streamRequestId) {
+            const generationType = response.object ? "object_generation" : "text_generation";
+            agentSessionManager.recordEvent(streamRequestId, "agent_generate", this.config.id, {
+              parts: (formattedContent?.parts || []).map((part) => ({
+                type: part.kind === "text" ? "text" : part.kind === "data" ? "tool_result" : "text",
+                content: part.text || JSON.stringify(part.data)
+              })),
+              generationType
+            });
+          }
+          return formattedResponse;
+        } catch (error) {
+          const errorToThrow = error instanceof Error ? error : new Error(String(error));
+          agentsCore.setSpanWithError(span, errorToThrow);
+          span.end();
+          throw errorToThrow;
         }
-        const formattedResponse = {
-          ...response,
-          formattedContent
-        };
-        if (streamRequestId) {
-          const generationType = response.object ? "object_generation" : "text_generation";
-          agentSessionManager.recordEvent(streamRequestId, "agent_generate", this.config.id, {
-            parts: (formattedContent?.parts || []).map((part) => ({
-              type: part.kind === "text" ? "text" : part.kind === "data" ? "tool_result" : "text",
-              content: part.text || JSON.stringify(part.data)
-            })),
-            generationType
-          });
-        }
-        return formattedResponse;
-      } catch (error) {
-        const errorToThrow = error instanceof Error ? error : new Error(String(error));
-        agentsCore.setSpanWithError(span, errorToThrow);
-        span.end();
-        throw errorToThrow;
       }
-    });
+    );
   }
 };
 
@@ -12069,7 +12078,17 @@ var generatePreviewRoute = zodOpenapi.createRoute({
       tenantId: z6.z.string(),
       projectId: z6.z.string(),
       id: z6.z.string()
-    })
+    }),
+    body: {
+      content: {
+        "application/json": {
+          schema: z6.z.object({
+            instructions: z6.z.string().optional().describe("Custom instructions for modifying the component"),
+            existingCode: z6.z.string().optional().describe("Existing component code to modify")
+          })
+        }
+      }
+    }
   },
   responses: {
     200: {
@@ -12090,7 +12109,18 @@ var generatePreviewRoute = zodOpenapi.createRoute({
 });
 app4.openapi(generatePreviewRoute, async (c) => {
   const { tenantId, projectId, id } = c.req.valid("param");
-  logger26.info({ tenantId, projectId, dataComponentId: id }, "Generating component preview");
+  const body = c.req.valid("json");
+  const { instructions, existingCode } = body;
+  logger26.info(
+    {
+      tenantId,
+      projectId,
+      dataComponentId: id,
+      hasInstructions: !!instructions,
+      hasExistingCode: !!existingCode
+    },
+    "Generating component preview"
+  );
   const dataComponent = await agentsCore.getDataComponent(dbClient_default)({
     scopes: { tenantId, projectId },
     dataComponentId: id
@@ -12110,7 +12140,7 @@ app4.openapi(generatePreviewRoute, async (c) => {
       message: "Project base model configuration is required"
     });
   }
-  const prompt = buildGenerationPrompt(dataComponent);
+  const prompt = buildGenerationPrompt(dataComponent, instructions, existingCode);
   try {
     const modelConfig = ModelFactory.prepareGenerationConfig(project.models.base);
     const previewSchema = z6.z.object({
@@ -12126,10 +12156,12 @@ app4.openapi(generatePreviewRoute, async (c) => {
     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;
     return streaming.stream(c, async (stream3) => {
       try {
         for await (const partialObject of result.partialObjectStream) {
-          await stream3.write(JSON.stringify(partialObject) + "\n");
+          const outputObject = instructions && existingData ? { ...partialObject, data: existingData } : partialObject;
+          await stream3.write(JSON.stringify(outputObject) + "\n");
         }
       } catch (error) {
         logger26.error(
@@ -12152,10 +12184,50 @@ app4.openapi(generatePreviewRoute, async (c) => {
     });
   }
 });
-function buildGenerationPrompt(dataComponent) {
+function buildGenerationPrompt(dataComponent, instructions, existingCode) {
   const propsSchema = dataComponent.props || {};
   const propsJson = JSON.stringify(propsSchema, null, 2);
   const componentName = sanitizeComponentName(dataComponent.name);
+  if (instructions && existingCode) {
+    return `You are an expert React and Tailwind CSS developer. You need to modify an existing React component based on specific instructions.
+
+COMPONENT DETAILS:
+- Original Name: ${dataComponent.name}
+- Component Function Name: ${componentName}
+- Description: ${dataComponent.description}
+- Props Schema (JSON Schema): ${propsJson}
+
+EXISTING COMPONENT CODE:
+\`\`\`jsx
+${existingCode}
+\`\`\`
+
+MODIFICATION INSTRUCTIONS:
+${instructions}
+
+REQUIREMENTS:
+1. Modify the existing component code according to the instructions
+2. Keep using Tailwind CSS SEMANTIC COLOR CLASSES (bg-background, text-foreground, etc.)
+3. Maintain the balanced spacing and design principles from the original
+4. Keep using lucide-react icons where appropriate
+5. DO NOT include export statements - just the imports and function
+6. DO NOT include TypeScript type annotations
+7. Component name should remain: ${componentName}
+8. DO NOT regenerate sample data - keep the same data structure
+
+OUTPUT FORMAT:
+You need to generate only one thing:
+1. "code": The modified React component code as a string
+
+Return ONLY the code field, the data field will be reused from the existing preview.
+
+EXAMPLE OUTPUT:
+{
+  "code": "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.`;
+  }
   return `You are an expert React and Tailwind CSS developer. Generate a beautiful, modern React component for displaying data and sample data to preview it.
 
 COMPONENT DETAILS: