@inkeep/agents-run-api 0.0.0-dev-20260105192809 → 0.0.0-dev-20260105201718

package/dist/agents/Agent.js

@@ -2,18 +2,21 @@ import { getLogger } from "../logger.js";
 import dbClient_default from "../data/db/dbClient.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 { toolSessionManager } from "./ToolSessionManager.js";
-import { createDefaultConversationHistoryConfig, getFormattedConversationHistory } from "../data/conversations.js";
-import { getStreamHelper } from "../utils/stream-registry.js";
+import { getCompressionConfigForModel } from "../utils/model-context-utils.js";
 import { setSpanWithError as setSpanWithError$1, tracer } from "../utils/tracer.js";
+import { getModelAwareCompressionConfig } from "../services/BaseCompressor.js";
+import "../services/ConversationCompressor.js";
+import { createDefaultConversationHistoryConfig, getConversationHistoryWithCompression } from "../data/conversations.js";
+import { getStreamHelper } from "../utils/stream-registry.js";
 import { agentSessionManager } from "../services/AgentSession.js";
 import { IncrementalStreamParser } from "../services/IncrementalStreamParser.js";
-import { MidGenerationCompressor, getCompressionConfigFromEnv } from "../services/MidGenerationCompressor.js";
+import { MidGenerationCompressor } from "../services/MidGenerationCompressor.js";
 import { pendingToolApprovalManager } from "../services/PendingToolApprovalManager.js";
 import { ResponseFormatter } from "../services/ResponseFormatter.js";
 import { generateToolId } from "../utils/agent-operations.js";
 import { jsonSchemaToZod } from "../utils/data-component-schema.js";
 import { ArtifactCreateSchema, ArtifactReferenceSchema } from "../utils/artifact-component-schema.js";
