@gracker/smartperfetto 1.0.15 → 1.0.17

package/dist/agentOpenAI/openAiRuntime.js

@@ -18,6 +18,7 @@ const architectureDetector_1 = require("../agent/detectors/architectureDetector"
 const enhancedSessionContext_1 = require("../agent/context/enhancedSessionContext");
 const claudeMcpServer_1 = require("../agentv3/claudeMcpServer");
 const claudeSystemPrompt_1 = require("../agentv3/claudeSystemPrompt");
+const strategyLoader_1 = require("../agentv3/strategyLoader");
 const claudeFindingExtractor_1 = require("../agentv3/claudeFindingExtractor");
 const focusAppDetector_1 = require("../agentv3/focusAppDetector");
 const sceneClassifier_1 = require("../agentv3/sceneClassifier");
@@ -35,8 +36,10 @@ const toolNarration_1 = require("../agentv3/toolNarration");
 const openAiConfig_1 = require("./openAiConfig");
 const mimoReasoningCompat_1 = require("./mimoReasoningCompat");
 const openAiToolAdapter_1 = require("./openAiToolAdapter");
+const finalResultQualityGate_1 = require("../services/finalResultQualityGate");
 const OPENAI_SESSION_FRESHNESS_MS = 4 * 60 * 60 * 1000;
 const OPENAI_MAX_PLAN_CONTINUATIONS = 3;
+const OPENAI_MAX_FINAL_REPORT_CONTINUATIONS = 1;
 const OPENAI_PLAN_COMPLETE_IDLE_ABORT_MS = 8000;
 function hasAdequateClosedPhaseSummary(phase) {
     if (phase.status !== 'completed' && phase.status !== 'skipped')
@@ -173,13 +176,49 @@ function looksLikeProcessNarrationParagraph(paragraph) {
     if (!compact)
         return false;
     return /^(?:我来|我需要|我将|我会|现在|接下来|下一步|首先[，,]?.*提交|调用\s*`?[\w-]+`?|记录关键发现|数据量充足|非常丰富的数据|让我|为了完成|I need\b|I will\b|Now I\b|Next\b|Let me\b)/i.test(compact)
-        || /阶段状态更新|执行剩余阶段|继续执行剩余阶段|update_plan_phase|submit_plan|resolve_hypothesis|provider 未主动结束 stream|plan 未完成|plan 已完成/i.test(compact);
+        || /现在进入\s*Phase|Phase\s*\d+(?:\.\d+)?.*返回|关键概览|阶段状态更新|执行剩余阶段|继续执行剩余阶段|update_plan_phase|submit_plan|resolve_hypothesis|provider 未主动结束 stream|plan 未完成|plan 已完成/i.test(compact);
 }
 function hasReportMarkers(text) {
     return /(^|\n)\s{0,3}#{1,3}\s+\S/.test(text)
         || /(^|\n)\s{0,3}\*\*[^*\n]{2,80}\*\*/.test(text)
         || /(^|\n)\s{0,3}\|/.test(text);
 }
+function normalizeConclusionForComparison(text) {
+    return text.trim().replace(/\s+/g, ' ');
+}
+function isSameConclusionText(a, b) {
+    const normalizedA = normalizeConclusionForComparison(a || '');
+    const normalizedB = normalizeConclusionForComparison(b || '');
+    return normalizedA.length > 0 && normalizedA === normalizedB;
+}
+function cleanPlanSummaryForFinalReport(summary) {
+    return summary
+        .trim()
+        .replace(/^(?:完成综合结论输出|完整结构化报告已(?:输出|生成))[。:：\s]*/i, '')
+        .replace(/^核心发现[：:\s]*/i, '')
+        .replace(/^所有关键artifact已在Phase\s*\d+(?:\.\d+)?中获取完毕[：:。\s]*/i, '')
+        .trim();
+}
+function isSubstantialReportText(text) {
+    const trimmed = text.trim();
+    if (trimmed.length < 200 || !(0, finalResultQualityGate_1.hasDeliverableFinalReportHeading)(trimmed))
+        return false;
+    if (looksLikeProcessNarrationParagraph(trimmed))
+        return false;
+    return !looksLikeProcessNarrationParagraph(trimmed.split(/\n{2,}/)[0] || '');
+}
+function isRicherReportCandidate(candidate, baseline) {
+    const candidateTrimmed = candidate.trim();
+    const baselineTrimmed = baseline.trim();
+    if (!isSubstantialReportText(candidateTrimmed))
+        return false;
+    if (!baselineTrimmed || !isSubstantialReportText(baselineTrimmed))
+        return true;
+    return candidateTrimmed.length > Math.max(200, baselineTrimmed.length * 1.25);
+}
+function selectOpenAiRecoveryAnswer(input) {
+    return input.runAnswer.trim() ? input.runAnswer : input.accumulatedAnswer;
+}
 function findEmbeddedFinalReportStart(text) {
     const match = /#{1,3}\s*(?:[\w\u4e00-\u9fff` .:：_-]{0,40})?(?:分析报告|综合结论|最终结论|最终报告|Final Report|Analysis Report)(?=\s|$|[：:。.!！?\n])/i.exec(text);
     return match?.index ?? -1;
@@ -216,12 +255,13 @@ function sanitizeOpenAiConclusionText(conclusion, options = {}) {
         ? paragraphs.slice(firstReportParagraph).join('\n\n').trim()
         : trimmed;
     const strippedStillProcess = looksLikeProcessNarrationParagraph(stripped.split(/\n{2,}/)[0] || '');
-    if (firstReportParagraph > 0 && stripped.length >= 80 && !strippedStillProcess) {
+    const strippedHasProcessNarration = looksLikeProcessNarrationParagraph(stripped);
+    if (firstReportParagraph > 0 && stripped.length >= 80 && !strippedStillProcess && !strippedHasProcessNarration) {
         return stripped;
     }
     if (fallback &&
         (options.completedByPlanIdle || options.planComplete) &&
-        (firstReportParagraph > 0 || strippedStillProcess || !hasReportMarkers(trimmed))) {
+        (firstReportParagraph > 0 || strippedStillProcess || strippedHasProcessNarration || !hasReportMarkers(trimmed))) {
         return fallback;
     }
     return trimmed;
@@ -234,14 +274,28 @@ function chooseOpenAiConclusionText(input) {
     });
     const fallback = input.fallbackConclusion?.trim();
     const accumulated = input.accumulatedAnswer.trim();
-    if (!input.completedByPlanIdle || !accumulated || accumulated === input.candidate.trim()) {
+    const selectedIsFallback = fallback ? isSameConclusionText(selected, fallback) : false;
+    const selectedNeedsRecovery = selectedIsFallback ||
+        (0, finalResultQualityGate_1.looksLikePhaseSummaryFallback)(selected) ||
+        !isSubstantialReportText(selected) ||
+        looksLikeProcessNarrationParagraph(selected.split(/\n{2,}/)[0] || '');
+    const mayRecoverAccumulated = accumulated.length > 0 &&
+        !isSameConclusionText(accumulated, input.candidate) &&
+        (input.completedByPlanIdle || (input.planComplete && selectedNeedsRecovery));
+    if (!mayRecoverAccumulated)
         return selected;
+    const recovered = sanitizeOpenAiConclusionText(accumulated, {
+        completedByPlanIdle: input.completedByPlanIdle,
+        planComplete: input.planComplete,
+        fallbackConclusion: input.fallbackConclusion,
+    });
+    if (isRicherReportCandidate(recovered, selected)) {
+        return recovered;
     }
-    const recovered = sanitizeOpenAiConclusionText(accumulated);
-    if (hasReportMarkers(recovered) && recovered.length > Math.max(200, selected.length * 1.25)) {
+    if ((0, finalResultQualityGate_1.hasDeliverableFinalReportHeading)(recovered) && recovered.length > Math.max(200, selected.length * 1.25)) {
         return recovered;
     }
-    if (fallback && selected === fallback && hasReportMarkers(recovered) && recovered.length > selected.length) {
+    if (fallback && selectedIsFallback && (0, finalResultQualityGate_1.hasDeliverableFinalReportHeading)(recovered) && recovered.length > selected.length) {
         return recovered;
     }
     return selected;
@@ -251,6 +305,7 @@ exports.__testing = {
     readCompletedStreamFinalOutput,
     sanitizeOpenAiConclusionText,
     chooseOpenAiConclusionText,
+    selectOpenAiRecoveryAnswer,
     isRecoverableOpenAIStreamTermination,
     compactProviderErrorMessage,
 };
@@ -392,16 +447,18 @@ class OpenAIRuntime extends events_1.EventEmitter {
                 tools: context.tools,
                 toolUseBehavior: 'run_llm_again',
                 modelSettings: {
+                    maxTokens: config.maxOutputTokens,
                     parallelToolCalls: false,
                 },
             });
-            const controller = new AbortController();
+            let activeController;
             const timeoutMs = (quickMode ? config.quickPathPerTurnMs : config.fullPathPerTurnMs)
                 * (quickMode ? config.quickMaxTurns : config.maxTurns);
+            const deadlineAt = Date.now() + timeoutMs;
             let timedOut = false;
             const timeout = setTimeout(() => {
                 timedOut = true;
-                controller.abort();
+                activeController?.abort();
             }, timeoutMs);
             this.emitUpdate({
                 type: 'progress',
@@ -423,7 +480,32 @@ class OpenAIRuntime extends events_1.EventEmitter {
                 let partial = false;
                 let terminationReason;
                 let terminationMessage;
+                let finalReportContinuations = 0;
+                const markTimeoutPartial = (planStatus) => {
+                    partial = true;
+                    terminationReason = 'timeout';
+                    terminationMessage = (0, outputLanguage_1.localize)(config.outputLanguage, `OpenAI 分析超过 ${Math.round(timeoutMs / 1000)} 秒超时，结果可能不完整。`, `OpenAI analysis timed out after ${Math.round(timeoutMs / 1000)} seconds; the result may be incomplete.`);
+                    conclusion = this.withIncompletePlanWarning(conclusion, planStatus, config.outputLanguage);
+                    this.emitUpdate({
+                        type: 'degraded',
+                        content: {
+                            module: 'openAiRuntime',
+                            fallback: 'partial_result_after_timeout',
+                            partial: true,
+                            terminationReason,
+                            message: terminationMessage,
+                        },
+                        timestamp: Date.now(),
+                    });
+                };
                 for (let continuation = 0;; continuation++) {
+                    if (timedOut || Date.now() >= deadlineAt) {
+                        timedOut = true;
+                        markTimeoutPartial(this.getPlanCompletionStatus(sessionId, quickMode));
+                        break;
+                    }
+                    const controller = new AbortController();
+                    activeController = controller;
                     let runAnswer = '';
                     let runTurns = 0;
                     let completedByPlanIdle = false;
@@ -485,6 +567,9 @@ class OpenAIRuntime extends events_1.EventEmitter {
                     }
                     finally {
                         clearPlanCompleteIdleTimer();
+                        if (activeController === controller) {
+                            activeController = undefined;
+                        }
                     }
                     rounds += runTurns || stream.currentTurn || 0;
                     const streamFinalOutput = readCompletedStreamFinalOutput(stream, {
@@ -497,13 +582,14 @@ class OpenAIRuntime extends events_1.EventEmitter {
                         : (streamFinalOutput ? JSON.stringify(streamFinalOutput) : runAnswer);
                     const planStatus = this.getPlanCompletionStatus(sessionId, quickMode);
                     const fallbackConclusion = this.buildCompletedPlanFallbackConclusion(sessionId, quickMode, config.outputLanguage);
+                    const recoveryAnswer = selectOpenAiRecoveryAnswer({ runAnswer, accumulatedAnswer });
                     conclusion = chooseOpenAiConclusionText({
                         candidate: finalOutput ||
                             runAnswer ||
                             accumulatedAnswer ||
                             fallbackConclusion ||
                             '',
-                        accumulatedAnswer,
+                        accumulatedAnswer: recoveryAnswer,
                         completedByPlanIdle,
                         planComplete: planStatus.complete,
                         fallbackConclusion,
@@ -514,25 +600,43 @@ class OpenAIRuntime extends events_1.EventEmitter {
                         finalRunState = this.safeSerializeRunState(stream.state);
                     }
                     if (timedOut && !completedByPlanIdle) {
-                        partial = true;
-                        terminationReason = 'timeout';
-                        terminationMessage = (0, outputLanguage_1.localize)(config.outputLanguage, `OpenAI 分析超过 ${Math.round(timeoutMs / 1000)} 秒超时，结果可能不完整。`, `OpenAI analysis timed out after ${Math.round(timeoutMs / 1000)} seconds; the result may be incomplete.`);
-                        conclusion = this.withIncompletePlanWarning(conclusion, planStatus, config.outputLanguage);
-                        this.emitUpdate({
-                            type: 'degraded',
-                            content: {
-                                module: 'openAiRuntime',
-                                fallback: 'partial_result_after_timeout',
-                                partial: true,
-                                terminationReason,
-                                message: terminationMessage,
-                            },
-                            timestamp: Date.now(),
-                        });
+                        markTimeoutPartial(planStatus);
                         break;
                     }
-                    if (planStatus.complete)
+                    if (planStatus.complete) {
+                        const streamHistory = Array.isArray(stream.history)
+                            ? stream.history
+                            : [];
+                        if (this.shouldRequestFinalReportAfterPlanComplete({
+                            quickMode,
+                            planStatus,
+                            conclusion,
+                            fallbackConclusion,
+                            completedByPlanIdle,
+                            timedOut,
+                            finalReportContinuations,
+                        }) && streamHistory.length > 0) {
+                            finalReportContinuations++;
+                            this.emitUpdate({
+                                type: 'progress',
+                                content: {
+                                    phase: 'concluding',
+                                    message: this.formatPlanCompleteReportContinuationMessage(config.outputLanguage),
+                                },
+                                timestamp: Date.now(),
+                            });
+                            currentInput = [
+                                ...streamHistory,
+                                {
+                                    role: 'user',
+                                    content: this.buildFinalReportAfterPlanCompletePrompt(config.outputLanguage),
+                                },
+                            ];
+                            currentPreviousResponseId = undefined;
+                            continue;
+                        }
                         break;
+                    }
                     if (continuation >= OPENAI_MAX_PLAN_CONTINUATIONS) {
                         partial = true;
                         terminationReason = 'plan_incomplete';
@@ -572,10 +676,54 @@ class OpenAIRuntime extends events_1.EventEmitter {
                 if (options.codeAwareMode && options.codeAwareMode !== 'off') {
                     conclusion = (0, codeAwareOutputRegistry_1.sanitizeCodeAwareText)(sessionId, conclusion);
                 }
+                const finalFallbackConclusion = this.buildCompletedPlanFallbackConclusion(sessionId, quickMode, config.outputLanguage);
+                if (finalFallbackConclusion &&
+                    (isSameConclusionText(conclusion, finalFallbackConclusion) ||
+                        (0, finalResultQualityGate_1.looksLikePhaseSummaryFallback)(conclusion)) &&
+                    !partial) {
+                    partial = true;
+                    terminationMessage = (0, outputLanguage_1.localize)(config.outputLanguage, 'OpenAI plan 已完成，但 provider 没有输出独立最终报告；已退回到阶段摘要，结果信息密度可能不足。', 'The OpenAI plan completed, but the provider did not produce an independent final report; falling back to phase summaries, which may be less informative.');
+                    this.emitUpdate({
+                        type: 'degraded',
+                        content: {
+                            module: 'openAiRuntime',
+                            fallback: 'completed_plan_summary_fallback',
+                            partial: true,
+                            message: terminationMessage,
+                        },
+                        timestamp: Date.now(),
+                    });
+                }
                 const findings = (0, claudeFindingExtractor_1.extractFindingsFromText)(conclusion);
                 const confidence = partial
                     ? Math.min(0.55, this.estimateConfidence(findings, conclusion))
                     : this.estimateConfidence(findings, conclusion);
+                const result = {
+                    sessionId,
+                    success: true,
+                    findings,
+                    hypotheses: context.hypotheses.map(h => this.toProtocolHypothesis(h)),
+                    conclusion,
+                    confidence,
+                    rounds,
+                    totalDurationMs: Date.now() - startTime,
+                    partial: partial || undefined,
+                    terminationReason,
+                    terminationMessage,
+                };
+                const gateIssue = (0, finalResultQualityGate_1.applyFinalResultQualityGate)({ result, query });
+                if (gateIssue) {
+                    this.emitUpdate({
+                        type: 'degraded',
+                        content: {
+                            module: 'openAiRuntime',
+                            fallback: gateIssue.code,
+                            partial: true,
+                            message: gateIssue.message,
+                        },
+                        timestamp: Date.now(),
+                    });
+                }
                 this.sessionMap.set(context.sessionMapKey, {
                     history: finalHistory,
                     lastResponseId: finalLastResponseId,
@@ -585,37 +733,23 @@ class OpenAIRuntime extends events_1.EventEmitter {
                 this.recordTurn({
                     query,
                     sessionId,
-                    conclusion,
-                    findings,
-                    confidence,
+                    result,
                     sessionContext: context.sessionContext,
                     previousTurnCount: context.previousTurns.length,
                     quickMode,
                 });
                 this.emitUpdate({
                     type: 'conclusion',
-                    content: { conclusion, durationMs: Date.now() - startTime, turns: rounds },
+                    content: { conclusion: result.conclusion, durationMs: Date.now() - startTime, turns: rounds },
                     timestamp: Date.now(),
                 });
                 this.emitUpdate({
                     type: 'answer_token',
-                    content: { done: true, totalChars: conclusion.length },
+                    content: { done: true, totalChars: result.conclusion.length },
                     timestamp: Date.now(),
                 });
                 await provider.close().catch(() => undefined);
-                return {
-                    sessionId,
-                    success: true,
-                    findings,
-                    hypotheses: context.hypotheses.map(h => this.toProtocolHypothesis(h)),
-                    conclusion,
-                    confidence,
-                    rounds,
-                    totalDurationMs: Date.now() - startTime,
-                    partial: partial || undefined,
-                    terminationReason,
-                    terminationMessage,
-                };
+                return result;
             }
             catch (error) {
                 clearTimeout(timeout);
@@ -1113,6 +1247,42 @@ class OpenAIRuntime extends events_1.EventEmitter {
             fallbackAnswer.trim().length > 0 ||
             this.buildCompletedPlanFallbackConclusion(sessionId, quickMode, outputLanguage_1.DEFAULT_OUTPUT_LANGUAGE) !== undefined;
     }
+    shouldRequestFinalReportAfterPlanComplete(input) {
+        if (input.quickMode ||
+            !input.planStatus.complete ||
+            input.timedOut ||
+            input.finalReportContinuations >= OPENAI_MAX_FINAL_REPORT_CONTINUATIONS) {
+            return false;
+        }
+        const conclusion = input.conclusion.trim();
+        const fallback = input.fallbackConclusion?.trim();
+        if (!fallback)
+            return false;
+        if (!conclusion)
+            return true;
+        if (isSameConclusionText(conclusion, fallback))
+            return true;
+        if ((0, finalResultQualityGate_1.looksLikePhaseSummaryFallback)(conclusion))
+            return true;
+        if (!(0, finalResultQualityGate_1.hasDeliverableFinalReportHeading)(conclusion))
+            return true;
+        if (looksLikeProcessNarrationParagraph(conclusion))
+            return true;
+        return looksLikeProcessNarrationParagraph(conclusion.split(/\n{2,}/)[0] || '');
+    }
+    buildFinalReportAfterPlanCompletePrompt(outputLanguage) {
+        const templateName = outputLanguage === 'en'
+            ? 'prompt-openai-final-report-continuation-en'
+            : 'prompt-openai-final-report-continuation-zh';
+        const template = (0, strategyLoader_1.loadPromptTemplate)(templateName);
+        if (!template) {
+            throw new Error(`Missing OpenAI final-report continuation prompt template: ${templateName}`);
+        }
+        return template;
+    }
+    formatPlanCompleteReportContinuationMessage(outputLanguage) {
+        return (0, outputLanguage_1.localize)(outputLanguage, 'OpenAI plan 已完成，但最终正文仍是阶段摘要，继续请求完整最终报告。', 'The OpenAI plan is complete, but the final body is still a phase summary; requesting the complete final report.');
+    }
     buildCompletedPlanFallbackConclusion(sessionId, quickMode, outputLanguage) {
         if (quickMode)
             return undefined;
@@ -1121,20 +1291,70 @@ class OpenAIRuntime extends events_1.EventEmitter {
             return undefined;
         if (!this.getPlanCompletionStatus(sessionId, quickMode).complete)
             return undefined;
+        const isFinalReportPhase = (phase) => /(综合结论|最终结论|结论|报告|conclusion|final report)/i.test(`${phase.name} ${phase.goal}`);
         const summaries = plan.phases
             .filter(hasAdequateClosedPhaseSummary)
             .map(phase => {
             const name = phase.name || phase.id;
-            return `- ${name}: ${phase.summary?.trim()}`;
+            return `- ${name}: ${cleanPlanSummaryForFinalReport(phase.summary || '')}`;
         });
         if (summaries.length === 0)
             return undefined;
         const finalPhase = [...plan.phases]
             .reverse()
             .find(phase => hasAdequateClosedPhaseSummary(phase) &&
-            /(综合结论|最终结论|结论|报告|conclusion|final report)/i.test(`${phase.name} ${phase.goal}`));
-        const finalSummary = finalPhase?.summary?.trim() || summaries[summaries.length - 1]?.replace(/^-\s*[^:]+:\s*/, '') || '';
-        return (0, outputLanguage_1.localize)(outputLanguage, `## 综合结论\n\n${finalSummary}\n\n## 分阶段证据摘要\n\n${summaries.join('\n')}`, `## Final Conclusion\n\n${finalSummary}\n\n## Evidence Summary By Phase\n\n${summaries.join('\n')}`);
+            isFinalReportPhase(phase));
+        const finalSummary = cleanPlanSummaryForFinalReport(finalPhase?.summary?.trim() || summaries[summaries.length - 1]?.replace(/^-\s*[^:]+:\s*/, '') || '');
+        const evidenceBullets = plan.phases
+            .filter(phase => hasAdequateClosedPhaseSummary(phase) && !isFinalReportPhase(phase))
+            .map(phase => {
+            const name = phase.name || phase.id;
+            return `- ${name}: ${cleanPlanSummaryForFinalReport(phase.summary || '')}`;
+        })
+            .filter(line => line.trim().length > 4)
+            .slice(0, 8)
+            .join('\n');
+        return (0, outputLanguage_1.localize)(outputLanguage, [
+            '## 综合结论',
+            '',
+            finalSummary || '分析计划已完成，以下结论基于已采集的结构化证据收敛。',
+            '',
+            '## 关键证据链',
+            '',
+            evidenceBullets || '- 已完成的计划阶段均有结构化证据支撑。',
+            '',
+            '## 根因拆解',
+            '',
+            '- 以上证据按阶段产出、关键指标、已确认假设和已排除因素归并；优化优先级以已验证且可执行的瓶颈为准。',
+            '',
+            '## 优化建议',
+            '',
+            '- 优先处理证据支持的可操作瓶颈；对已排除但风险较高的因素保留必要监控。',
+            '',
+            '## 置信度/限制',
+            '',
+            '- 结论基于已完成计划阶段的结构化证据收敛；若需要代码级 owner 定位，应结合源码符号继续分析。',
+        ].join('\n'), [
+            '## Final Conclusion',
+            '',
+            finalSummary || 'The analysis plan completed; this conclusion is synthesized from the collected structured evidence.',
+            '',
+            '## Key Evidence',
+            '',
+            evidenceBullets || '- Completed plan phases contain structured evidence.',
+            '',
+            '## Root Cause Breakdown',
+            '',
+            '- The evidence is grouped by phase outputs, key metrics, confirmed hypotheses, and excluded factors; optimization priority should follow verified and actionable bottlenecks.',
+            '',
+            '## Recommendations',
+            '',
+            '- Prioritize actionable bottlenecks supported by evidence; keep monitoring excluded factors that still carry residual risk.',
+            '',
+            '## Confidence / Limits',
+            '',
+            '- This conclusion is synthesized from structured evidence collected by the completed plan phases. Use source-code symbol lookup for owner-level fixes.',
+        ].join('\n'));
     }
     buildPlanPhaseSummaryFallbackConclusion(sessionId, quickMode, outputLanguage) {
         if (quickMode)
@@ -1195,9 +1415,19 @@ class OpenAIRuntime extends events_1.EventEmitter {
         this.recordTurn({
             query: params.query,
             sessionId: params.sessionId,
-            conclusion,
-            findings,
-            confidence,
+            result: {
+                sessionId: params.sessionId,
+                success: true,
+                findings,
+                hypotheses: params.context.hypotheses.map(h => this.toProtocolHypothesis(h)),
+                conclusion,
+                confidence,
+                rounds: params.rounds,
+                totalDurationMs: Date.now() - params.startTime,
+                partial: true,
+                terminationReason,
+                terminationMessage,
+            },
             sessionContext: params.context.sessionContext,
             previousTurnCount: params.context.previousTurns.length,
             quickMode: params.quickMode,
@@ -1337,16 +1567,21 @@ class OpenAIRuntime extends events_1.EventEmitter {
             followUpType: input.previousTurnCount > 0 ? 'extend' : 'initial',
         }, {
             agentId: 'openai-agent',
-            success: true,
-            findings: input.findings,
-            confidence: input.confidence,
-            message: input.conclusion,
-        }, input.findings);
+            success: input.result.success,
+            findings: input.result.findings,
+            confidence: input.result.confidence,
+            message: input.result.conclusion,
+            partial: input.result.partial,
+            terminationReason: input.result.terminationReason,
+            terminationMessage: input.result.terminationMessage,
+        }, input.result.findings);
+        if (input.result.partial === true)
+            return;
         input.sessionContext.updateWorkingMemoryFromConclusion({
             turnIndex: input.previousTurnCount,
             query: input.query,
-            conclusion: input.conclusion,
-            confidence: input.confidence,
+            conclusion: input.result.conclusion,
+            confidence: input.result.confidence,
         });
     }
     captureEntitiesFromSkillDisplayResults(displayResults, entityStore) {