@inkeep/agents-api 0.46.0 → 0.47.0

package/dist/domains/run/agents/Agent.js

@@ -2,7 +2,7 @@ import { getLogger as getLogger$1 } from "../../../logger.js";
 import { env } from "../../../env.js";
 import manageDbPool_default from "../../../data/db/manageDbPool.js";
 import runDbClient_default from "../../../data/db/runDbClient.js";
-import { AGENT_EXECUTION_MAX_GENERATION_STEPS, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS, LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS } from "../constants/execution-limits/index.js";
+import { AGENT_EXECUTION_MAX_GENERATION_STEPS, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS } from "../constants/execution-limits/index.js";
 import { toolSessionManager } from "./ToolSessionManager.js";
 import { getCompressionConfigForModel } from "../utils/model-context-utils.js";
 import { setSpanWithError as setSpanWithError$1, tracer } from "../utils/tracer.js";
@@ -23,10 +23,9 @@ import { withJsonPostProcessing } from "../utils/json-postprocessor.js";
 import { calculateBreakdownTotal, estimateTokens } from "../utils/token-estimator.js";
 import { createDelegateToAgentTool, createTransferToAgentTool } from "./relationTools.js";
 import { SystemPromptBuilder } from "./SystemPromptBuilder.js";
-import { Phase1Config, V1_BREAKDOWN_SCHEMA } from "./versions/v1/Phase1Config.js";
-import { Phase2Config } from "./versions/v1/Phase2Config.js";
+import { PromptConfig, V1_BREAKDOWN_SCHEMA } from "./versions/v1/PromptConfig.js";
 import { z } from "@hono/zod-openapi";
-import { CredentialStuffer, JsonTransformer, MCPServerType, MCPTransportType, McpClient, ModelFactory, TemplateEngine, buildComposioMCPUrl, createMessage, generateId, getFunctionToolsForSubAgent, getLedgerArtifacts, isGithubWorkAppTool, listTaskIdsByContextId, parseEmbeddedJson, withRef } from "@inkeep/agents-core";
+import { CredentialStuffer, JsonTransformer, MCPServerType, MCPTransportType, McpClient, ModelFactory, TemplateEngine, buildComposioMCPUrl, createMessage, generateId, getFunctionToolsForSubAgent, isGithubWorkAppTool, parseEmbeddedJson, withRef } from "@inkeep/agents-core";
 import { Output, generateText, streamText, tool } from "ai";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
 
@@ -44,6 +43,43 @@ function hasToolCallWithPrefix(prefix) {
 	};
 }
 const logger = getLogger$1("Agent");