-import { getCompressionConfigForModel } from "../utils/model-context-utils.js";
+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";
@@ -183,21 +186,6 @@ var Agent = class {
 	/**
 	* Simple compression fallback: drop oldest messages to fit under token limit
 	*/
-	simpleCompression(messages, targetTokens) {
-		if (messages.length === 0) return messages;
-		const estimateTokens$1 = (msg) => {
-			const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
-			return Math.ceil(content.length / 4);
-		};
-		let totalTokens = messages.reduce((sum, msg) => sum + estimateTokens$1(msg), 0);
-		if (totalTokens <= targetTokens) return messages;
-		const result = [...messages];
-		while (totalTokens > targetTokens && result.length > 1) {
-			const dropped = result.shift();
-			if (dropped) totalTokens -= estimateTokens$1(dropped);
-		}
-		return result;
-	}
 	/**
 	* Set delegation status for this agent instance
 	*/
@@ -931,7 +919,7 @@ var Agent = class {
 	*/
 	async buildPhase2SystemPrompt(runtimeContext) {
 		const phase2Config = new Phase2Config();
-		const compressionConfig = getCompressionConfigFromEnv();
+		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;
@@ -1036,7 +1024,7 @@ var Agent = class {
 			}, "Failed to process agent prompt with context, using original");
 		}
 		const shouldIncludeArtifactComponents = !excludeDataComponents;
-		const compressionConfig = getCompressionConfigFromEnv();
+		const compressionConfig = getModelAwareCompressionConfig();
 		const hasAgentArtifactComponents = await this.hasAgentArtifactComponents() || compressionConfig.enabled;
 		const config = {
 			corePrompt: processedPrompt,
@@ -1091,7 +1079,7 @@ var Agent = class {
 	}
 	async getDefaultTools(streamRequestId) {
 		const defaultTools = {};
-		const compressionConfig = getCompressionConfigFromEnv();
+		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();
@@ -1316,80 +1304,13 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 			"subAgent.id": this.config.id,
 			"subAgent.name": this.config.name
 		} }, async (span) => {
-			const contextId = runtimeContext?.contextId || "default";
-			const taskId = runtimeContext?.metadata?.taskId || "unknown";
-			const streamRequestId = runtimeContext?.metadata?.streamRequestId;
-			const sessionId = streamRequestId || "fallback-session";
+			const { contextId, taskId, streamRequestId, sessionId } = this.setupGenerationContext(runtimeContext);
 			try {
-				this.streamRequestId = streamRequestId;
-				this.streamHelper = streamRequestId ? getStreamHelper(streamRequestId) : void 0;
+				const { systemPrompt, thinkingSystemPrompt, 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);
-				const [mcpTools, systemPromptResult, thinkingSystemPromptResult, functionTools, relationTools, defaultTools] = await tracer.startActiveSpan("agent.load_tools", { attributes: {
-					"subAgent.name": this.config.name,
-					"session.id": sessionId || "none"
-				} }, async (childSpan) => {
-					try {
-						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)
-						]);
-						childSpan.setStatus({ code: SpanStatusCode.OK });
-						return result;
-					} catch (err) {
-						setSpanWithError$1(childSpan, err instanceof Error ? err : new Error(String(err)));
-						throw err;
-					} finally {
-						childSpan.end();
-					}
-				});
-				const systemPrompt = systemPromptResult.prompt;
-				const thinkingSystemPrompt = thinkingSystemPromptResult.prompt;
-				const contextBreakdown = systemPromptResult.breakdown;
-				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") {
-						const filters = {
-							delegationId: this.delegationId,
-							isDelegated: this.isDelegatedAgent
-						};
-						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,
-							delegationId: this.delegationId,
-							isDelegated: this.isDelegatedAgent
-						}
-					});
-				}
-				contextBreakdown.conversationHistory = estimateTokens(conversationHistory);
-				calculateBreakdownTotal(contextBreakdown);
+				const { conversationHistory, contextBreakdown } = await this.buildConversationHistory(contextId, taskId, userMessage, streamRequestId, initialContextBreakdown);
 				span.setAttributes({
 					"context.breakdown.system_template_tokens": contextBreakdown.systemPromptTemplate,
 					"context.breakdown.core_instructions_tokens": contextBreakdown.coreInstructions,
@@ -1404,289 +1325,24 @@ ${typeof cleanResult === "string" ? cleanResult : JSON.stringify(cleanResult, nu
 					"context.breakdown.conversation_history_tokens": contextBreakdown.conversationHistory,
 					"context.breakdown.total_tokens": contextBreakdown.total
 				});
-				const primaryModelSettings = this.getPrimaryModel();
-				const modelSettings = ModelFactory.prepareGenerationConfig(primaryModelSettings);
+				const { primaryModelSettings, modelSettings, hasStructuredOutput, shouldStreamPhase1, timeoutMs } = this.configureModelSettings();
 				let response;
 				let textResponse;
-				const hasStructuredOutput = 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 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,
-					appliedTimeout: timeoutMs,
-					maxAllowed: LLM_GENERATION_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
-				});
-				const originalMessageCount = messages.length;
-				const compressionConfigResult = getCompressionConfigForModel(primaryModelSettings);
-				const compressionConfig = {
-					hardLimit: compressionConfigResult.hardLimit,
-					safetyBuffer: compressionConfigResult.safetyBuffer,
-					enabled: compressionConfigResult.enabled
-				};
-				const compressor = compressionConfig.enabled ? new MidGenerationCompressor(sessionId, contextId, this.config.tenantId, this.config.projectId, compressionConfig, this.getSummarizerModel(), primaryModelSettings) : null;
-				this.currentCompressor = compressor;
+				const messages = this.buildInitialMessages(systemPrompt, thinkingSystemPrompt, hasStructuredOutput, conversationHistory, userMessage);
+				const { originalMessageCount, compressor } = this.setupCompression(messages, sessionId, contextId, primaryModelSettings);
 				if (shouldStreamPhase1) {
-					const streamResult = streamText({
+					const streamConfig = {
 						...modelSettings,
-						toolChoice: "auto",
-						messages,
-						tools: sanitizedTools,
-						prepareStep: async ({ messages: stepMessages }) => {
-							if (!compressor) return {};
-							if (compressor.isCompressionNeeded(stepMessages)) {
-								logger.info({ compressorState: compressor.getState() }, "Triggering layered mid-generation compression");
-								try {
-									const originalMessages = stepMessages.slice(0, originalMessageCount);
-									const generatedMessages = stepMessages.slice(originalMessageCount);
-									if (generatedMessages.length > 0) {
-										const compressionResult = await compressor.compress(generatedMessages);
-										const finalMessages = [...originalMessages];
-										if (compressionResult.summary.text_messages && compressionResult.summary.text_messages.length > 0) finalMessages.push(...compressionResult.summary.text_messages);
-										const summaryMessage = JSON.stringify({
-											high_level: compressionResult.summary?.summary?.high_level,
-											user_intent: compressionResult.summary?.summary?.user_intent,
-											decisions: compressionResult.summary?.summary?.decisions,
-											open_questions: compressionResult.summary?.summary?.open_questions,
-											next_steps: compressionResult.summary?.summary?.next_steps,
-											related_artifacts: compressionResult?.summary?.summary?.related_artifacts
-										});
-										finalMessages.push({
-											role: "user",
-											content: `Based on your research, here's what you've discovered: ${summaryMessage}
-
-Now please provide your answer to my original question using this context.`
-										});
-										logger.info({
-											originalTotal: stepMessages.length,
-											compressed: finalMessages.length,
-											originalKept: originalMessages.length,
-											generatedCompressed: generatedMessages.length
-										}, "Generated content compression completed");
-										logger.info({ summaryMessage }, "Summary message");
-										return { messages: finalMessages };
-									}
-									return {};
-								} catch (error) {
-									logger.error({
-										error: error instanceof Error ? error.message : String(error),
-										stack: error instanceof Error ? error.stack : void 0
-									}, "Smart compression failed, falling back to simple compression");
-									try {
-										const targetSize = Math.floor(compressor.getHardLimit() * .5);
-										const fallbackMessages = this.simpleCompression(stepMessages, targetSize);
-										logger.info({
-											originalCount: stepMessages.length,
-											compressedCount: fallbackMessages.length,
-											compressionType: "simple_fallback"
-										}, "Simple compression fallback completed");
-										return { messages: fallbackMessages };
-									} catch (fallbackError) {
-										logger.error({ error: fallbackError instanceof Error ? fallbackError.message : String(fallbackError) }, "Fallback compression also failed, continuing without compression");
-										return {};
-									}
-								}
-							}
-							return {};
-						},
-						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) {
-								logger.debug({ error }, "Failed to track agent reasoning");
-							}
-							if (last && last["content"] && last["content"].length > 0) {
-								const lastContent = last["content"][last["content"].length - 1];
-								if (lastContent["type"] === "tool-error") {
-									const error = lastContent["error"];
-									if (error && typeof error === "object" && "name" in error && error.name === "connection_refused") return true;
-								}
-							}
-							if (steps.length >= 2) {
-								const previousStep = steps[steps.length - 2];
-								if (previousStep && "toolCalls" in previousStep && previousStep.toolCalls) {
-									if (previousStep.toolCalls.some((tc) => tc.toolName.startsWith("transfer_to_")) && "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: {
-								subAgentId: this.config.id,
-								subAgentName: this.config.name
-							}
-						},
-						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
+						toolChoice: "auto"
 					};
-					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;
-							const errorMessage = event.error?.error?.message;
-							throw new Error(errorMessage);
-						}
-					}
-					await parser.finalize();
+					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;
-					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 }
-					})) };
+					response = this.formatStreamingResponse(response, parser);
 				} else {
-					let genConfig;
-					if (hasStructuredOutput) genConfig = {
-						...modelSettings,
-						toolChoice: "required"
-					};
-					else genConfig = {
-						...modelSettings,
-						toolChoice: "auto"
-					};
-					response = await generateText({
-						...genConfig,
-						messages,
-						tools: sanitizedTools,
-						prepareStep: async ({ messages: stepMessages }) => {
-							if (!compressor) return {};
-							if (compressor.isCompressionNeeded(stepMessages)) {
-								logger.info({ compressorState: compressor.getState() }, "Triggering layered mid-generation compression");
-								try {
-									const originalMessages = stepMessages.slice(0, originalMessageCount);
-									const generatedMessages = stepMessages.slice(originalMessageCount);
-									if (generatedMessages.length > 0) {
-										const compressionResult = await compressor.compress(generatedMessages);
-										const finalMessages = [...originalMessages];
-										if (compressionResult.summary.text_messages && compressionResult.summary.text_messages.length > 0) finalMessages.push(...compressionResult.summary.text_messages);
-										const summaryMessage = JSON.stringify({
-											high_level: compressionResult.summary?.summary?.high_level,
-											user_intent: compressionResult.summary?.summary?.user_intent,
-											decisions: compressionResult.summary?.summary?.decisions,
-											open_questions: compressionResult.summary?.summary?.open_questions,
-											next_steps: compressionResult.summary?.summary?.next_steps,
-											related_artifacts: compressionResult?.summary?.summary?.related_artifacts
-										});
-										finalMessages.push({
-											role: "user",
-											content: `Based on your research, here's what you've discovered: ${summaryMessage}
-
-Now please provide your answer to my original question using this context.`
-										});
-										logger.info({
-											originalTotal: stepMessages.length,
-											compressed: finalMessages.length,
-											originalKept: originalMessages.length,
-											generatedCompressed: generatedMessages.length
-										}, "Generated content compression completed");
-										logger.info({ summaryMessage }, "Summary message");
-										return { messages: finalMessages };
-									}
-									return {};
-								} catch (error) {
-									logger.error({
-										error: error instanceof Error ? error.message : String(error),
-										stack: error instanceof Error ? error.stack : void 0
-									}, "Smart compression failed, falling back to simple compression");
-									try {
-										const targetSize = Math.floor(compressor.getHardLimit() * .5);
-										const fallbackMessages = this.simpleCompression(stepMessages, targetSize);
-										logger.info({
-											originalCount: stepMessages.length,
-											compressedCount: fallbackMessages.length,
-											compressionType: "simple_fallback"
-										}, "Simple compression fallback completed");
-										return { messages: fallbackMessages };
-									} catch (fallbackError) {
-										logger.error({ error: fallbackError instanceof Error ? fallbackError.message : String(fallbackError) }, "Fallback compression also failed, continuing without compression");
-										return {};
-									}
-								}
-							}
-							return {};
-						},
-						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) {
-								logger.debug({ error }, "Failed to track agent reasoning");
-							}
-							if (steps.length >= 2) {
-								const previousStep = steps[steps.length - 2];
-								if (previousStep && "toolCalls" in previousStep && previousStep.toolCalls) {
-									if (previousStep.toolCalls.some((tc) => tc.toolName.startsWith("transfer_to_") || tc.toolName === "thinking_complete") && "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",
-								subAgentId: this.config.id,
-								subAgentName: this.config.name
-							}
-						},
-						abortSignal: AbortSignal.timeout(timeoutMs)
-					});
+					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;
@@ -1696,29 +1352,368 @@ Now please provide your answer to my original question using this context.`
 					};
 				}
 				if (hasStructuredOutput && !hasToolCallWithPrefix("transfer_to_")(response)) if (response.steps?.flatMap((s) => s.toolCalls || [])?.find((tc) => tc.toolName === "thinking_complete")) {
-					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 = `
+					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 || "";
+				span.setStatus({ code: SpanStatusCode.OK });
+				span.end();
+				const formattedResponse = await this.formatFinalResponse(response, textResponse, sessionId, contextId);
+				if (streamRequestId) {
+					const generationType = response.object ? "object_generation" : "text_generation";
+					agentSessionManager.recordEvent(streamRequestId, "agent_generate", this.config.id, {
+						parts: (formattedResponse.formattedContent?.parts || []).map((part) => ({
+							type: part.kind === "text" ? "text" : part.kind === "data" ? "tool_result" : "text",
+							content: part.text || JSON.stringify(part.data)
+						})),
+						generationType
+					});
+				}
+				if (compressor) compressor.fullCleanup();
+				this.currentCompressor = null;
+				return formattedResponse;
+			} catch (error) {
+				this.handleGenerationError(error, span);
+			}
+		});
+	}
+	/**
+	* Setup generation context and initialize streaming helper
+	*/
+	setupGenerationContext(runtimeContext) {
+		const contextId = runtimeContext?.contextId || "default";
+		const taskId = runtimeContext?.metadata?.taskId || "unknown";
+		const streamRequestId = runtimeContext?.metadata?.streamRequestId;
+		const sessionId = streamRequestId || "fallback-session";
+		this.streamRequestId = streamRequestId;
+		this.streamHelper = streamRequestId ? getStreamHelper(streamRequestId) : void 0;
+		if (streamRequestId && this.artifactComponents.length > 0) agentSessionManager.updateArtifactComponents(streamRequestId, this.artifactComponents);
+		const conversationId = runtimeContext?.metadata?.conversationId;
+		if (conversationId) this.setConversationId(conversationId);
+		return {
+			contextId,
+			taskId,
+			streamRequestId,
+			sessionId
+		};
+	}
+	/**
+	* 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: {
+			"subAgent.name": this.config.name,
+			"session.id": sessionId || "none"
+		} }, async (childSpan) => {
+			try {
+				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)
+				]);
+				childSpan.setStatus({ code: SpanStatusCode.OK });
+				return result;
+			} catch (err) {
+				setSpanWithError$1(childSpan, err instanceof Error ? err : new Error(String(err)));
+				throw err;
+			} finally {
+				childSpan.end();
+			}
+		});
+		const systemPrompt = systemPromptResult.prompt;
+		const thinkingSystemPrompt = thinkingSystemPromptResult.prompt;
+		const contextBreakdown = systemPromptResult.breakdown;
+		const allTools = {
+			...mcpTools,
+			...functionTools,
+			...relationTools,
+			...defaultTools
+		};
+		return {
+			systemPrompt,
+			thinkingSystemPrompt,
+			sanitizedTools: this.sanitizeToolsForAISDK(allTools),
+			contextBreakdown
+		};
+	}
+	/**
+	* Build conversation history based on configuration mode and filters
+	*/
+	async buildConversationHistory(contextId, taskId, userMessage, streamRequestId, initialContextBreakdown) {
+		let conversationHistory = "";
+		const historyConfig = this.config.conversationHistoryConfig ?? createDefaultConversationHistoryConfig();
+		if (historyConfig && historyConfig.mode !== "none") {
+			if (historyConfig.mode === "full") {
+				const filters = {
+					delegationId: this.delegationId,
+					isDelegated: this.isDelegatedAgent
+				};
+				conversationHistory = await getConversationHistoryWithCompression({
+					tenantId: this.config.tenantId,
+					projectId: this.config.projectId,
+					conversationId: contextId,
+					currentMessage: userMessage,
+					options: historyConfig,
+					filters,
+					summarizerModel: this.getSummarizerModel(),
+					streamRequestId,
+					fullContextSize: initialContextBreakdown.total
+				});
+			} else if (historyConfig.mode === "scoped") conversationHistory = await getConversationHistoryWithCompression({
+				tenantId: this.config.tenantId,
+				projectId: this.config.projectId,
+				conversationId: contextId,
+				currentMessage: userMessage,
+				options: historyConfig,
+				filters: {
+					subAgentId: this.config.id,
+					taskId,
+					delegationId: this.delegationId,
+					isDelegated: this.isDelegatedAgent
+				},
+				summarizerModel: this.getSummarizerModel(),
+				streamRequestId,
+				fullContextSize: initialContextBreakdown.total
+			});
+		}
+		const conversationHistoryTokens = estimateTokens(conversationHistory);
+		const updatedContextBreakdown = {
+			...initialContextBreakdown,
+			conversationHistory: conversationHistoryTokens
+		};
+		calculateBreakdownTotal(updatedContextBreakdown);
+		return {
+			conversationHistory,
+			contextBreakdown: updatedContextBreakdown
+		};
+	}
+	/**
+	* 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 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,
+			appliedTimeout: timeoutMs,
+			maxAllowed: LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS
+		}, "Requested timeout exceeded maximum allowed, capping to 10 minutes");
+		return {
+			primaryModelSettings,
+			modelSettings: {
+				...modelSettings,
+				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;
+		const messages = [];
+		messages.push({
+			role: "system",
+			content: phase1SystemPrompt
+		});
+		if (conversationHistory.trim() !== "") messages.push({
+			role: "user",
+			content: conversationHistory
+		});
+		messages.push({
+			role: "user",
+			content: userMessage
+		});
+		return messages;
+	}
+	/**
+	* Setup compression for the current generation
+	*/
+	setupCompression(messages, sessionId, contextId, primaryModelSettings) {
+		const originalMessageCount = messages.length;
+		const compressionConfigResult = getCompressionConfigForModel(primaryModelSettings);
+		const compressionConfig = {
+			hardLimit: compressionConfigResult.hardLimit,
+			safetyBuffer: compressionConfigResult.safetyBuffer,
+			enabled: compressionConfigResult.enabled
+		};
+		const compressor = compressionConfig.enabled ? new MidGenerationCompressor(sessionId, contextId, this.config.tenantId, this.config.projectId, compressionConfig, this.getSummarizerModel(), primaryModelSettings) : null;
+		this.currentCompressor = compressor;
+		return {
+			originalMessageCount,
+			compressor
+		};
+	}
+	/**
+	* Prepare step function for streaming with compression logic
+	*/
+	async handlePrepareStepCompression(stepMessages, compressor, originalMessageCount, fullContextSize) {
+		if (!compressor) return {};
+		if (compressor.isCompressionNeeded(stepMessages)) {
+			logger.info({ compressorState: compressor.getState() }, "Triggering layered mid-generation compression");
+			const originalMessages = stepMessages.slice(0, originalMessageCount);
+			const generatedMessages = stepMessages.slice(originalMessageCount);
+			if (generatedMessages.length > 0) {
+				const compressionResult = await compressor.safeCompress(generatedMessages, fullContextSize);
+				if (Array.isArray(compressionResult.summary)) {
+					const compressedMessages = compressionResult.summary;
+					logger.info({
+						originalTotal: stepMessages.length,
+						compressed: originalMessages.length + compressedMessages.length,
+						originalKept: originalMessages.length,
+						generatedCompressed: compressedMessages.length
+					}, "Simple compression fallback applied");
+					return { messages: [...originalMessages, ...compressedMessages] };
+				}
+				const finalMessages = [...originalMessages];
+				if (compressionResult.summary.text_messages && compressionResult.summary.text_messages.length > 0) finalMessages.push(...compressionResult.summary.text_messages);
+				const summaryData = {
+					high_level: compressionResult.summary?.high_level,
+					user_intent: compressionResult.summary?.user_intent,
+					decisions: compressionResult.summary?.decisions,
+					open_questions: compressionResult.summary?.open_questions,
+					next_steps: compressionResult.summary?.next_steps,
+					related_artifacts: compressionResult.summary?.related_artifacts
+				};
+				if (summaryData.related_artifacts && summaryData.related_artifacts.length > 0) summaryData.related_artifacts = summaryData.related_artifacts.map((artifact) => ({
+					...artifact,
+					artifact_reference: `<artifact:ref id="${artifact.id}" tool="${artifact.tool_call_id}" />`
+				}));
+				const summaryMessage = JSON.stringify(summaryData);
+				finalMessages.push({
+					role: "user",
+					content: `Based on your research, here's what you've discovered: ${summaryMessage}
+
+**IMPORTANT**: If you have enough information from this compressed research to answer my original question, please provide your answer now. Only continue with additional tool calls if you need critical missing information that wasn't captured in the research above. When referencing any artifacts from the compressed research, you MUST use <artifact:ref id="artifact_id" tool="tool_call_id" /> tags with the exact IDs from the related_artifacts above.`
+				});
+				logger.info({
+					originalTotal: stepMessages.length,
+					compressed: finalMessages.length,
+					originalKept: originalMessages.length,
+					generatedCompressed: generatedMessages.length
+				}, "AI compression completed successfully");
+				return { messages: finalMessages };
+			}
+			return {};
+		}
+		return {};
+	}
+	async handleStopWhenConditions(steps, includeThinkingComplete = false) {
+		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) {
+			logger.debug({ error }, "Failed to track agent reasoning");
+		}
+		if (!includeThinkingComplete && last && last["content"] && last["content"].length > 0) {
+			const lastContent = last["content"][last["content"].length - 1];
+			if (lastContent["type"] === "tool-error") {
+				const error = lastContent["error"];
+				if (error && typeof error === "object" && "name" in error && error.name === "connection_refused") return true;
+			}
+		}
+		if (steps.length >= 2) {
+			const previousStep = steps[steps.length - 2];
+			if (previousStep && "toolCalls" in previousStep && previousStep.toolCalls) {
+				const stopToolNames = includeThinkingComplete ? ["transfer_to_", "thinking_complete"] : ["transfer_to_"];
+				if (previousStep.toolCalls.some((tc) => stopToolNames.some((toolName) => toolName.endsWith("_") ? tc.toolName.startsWith(toolName) : tc.toolName === toolName)) && "toolResults" in previousStep && previousStep.toolResults) return true;
+			}
+		}
+		return steps.length >= this.getMaxGenerationSteps();
+	}
+	setupStreamParser(sessionId, contextId) {
+		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
+		};
+		return new IncrementalStreamParser(streamHelper, this.config.tenantId, contextId, artifactParserOptions);
+	}
+	buildTelemetryConfig(phase) {
+		return {
+			isEnabled: true,
+			functionId: this.config.id,
+			recordInputs: true,
+			recordOutputs: true,
+			metadata: {
+				...phase && { phase },
+				subAgentId: this.config.id,
+				subAgentName: this.config.name
+			}
+		};
+	}
+	buildBaseGenerationConfig(modelSettings, messages, sanitizedTools, compressor, originalMessageCount, timeoutMs, toolChoice = "auto", phase, includeThinkingComplete = false, fullContextSize) {
+		return {
+			...modelSettings,
+			toolChoice,
+			messages,
+			tools: sanitizedTools,
+			prepareStep: async ({ messages: stepMessages }) => {
+				return await this.handlePrepareStepCompression(stepMessages, compressor, originalMessageCount, fullContextSize);
+			},
+			stopWhen: async ({ steps }) => {
+				return await this.handleStopWhenConditions(steps, includeThinkingComplete);
+			},
+			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):**
@@ -1742,8 +1737,8 @@ ${hints.commonFields?.map((field) => `  • ${field}`).join("\n") || "  None det
 
 **Forbidden Syntax:** ${hints.forbiddenSyntax || "Use these paths for artifact base selectors."}
 `;
-								}
-								const formattedResult = `## Tool: ${call.toolName}
+					}
+					const formattedResult = `## Tool: ${call.toolName}
 
 ### 🔧 TOOL_CALL_ID: ${result.toolCallId}
 
@@ -1752,185 +1747,179 @@ ${input}
 
 ### Output
 ${output}${structureHintsFormatted}`;
-								reasoningFlow.push({
-									role: "assistant",
-									content: formattedResult
-								});
-							}
-						});
+					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(z.object({
-							id: z.string(),
-							name: 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 = z.union(componentSchemas);
-					const structuredModelSettings = ModelFactory.prepareGenerationConfig(this.getStructuredOutputModel());
-					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");
-					if (this.getStreamingHelper()) {
-						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."
-						});
-						const streamResult = streamObject({
-							...structuredModelSettings,
-							messages: phase2Messages,
-							schema: z.object({ dataComponents: z.array(dataComponentsSchema) }),
-							experimental_telemetry: {
-								isEnabled: true,
-								functionId: this.config.id,
-								recordInputs: true,
-								recordOutputs: true,
-								metadata: {
-									phase: "structured_generation",
-									subAgentId: this.config.id,
-									subAgentName: this.config.name
-								}
-							},
-							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);
-						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 } = await import("../utils/json-postprocessor.js");
-						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."
-						});
-						const structuredResponse = await generateObject(withJsonPostProcessing({
-							...structuredModelSettings,
-							messages: phase2Messages,
-							schema: z.object({ dataComponents: z.array(dataComponentsSchema) }),
-							experimental_telemetry: {
-								isEnabled: true,
-								functionId: this.config.id,
-								recordInputs: true,
-								recordOutputs: true,
-								metadata: {
-									phase: "structured_generation",
-									subAgentId: this.config.id,
-									subAgentName: this.config.name
-								}
-							},
-							abortSignal: AbortSignal.timeout(phase2TimeoutMs)
-						}));
-						response = {
-							...response,
-							object: structuredResponse.object
-						};
-						textResponse = JSON.stringify(structuredResponse.object, null, 2);
-					}
-				} else textResponse = response.text || "";
-				else textResponse = response.steps[response.steps.length - 1].text || "";
-				span.setStatus({ code: 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
-					});
-				}
-				this.currentCompressor = null;
-				return formattedResponse;
-			} catch (error) {
-				this.currentCompressor = null;
-				const errorToThrow = error instanceof Error ? error : new Error(String(error));
-				setSpanWithError$1(span, errorToThrow);
-				span.end();
-				throw errorToThrow;
-			}
+			});
+		});
+		return reasoningFlow;
+	}
+	buildDataComponentsSchema() {
+		const componentSchemas = [];
+		if (this.config.dataComponents && this.config.dataComponents.length > 0) this.config.dataComponents.forEach((dc) => {
+			const propsSchema = jsonSchemaToZod(dc.props);
+			componentSchemas.push(z.object({
+				id: z.string(),
+				name: 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 = z.union(componentSchemas);
+		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 = streamObject({
+			...structuredModelSettings,
+			messages: phase2Messages,
+			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.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 }
+		})) };
+		return {
+			...response,
+			object: structuredResponse.object,
+			textResponse: JSON.stringify(structuredResponse.object, null, 2)
+		};
+	}
+	async executeNonStreamingPhase2(structuredModelSettings, phase2Messages, dataComponentsSchema, phase2TimeoutMs, response) {
+		const structuredResponse = await generateObject(withJsonPostProcessing({
+			...structuredModelSettings,
+			messages: phase2Messages,
+			schema: z.object({ dataComponents: z.array(dataComponentsSchema) }),
+			experimental_telemetry: this.buildTelemetryConfig("structured_generation"),
+			abortSignal: AbortSignal.timeout(phase2TimeoutMs)
+		}));
+		return {
+			...response,
+			object: structuredResponse.object,
+			textResponse: JSON.stringify(structuredResponse.object, null, 2)
+		};
+	}
+	async formatFinalResponse(response, textResponse, sessionId, contextId) {
+		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);
+		}
+		return {
+			...response,
+			formattedContent
+		};
+	}
+	handleGenerationError(error, span) {
+		if (this.currentCompressor) this.currentCompressor.fullCleanup();
+		this.currentCompressor = null;
+		const errorToThrow = error instanceof Error ? error : new Error(String(error));
+		setSpanWithError$1(span, errorToThrow);
+		span.end();
+		throw errorToThrow;
+	}
+	/**
+	* Public cleanup method for external lifecycle management (e.g., session cleanup)
+	* Performs full cleanup of compression state when agent/session is ending
+	*/
+	cleanupCompression() {
+		if (this.currentCompressor) {
+			this.currentCompressor.fullCleanup();
+			this.currentCompressor = null;
+		}
+	}
+	async processStreamEvents(streamResult, parser) {
+		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;
+				const errorMessage = event.error?.error?.message;
+				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;
 	}
 };