+/**
+* Resolves a generation response from either `generateText` or `streamText` into
+* a plain object with all needed values as own properties.
+*
+* **Why this exists:** The AI SDK returns class instances whose key properties
+* (`text`, `steps`, `finishReason`, `output`) are prototype getters.
+* `StreamTextResult` getters return `PromiseLike` values; `GenerateTextResult`
+* getters return direct values. In both cases, the spread operator `{ ...result }`
+* silently drops them. This function uses `Promise.resolve()` to safely resolve
+* both styles, then spreads them as explicit own properties so downstream code
+* (and further spreads) never loses them.
+*/
+async function resolveGenerationResponse(response) {
+	const stepsValue = response.steps;
+	if (!stepsValue) return response;
+	try {
+		const [steps, text, finishReason, output] = await Promise.all([
+			Promise.resolve(stepsValue),
+			Promise.resolve(response.text),
+			Promise.resolve(response.finishReason),
+			Promise.resolve(response.output)
+		]);
+		return {
+			...response,
+			steps,
+			text,
+			finishReason,
+			output
+		};
+	} catch (error) {
+		logger.error({
+			error: error instanceof Error ? error.message : String(error),
+			responseKeys: Object.keys(response)
+		}, "Failed to resolve generation response properties - AI SDK response may be malformed");
+		throw new Error(`Failed to resolve generation response: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
 function validateModel(modelString, modelType) {
 	if (!modelString?.trim()) throw new Error(`${modelType} model is required. Please configure models at the project level.`);
 	return modelString.trim();
@@ -53,7 +89,7 @@ function isValidTool(tool$1) {
 }
 var Agent = class {
 	config;
-	systemPromptBuilder = new SystemPromptBuilder("v1", new Phase1Config());
+	systemPromptBuilder = new SystemPromptBuilder("v1", new PromptConfig());
 	credentialStuffer;
 	streamHelper;
 	streamRequestId;
@@ -141,7 +177,7 @@ var Agent = class {
 		if (toolType === "delegation") return this.config.delegateRelations.find((relation) => this.#createRelationToolName("delegate", relation.config.id) === toolName)?.config.relationId;
 	}
 	/**
-	* Get the primary model settings for text generation and thinking
+	* Get the primary model settings for text generation
 	* Requires model to be configured at project level
 	*/
 	getPrimaryModel() {
@@ -244,7 +280,7 @@ var Agent = class {
 					if (options?.mcpServerName) attributes["ai.toolCall.mcpServerName"] = options.mcpServerName;
 					activeSpan.setAttributes(attributes);
 				}
-				const isInternalToolForUi = toolName.includes("save_tool_result") || toolName.includes("thinking_complete") || toolName.startsWith("transfer_to_") || toolName.startsWith("delegate_to_");
+				const isInternalToolForUi = toolName.includes("save_tool_result") || toolName.startsWith("transfer_to_") || toolName.startsWith("delegate_to_");
 				const needsApproval = options?.needsApproval || false;
 				if (streamRequestId && streamHelper && !isInternalToolForUi) {
 					const inputText = JSON.stringify(args ?? {});
@@ -1070,8 +1106,7 @@ var Agent = class {
 		}
 	}
 	/**
-	* Build adaptive system prompt for Phase 2 structured output generation
-	* based on configured data components and artifact components across the agent
+	* Get the client's current time formatted in their timezone
 	*/
 	getClientCurrentTime() {
 		const clientTimezone = this.config.forwardedHeaders?.["x-inkeep-client-timezone"];
@@ -1097,48 +1132,6 @@ var Agent = class {
 			return;
 		}
 	}
-	async buildPhase2SystemPrompt(runtimeContext) {
-		const phase2Config = new Phase2Config();
-		const compressionConfig = getModelAwareCompressionConfig();
-		const hasAgentArtifactComponents = await this.hasAgentArtifactComponents() || compressionConfig.enabled;
-		const conversationId = runtimeContext?.metadata?.conversationId || runtimeContext?.contextId;
-		const resolvedContext = conversationId ? await this.getResolvedContext(conversationId) : null;
-		let processedPrompt = this.config.prompt || "";
-		if (resolvedContext && this.config.prompt) try {
-			processedPrompt = TemplateEngine.render(this.config.prompt, resolvedContext, {
-				strict: false,
-				preserveUnresolved: false
-			});
-		} catch (error) {
-			logger.error({
-				conversationId,
-				error: error instanceof Error ? error.message : "Unknown error"
-			}, "Failed to process agent prompt with context for Phase 2, using original");
-			processedPrompt = this.config.prompt;
-		}
-		const referenceTaskIds = await listTaskIdsByContextId(runDbClient_default)({ contextId: this.conversationId || "" });
-		const referenceArtifacts = [];
-		for (const taskId of referenceTaskIds) {
-			const artifacts = await getLedgerArtifacts(runDbClient_default)({
-				scopes: {
-					tenantId: this.config.tenantId,
-					projectId: this.config.projectId
-				},
-				taskId
-			});
-			referenceArtifacts.push(...artifacts);
-		}
-		const clientCurrentTime = this.getClientCurrentTime();
-		return phase2Config.assemblePhase2Prompt({
-			corePrompt: processedPrompt,
-			dataComponents: this.config.dataComponents || [],
-			artifactComponents: this.artifactComponents,
-			hasArtifactComponents: this.artifactComponents && this.artifactComponents.length > 0,
-			hasAgentArtifactComponents,
-			artifacts: referenceArtifacts,
-			clientCurrentTime
-		});
-	}
 	async buildSystemPrompt(runtimeContext, excludeDataComponents = false) {
 		const conversationId = runtimeContext?.metadata?.conversationId || runtimeContext?.contextId;
 		if (conversationId) this.setConversationId(conversationId);
@@ -1193,7 +1186,6 @@ var Agent = class {
 			ref: this.executionContext.resolvedRef
 		});
 		const componentDataComponents = excludeDataComponents ? [] : this.config.dataComponents || [];
-		const isThinkingPreparation = this.config.dataComponents && this.config.dataComponents.length > 0 && excludeDataComponents;
 		let prompt = await this.getPrompt();
 		if (prompt && resolvedContext) try {
 			prompt = TemplateEngine.render(prompt, resolvedContext, {
@@ -1209,6 +1201,15 @@ var Agent = class {
 		const shouldIncludeArtifactComponents = !excludeDataComponents;
 		const compressionConfig = getModelAwareCompressionConfig();
 		const hasAgentArtifactComponents = await this.hasAgentArtifactComponents() || compressionConfig.enabled;
+		const hasStructuredOutput = Boolean(this.config.dataComponents && this.config.dataComponents.length > 0);
+		const includeDataComponents = hasStructuredOutput && !excludeDataComponents;
+		logger.info({
+			agentId: this.config.id,
+			hasStructuredOutput,
+			excludeDataComponents,
+			includeDataComponents,
+			dataComponentsCount: this.config.dataComponents?.length || 0
+		}, "System prompt configuration");
 		const clientCurrentTime = this.getClientCurrentTime();
 		const config = {
 			corePrompt: processedPrompt,
@@ -1218,9 +1219,9 @@ var Agent = class {
 			artifacts: referenceArtifacts,
 			artifactComponents: shouldIncludeArtifactComponents ? this.artifactComponents : [],
 			hasAgentArtifactComponents,
-			isThinkingPreparation,
 			hasTransferRelations: (this.config.transferRelations?.length ?? 0) > 0,
 			hasDelegateRelations: (this.config.delegateRelations?.length ?? 0) > 0,
+			includeDataComponents,
 			clientCurrentTime
 		};
 		return await this.systemPromptBuilder.buildSystemPrompt(config);
@@ -1252,24 +1253,10 @@ var Agent = class {
 			}
 		});
 	}
-	createThinkingCompleteTool() {
-		return tool({
-			description: "🚨 CRITICAL: Call this tool IMMEDIATELY when you have gathered enough information to answer the user. This is MANDATORY - you CANNOT provide text responses in thinking mode, only tool calls. Call thinking_complete as soon as you have sufficient data to generate a structured response.",
-			inputSchema: z.object({
-				complete: z.boolean().describe("ALWAYS set to true - marks end of research phase"),
-				summary: z.string().describe("Brief summary of what information was gathered and why it is sufficient to answer the user")
-			}),
-			execute: async (params) => params
-		});
-	}
 	async getDefaultTools(streamRequestId) {
 		const defaultTools = {};
 		const compressionConfig = getModelAwareCompressionConfig();
 		if (await this.agentHasArtifactComponents() || compressionConfig.enabled) defaultTools.get_reference_artifact = this.getArtifactTools();
-		if (this.config.dataComponents && this.config.dataComponents.length > 0) {
-			const thinkingCompleteTool = this.createThinkingCompleteTool();
-			if (thinkingCompleteTool) defaultTools.thinking_complete = this.wrapToolWithStreaming("thinking_complete", thinkingCompleteTool, streamRequestId, "tool");
-		}
 		logger.info({
 			agentId: this.config.id,
 			streamRequestId
@@ -1651,7 +1638,7 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 		} }, async (span) => {
 			const { contextId, taskId, streamRequestId, sessionId } = this.setupGenerationContext(runtimeContext);
 			try {
-				const { systemPrompt, thinkingSystemPrompt, sanitizedTools, contextBreakdown: initialContextBreakdown } = await this.loadToolsAndPrompts(sessionId, streamRequestId, runtimeContext);
+				const { systemPrompt, sanitizedTools, contextBreakdown: initialContextBreakdown } = await this.loadToolsAndPrompts(sessionId, streamRequestId, runtimeContext);
 				if (streamRequestId && this.artifactComponents.length > 0) agentSessionManager.updateArtifactComponents(streamRequestId, this.artifactComponents);
 				const conversationId = runtimeContext?.metadata?.conversationId;
 				if (conversationId) this.setConversationId(conversationId);
@@ -1660,50 +1647,48 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 				for (const componentDef of V1_BREAKDOWN_SCHEMA) breakdownAttributes[componentDef.spanAttribute] = contextBreakdown.components[componentDef.key] ?? 0;
 				breakdownAttributes["context.breakdown.total_tokens"] = contextBreakdown.total;
 				span.setAttributes(breakdownAttributes);
-				const { primaryModelSettings, modelSettings, hasStructuredOutput, shouldStreamPhase1, timeoutMs } = this.configureModelSettings();
+				const { primaryModelSettings, modelSettings, hasStructuredOutput, timeoutMs } = this.configureModelSettings();
 				let response;
 				let textResponse;
-				const messages = this.buildInitialMessages(systemPrompt, thinkingSystemPrompt, hasStructuredOutput, conversationHistory, userMessage);
+				const messages = this.buildInitialMessages(systemPrompt, conversationHistory, userMessage);
 				const { originalMessageCount, compressor } = this.setupCompression(messages, sessionId, contextId, primaryModelSettings);
-				if (shouldStreamPhase1) {
-					const streamConfig = {
-						...modelSettings,
-						toolChoice: "auto"
-					};
-					const streamResult = streamText(this.buildBaseGenerationConfig(streamConfig, messages, sanitizedTools, compressor, originalMessageCount, timeoutMs, "auto", void 0, false, contextBreakdown.total));
-					const parser = this.setupStreamParser(sessionId, contextId);
-					await this.processStreamEvents(streamResult, parser);
-					response = await streamResult;
-					response = this.formatStreamingResponse(response, parser);
-				} else {
-					const toolChoice = hasStructuredOutput ? "required" : "auto";
-					response = await generateText(this.buildBaseGenerationConfig(modelSettings, messages, sanitizedTools, compressor, originalMessageCount, timeoutMs, toolChoice, "planning", true, contextBreakdown.total));
-				}
-				if (response.steps) {
-					const resolvedSteps = await response.steps;
-					response = {
-						...response,
-						steps: resolvedSteps
-					};
-				}
-				if (hasStructuredOutput && !hasToolCallWithPrefix("transfer_to_")(response)) if (response.steps?.flatMap((s) => s.toolCalls || [])?.find((tc) => tc.toolName === "thinking_complete")) {
-					const reasoningFlow = this.buildReasoningFlow(response, sessionId);
-					const dataComponentsSchema = this.buildDataComponentsSchema();
-					const structuredModelSettings = ModelFactory.prepareGenerationConfig(this.getStructuredOutputModel());
-					const phase2TimeoutMs = this.calculatePhase2Timeout(structuredModelSettings);
-					if (this.getStreamingHelper()) {
-						const phase2Messages = await this.buildPhase2Messages(runtimeContext, conversationHistory, userMessage, reasoningFlow);
-						const result = await this.executeStreamingPhase2(structuredModelSettings, phase2Messages, dataComponentsSchema, phase2TimeoutMs, sessionId, contextId, response);
-						response = result;
-						textResponse = result.textResponse;
-					} else {
-						const phase2Messages = await this.buildPhase2Messages(runtimeContext, conversationHistory, userMessage, reasoningFlow);
-						const result = await this.executeNonStreamingPhase2(structuredModelSettings, phase2Messages, dataComponentsSchema, phase2TimeoutMs, response);
-						response = result;
-						textResponse = result.textResponse;
-					}
-				} else textResponse = response.text || "";
-				else textResponse = response.steps[response.steps.length - 1].text || "";
+				const streamConfig = {
+					...modelSettings,
+					toolChoice: "auto"
+				};
+				const shouldStream = this.getStreamingHelper();
+				const dataComponentsSchema = hasStructuredOutput ? this.buildDataComponentsSchema() : null;
+				const baseConfig = this.buildBaseGenerationConfig(streamConfig, messages, sanitizedTools, compressor, originalMessageCount, timeoutMs, "auto", dataComponentsSchema ? "structured_generation" : void 0, contextBreakdown.total);
+				const generationConfig = dataComponentsSchema ? {
+					...baseConfig,
+					output: Output.object({ schema: z.object({ dataComponents: z.array(dataComponentsSchema) }) })
+				} : baseConfig;
+				const nonStreamingConfig = withJsonPostProcessing(generationConfig);
+				logger.info({
+					agentId: this.config.id,
+					hasStructuredOutput,
+					shouldStream
+				}, "🚀 Starting generation");
+				let rawResponse;
+				if (shouldStream) rawResponse = await this.handleStreamGeneration(streamText(generationConfig), sessionId, contextId, !!dataComponentsSchema);
+				else rawResponse = await generateText(nonStreamingConfig);
+				logger.info({
+					agentId: this.config.id,
+					hasOutput: !!rawResponse.output,
+					dataComponentsCount: rawResponse.output?.dataComponents?.length || 0,
+					finishReason: rawResponse.finishReason
+				}, "✅ Generation completed");
+				response = await resolveGenerationResponse(rawResponse);
+				if (hasStructuredOutput && response.output) {
+					response.object = response.output;
+					logger.info({
+						agentId: this.config.id,
+						dataComponentsCount: response.output?.dataComponents?.length || 0,
+						dataComponentNames: response.output?.dataComponents?.map((dc) => dc.name) || []
+					}, "📦 Processing response with data components");
+					textResponse = JSON.stringify(response.output, null, 2);
+				} else if (hasToolCallWithPrefix("transfer_to_")(response)) textResponse = response.steps[response.steps.length - 1].text || "";
+				else textResponse = response.text || "";
 				span.setStatus({ code: SpanStatusCode.OK });
 				span.end();
 				const formattedResponse = await this.formatFinalResponse(response, textResponse, sessionId, contextId);
@@ -1749,7 +1734,7 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 	* Load all tools and system prompts in parallel, then combine and sanitize them
 	*/
 	async loadToolsAndPrompts(sessionId, streamRequestId, runtimeContext) {
-		const [mcpTools, systemPromptResult, thinkingSystemPromptResult, functionTools, relationTools, defaultTools] = await tracer.startActiveSpan("agent.load_tools", { attributes: {
+		const [mcpTools, systemPromptResult, functionTools, relationTools, defaultTools] = await tracer.startActiveSpan("agent.load_tools", { attributes: {
 			"subAgent.name": this.config.name,
 			"session.id": sessionId || "none"
 		} }, async (childSpan) => {
@@ -1757,7 +1742,6 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 				const result = await Promise.all([
 					this.getMcpTools(sessionId, streamRequestId),
 					this.buildSystemPrompt(runtimeContext, false),
-					this.buildSystemPrompt(runtimeContext, true),
 					this.getFunctionTools(sessionId, streamRequestId),
 					Promise.resolve(this.getRelationTools(runtimeContext, sessionId)),
 					this.getDefaultTools(streamRequestId)
@@ -1772,7 +1756,6 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 			}
 		});
 		const systemPrompt = systemPromptResult.prompt;
-		const thinkingSystemPrompt = thinkingSystemPromptResult.prompt;
 		const contextBreakdown = systemPromptResult.breakdown;
 		const allTools = {
 			...mcpTools,
@@ -1782,7 +1765,6 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 		};
 		return {
 			systemPrompt,
-			thinkingSystemPrompt,
 			sanitizedTools: this.sanitizeToolsForAISDK(allTools),
 			contextBreakdown
 		};
@@ -1845,11 +1827,10 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 	* Configure model settings, timeouts, and streaming behavior
 	*/
 	configureModelSettings() {
-		const primaryModelSettings = this.getPrimaryModel();
-		const modelSettings = ModelFactory.prepareGenerationConfig(primaryModelSettings);
 		const hasStructuredOutput = Boolean(this.config.dataComponents && this.config.dataComponents.length > 0);
-		const shouldStreamPhase1 = this.getStreamingHelper() && !hasStructuredOutput;
-		const configuredTimeout = modelSettings.maxDuration ? Math.min(modelSettings.maxDuration * 1e3, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS) : shouldStreamPhase1 ? LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING : LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING;
+		const primaryModelSettings = hasStructuredOutput ? this.getStructuredOutputModel() : this.getPrimaryModel();
+		const modelSettings = ModelFactory.prepareGenerationConfig(primaryModelSettings);
+		const configuredTimeout = modelSettings.maxDuration ? Math.min(modelSettings.maxDuration * 1e3, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS) : LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING;
 		const timeoutMs = Math.min(configuredTimeout, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS);
 		if (modelSettings.maxDuration && modelSettings.maxDuration * 1e3 > LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS) logger.warn({
 			requestedTimeout: modelSettings.maxDuration * 1e3,
@@ -1863,19 +1844,17 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 				maxDuration: timeoutMs / 1e3
 			},
 			hasStructuredOutput,
-			shouldStreamPhase1,
 			timeoutMs
 		};
 	}
 	/**
 	* Build initial messages array with system prompt and user content
 	*/
-	buildInitialMessages(systemPrompt, thinkingSystemPrompt, hasStructuredOutput, conversationHistory, userMessage) {
-		const phase1SystemPrompt = hasStructuredOutput ? thinkingSystemPrompt : systemPrompt;
+	buildInitialMessages(systemPrompt, conversationHistory, userMessage) {
 		const messages = [];
 		messages.push({
 			role: "system",
-			content: phase1SystemPrompt
+			content: systemPrompt
 		});
 		if (conversationHistory.trim() !== "") messages.push({
 			role: "user",
@@ -1959,7 +1938,7 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 		}
 		return {};
 	}
-	async handleStopWhenConditions(steps, includeThinkingComplete = false) {
+	async handleStopWhenConditions(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: [{
@@ -1969,7 +1948,7 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 		} catch (error) {
 			logger.debug({ error }, "Failed to track agent reasoning");
 		}
-		if (!includeThinkingComplete && last && last.content && last.content.length > 0) {
+		if (last?.content && last.content.length > 0) {
 			const lastContent = last.content[last.content.length - 1];
 			if (lastContent.type === "tool-error") {
 				const error = lastContent.error;
@@ -1979,10 +1958,7 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 		if (steps.length >= 1) {
 			const currentStep = steps[steps.length - 1];
 			if (currentStep && "toolCalls" in currentStep && currentStep.toolCalls) {
-				const hasTransferTool = currentStep.toolCalls.some((tc) => tc.toolName.startsWith("transfer_to_"));
-				const hasThinkingComplete = currentStep.toolCalls.some((tc) => tc.toolName === "thinking_complete");
-				if (hasTransferTool) return true;
-				if (includeThinkingComplete && hasThinkingComplete && "toolResults" in currentStep && currentStep.toolResults) return true;
+				if (currentStep.toolCalls.some((tc) => tc.toolName.startsWith("transfer_to_"))) return true;
 			}
 		}
 		const maxSteps = this.getMaxGenerationSteps();
@@ -2035,7 +2011,7 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 			}
 		};
 	}
-	buildBaseGenerationConfig(modelSettings, messages, sanitizedTools, compressor, originalMessageCount, timeoutMs, toolChoice = "auto", phase, includeThinkingComplete = false, fullContextSize) {
+	buildBaseGenerationConfig(modelSettings, messages, sanitizedTools, compressor, originalMessageCount, timeoutMs, toolChoice = "auto", phase, fullContextSize) {
 		return {
 			...modelSettings,
 			toolChoice,
@@ -2045,78 +2021,12 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 				return await this.handlePrepareStepCompression(stepMessages, compressor, originalMessageCount, fullContextSize);
 			},
 			stopWhen: async ({ steps }) => {
-				return await this.handleStopWhenConditions(steps, includeThinkingComplete);
+				return await this.handleStopWhenConditions(steps);
 			},
 			experimental_telemetry: this.buildTelemetryConfig(phase),
 			abortSignal: AbortSignal.timeout(timeoutMs)
 		};
 	}
-	buildReasoningFlow(response, sessionId) {
-		const reasoningFlow = [];
-		const compressionSummary = this.currentCompressor?.getCompressionSummary();
-		if (compressionSummary) {
-			const summaryContent = JSON.stringify(compressionSummary, null, 2);
-			reasoningFlow.push({
-				role: "assistant",
-				content: `## Research Summary (Compressed)\n\nBased on tool executions, here's the comprehensive summary:\n\n\`\`\`json\n${summaryContent}\n\`\`\`\n\nThis summary represents all tool execution results in compressed form. Full details are preserved in artifacts.`
-			});
-		} else 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);
-					if ((storedResult?.toolName || call.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 = `
-### 📊 Structure Hints for Artifact Creation
-
-**Terminal Field Paths (${hints.terminalPaths?.length || 0} found):**
-${hints.terminalPaths?.map((path) => `  • ${path}`).join("\n") || "  None detected"}
-
-**Array Structures (${hints.arrayPaths?.length || 0} found):**
-${hints.arrayPaths?.map((path) => `  • ${path}`).join("\n") || "  None detected"}
-
-**Object Structures (${hints.objectPaths?.length || 0} found):**
-${hints.objectPaths?.map((path) => `  • ${path}`).join("\n") || "  None detected"}
-
-**Example Selectors:**
-${hints.exampleSelectors?.map((sel) => `  • ${sel}`).join("\n") || "  None detected"}
-
-**Common Fields:**
-${hints.commonFields?.map((field) => `  • ${field}`).join("\n") || "  None detected"}
-
-**Structure Stats:** ${hints.totalPathsFound || 0} total paths, ${hints.maxDepthFound || 0} levels deep
-
-**Note:** ${hints.note || "Use these paths for artifact base selectors."}
-
-**Forbidden Syntax:** ${hints.forbiddenSyntax || "Use these paths for artifact base selectors."}
-`;
-					}
-					const formattedResult = `## Tool: ${call.toolName}
-
-### 🔧 TOOL_CALL_ID: ${result.toolCallId}
-
-### Input
-${input}
-
-### Output
-${output}${structureHintsFormatted}`;
-					reasoningFlow.push({
-						role: "assistant",
-						content: formattedResult
-					});
-				}
-			});
-		});
-		return reasoningFlow;
-	}
 	buildDataComponentsSchema() {
 		const componentSchemas = [];
 		this.config.dataComponents?.forEach((dc) => {
@@ -2142,75 +2052,6 @@ ${output}${structureHintsFormatted}`;
 		}
 		return dataComponentsSchema;
 	}
-	calculatePhase2Timeout(structuredModelSettings) {
-		const configuredPhase2Timeout = structuredModelSettings.maxDuration ? Math.min(structuredModelSettings.maxDuration * 1e3, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS) : LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS;
-		const phase2TimeoutMs = Math.min(configuredPhase2Timeout, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS);
-		if (structuredModelSettings.maxDuration && structuredModelSettings.maxDuration * 1e3 > LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS) logger.warn({
-			requestedTimeout: structuredModelSettings.maxDuration * 1e3,
-			appliedTimeout: phase2TimeoutMs,
-			maxAllowed: LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS,
-			phase: "structured_generation"
-		}, "Phase 2 requested timeout exceeded maximum allowed, capping to 10 minutes");
-		return phase2TimeoutMs;
-	}
-	async buildPhase2Messages(runtimeContext, conversationHistory, userMessage, reasoningFlow) {
-		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);
-		if (reasoningFlow.length > 0 && reasoningFlow[reasoningFlow.length - 1]?.role === "assistant") phase2Messages.push({
-			role: "user",
-			content: "Continue with the structured response."
-		});
-		return phase2Messages;
-	}
-	async executeStreamingPhase2(structuredModelSettings, phase2Messages, dataComponentsSchema, phase2TimeoutMs, sessionId, contextId, response) {
-		const streamResult = streamText({
-			...structuredModelSettings,
-			messages: phase2Messages,
-			output: Output.object({ schema: z.object({ dataComponents: z.array(dataComponentsSchema) }) }),
-			experimental_telemetry: this.buildTelemetryConfig("structured_generation"),
-			abortSignal: AbortSignal.timeout(phase2TimeoutMs)
-		});
-		const parser = this.setupStreamParser(sessionId, contextId);
-		for await (const delta of streamResult.partialOutputStream) 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 }
-		})) };
-		return {
-			...response,
-			object: structuredResponse.output,
-			textResponse: JSON.stringify(structuredResponse.output, null, 2)
-		};
-	}
-	async executeNonStreamingPhase2(structuredModelSettings, phase2Messages, dataComponentsSchema, phase2TimeoutMs, response) {
-		const structuredResponse = await generateText(withJsonPostProcessing({
-			...structuredModelSettings,
-			messages: phase2Messages,
-			output: Output.object({ schema: z.object({ dataComponents: z.array(dataComponentsSchema) }) }),
-			experimental_telemetry: this.buildTelemetryConfig("structured_generation"),
-			abortSignal: AbortSignal.timeout(phase2TimeoutMs)
-		}));
-		return {
-			...response,
-			object: structuredResponse.output,
-			textResponse: JSON.stringify(structuredResponse.output, null, 2)
-		};
-	}
 	async formatFinalResponse(response, textResponse, sessionId, contextId) {
 		let formattedContent = response.formattedContent || null;
 		if (!formattedContent) {
@@ -2236,6 +2077,12 @@ ${output}${structureHintsFormatted}`;
 		if (this.currentCompressor) this.currentCompressor.fullCleanup();
 		this.currentCompressor = null;
 		const errorToThrow = error instanceof Error ? error : new Error(String(error));
+		logger.error({
+			agentId: this.config.id,
+			errorMessage: errorToThrow.message,
+			errorStack: errorToThrow.stack,
+			errorName: errorToThrow.name
+		}, "❌ Generation error in Agent");
 		setSpanWithError$1(span, errorToThrow);
 		span.end();
 		throw errorToThrow;
@@ -2250,6 +2097,21 @@ ${output}${structureHintsFormatted}`;
 			this.currentCompressor = null;
 		}
 	}
+	async handleStreamGeneration(streamResult, sessionId, contextId, hasStructuredOutput) {
+		const parser = this.setupStreamParser(sessionId, contextId);
+		if (hasStructuredOutput) {
+			for await (const delta of streamResult.partialOutputStream) if (delta) await parser.processObjectDelta(delta);
+		} else await this.processStreamEvents(streamResult, parser);
+		await parser.finalize();
+		const 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 }
+		})) };
+		return response;
+	}
 	async processStreamEvents(streamResult, parser) {
 		for await (const event of streamResult.fullStream) switch (event.type) {
 			case "text-delta":
@@ -2270,24 +2132,8 @@ ${output}${structureHintsFormatted}`;
 				throw new Error(errorMessage);
 			}
 		}
-		await parser.finalize();
-	}
-	formatStreamingResponse(response, parser) {
-		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 }
-		})) };
-		return response;
 	}
 };
 
 //#endregion
-export { Agent, hasToolCallWithPrefix };
+export { Agent, hasToolCallWithPrefix, resolveGenerationResponse };

package/dist/domains/run/agents/generateTaskHandler.js

@@ -311,11 +311,16 @@ const createTaskHandler = (config, credentialStoreRegistry) => {
 					}, "[DEBUG] Transfer validation FAILED");
 				}
 			}
-			const parts = (response.formattedContent?.parts || []).map((part) => ({
-				kind: part.kind,
-				...part.kind === "text" && { text: part.text },
-				...part.kind === "data" && { data: part.data }
-			}));
+			const parts = (response.formattedContent?.parts || []).map((part) => {
+				if (part.kind === "data") return {
+					kind: "data",
+					data: part.data
+				};
+				return {
+					kind: "text",
+					text: part.text
+				};
+			});
 			return {
 				status: { state: TaskState.Completed },
 				artifacts: [{