ГЛОБАЛЬНЫЙ РЕФАКТОРИНГ АРХИТЕКТУРЫ - Рефакторинг этапов 2.43: assistantService переподключен на новый deep-analysis attempt adapter. (с удалением старой громоздкой склейки).

2026-04-10 23:37:24 +03:00
parent 875f3bfbcd
commit 80754e016c
6 changed files with 767 additions and 185 deletions
@@ -0,0 +1,243 @@
+import { resolveCompanyAnchors } from "./companyAnchorResolver";
+import {
+  applyPolarityHintToExecutionPlan,
+  applyTemporalHintToExecutionPlan,
+  resolveDomainPolarityGuard,
+  resolveTemporalGuard
+} from "./assistantRuntimeGuards";
+import { resolveClaimBoundAnchors } from "./assistantClaimBoundEvidence";
+import {
+  runAssistantDeepTurnAnalysisRuntime,
+  type RunAssistantDeepTurnAnalysisRuntimeInput,
+  type RunAssistantDeepTurnAnalysisRuntimeOutput
+} from "./assistantDeepTurnAnalysisRuntimeAdapter";
+import {
+  buildAssistantDeepTurnRuntimeContext,
+  type BuildAssistantDeepTurnRuntimeContextInput,
+  type BuildAssistantDeepTurnRuntimeContextOutput
+} from "./assistantDeepTurnContextRuntimeAdapter";
+import {
+  buildAssistantDeepTurnExecutionPlan,
+  type BuildAssistantDeepTurnExecutionPlanInput,
+  type BuildAssistantDeepTurnExecutionPlanOutput
+} from "./assistantDeepTurnPlanRuntimeAdapter";
+import {
+  executeAssistantDeepTurnRetrievalPlan,
+  type AssistantDeepTurnRetrievalExecutionInput,
+  type AssistantDeepTurnRetrievalExecutionOutput
+} from "./assistantDeepTurnRetrievalRuntimeAdapter";
+import {
+  applyAssistantDeepTurnRetrievalGuards,
+  type AssistantDeepTurnRetrievalGuardPipelineInput,
+  type AssistantDeepTurnRetrievalGuardPipelineOutput
+} from "./assistantDeepTurnGuardRuntimeAdapter";
+import {
+  runAssistantDeepTurnGroundingRuntime,
+  type AssistantDeepTurnGroundingRuntimeInput,
+  type AssistantDeepTurnGroundingRuntimeOutput
+} from "./assistantDeepTurnGroundingRuntimeAdapter";
+import {
+  buildAssistantDeepTurnComposition,
+  type BuildAssistantDeepTurnCompositionInput,
+  type AssistantDeepTurnCompositionOutput
+} from "./assistantDeepTurnCompositionRuntimeAdapter";
+import type { NormalizeResponsePayload, RouteHintSummary } from "../types/normalizer";
+import type { InvestigationStateWithProblemUnits } from "../types/stage2ProblemUnits";
+import type { AssistantExecutionPlanItem } from "./assistantQueryPlanning";
+import type { AssistantRequirementExtractionLike } from "./assistantDeepTurnPlanRuntimeAdapter";
+
+interface RuntimeAnalysisContextLike {
+  active: boolean;
+  as_of_date: string | null;
+  period_from: string | null;
+  period_to: string | null;
+  source: string | null;
+}
+
+export interface RunAssistantDeepTurnAnalysisAttemptRuntimeInput {
+  userMessage: string;
+  normalizedPayload: NormalizeResponsePayload["normalized"];
+  routeSummary: RouteHintSummary | null;
+  runtimeAnalysisContext: RuntimeAnalysisContextLike;
+  followupUsage: unknown | null | undefined;
+  investigationState: InvestigationStateWithProblemUnits | null | undefined;
+  featureAnswerPolicyV11: boolean;
+  featureProblemCentricAnswerV1: boolean;
+  featureLifecycleAnswerV1: boolean;
+  resolveBusinessScopeAlignment: BuildAssistantDeepTurnRuntimeContextInput["resolveBusinessScopeAlignment"];
+  inferP0DomainFromMessage: BuildAssistantDeepTurnRuntimeContextInput["inferP0DomainFromMessage"];
+  resolveBusinessScopeFromLiveContext: BuildAssistantDeepTurnRuntimeContextInput["resolveBusinessScopeFromLiveContext"];
+  extractRequirements: BuildAssistantDeepTurnExecutionPlanInput["extractRequirements"];
+  toExecutionPlan: BuildAssistantDeepTurnExecutionPlanInput["toExecutionPlan"];
+  enforceRbpLiveRoutePlan: BuildAssistantDeepTurnExecutionPlanInput["enforceRbpLiveRoutePlan"];
+  enforceFaLiveRoutePlan: BuildAssistantDeepTurnExecutionPlanInput["enforceFaLiveRoutePlan"];
+  executeRouteRuntime: AssistantDeepTurnRetrievalExecutionInput["executeRouteRuntime"];
+  mapNoRouteReason: AssistantDeepTurnRetrievalExecutionInput["mapNoRouteReason"];
+  buildSkippedResult: AssistantDeepTurnRetrievalExecutionInput["buildSkippedResult"];
+  evaluateCoverage: AssistantDeepTurnGroundingRuntimeInput["evaluateCoverage"];
+  checkGrounding: AssistantDeepTurnGroundingRuntimeInput["checkGrounding"];
+  collectRbpLiveRouteAudit: AssistantDeepTurnGroundingRuntimeInput["collectRbpLiveRouteAudit"];
+  collectFaLiveRouteAudit: AssistantDeepTurnGroundingRuntimeInput["collectFaLiveRouteAudit"];
+  hasExplicitPeriodAnchor: BuildAssistantDeepTurnCompositionInput["hasExplicitPeriodAnchor"];
+  runDeepTurnAnalysisRuntime?: (
+    input: RunAssistantDeepTurnAnalysisRuntimeInput
+  ) => Promise<RunAssistantDeepTurnAnalysisRuntimeOutput>;
+  runDeepTurnContextRuntime?: (
+    input: BuildAssistantDeepTurnRuntimeContextInput
+  ) => BuildAssistantDeepTurnRuntimeContextOutput;
+  runDeepTurnPlanRuntime?: (
+    input: BuildAssistantDeepTurnExecutionPlanInput
+  ) => BuildAssistantDeepTurnExecutionPlanOutput;
+  runDeepTurnRetrievalRuntime?: (
+    input: AssistantDeepTurnRetrievalExecutionInput
+  ) => Promise<AssistantDeepTurnRetrievalExecutionOutput>;
+  runDeepTurnGuardRuntime?: (
+    input: AssistantDeepTurnRetrievalGuardPipelineInput
+  ) => AssistantDeepTurnRetrievalGuardPipelineOutput;
+  runDeepTurnGroundingRuntime?: (
+    input: AssistantDeepTurnGroundingRuntimeInput
+  ) => AssistantDeepTurnGroundingRuntimeOutput;
+  runDeepTurnCompositionRuntime?: (
+    input: BuildAssistantDeepTurnCompositionInput
+  ) => AssistantDeepTurnCompositionOutput;
+}
+
+export async function runAssistantDeepTurnAnalysisAttemptRuntime(
+  input: RunAssistantDeepTurnAnalysisAttemptRuntimeInput
+): Promise<RunAssistantDeepTurnAnalysisRuntimeOutput> {
+  const runDeepTurnAnalysisRuntimeSafe =
+    input.runDeepTurnAnalysisRuntime ?? runAssistantDeepTurnAnalysisRuntime;
+  const runDeepTurnContextRuntimeSafe = input.runDeepTurnContextRuntime ?? buildAssistantDeepTurnRuntimeContext;
+  const runDeepTurnPlanRuntimeSafe = input.runDeepTurnPlanRuntime ?? buildAssistantDeepTurnExecutionPlan;
+  const runDeepTurnRetrievalRuntimeSafe =
+    input.runDeepTurnRetrievalRuntime ?? executeAssistantDeepTurnRetrievalPlan;
+  const runDeepTurnGuardRuntimeSafe = input.runDeepTurnGuardRuntime ?? applyAssistantDeepTurnRetrievalGuards;
+  const runDeepTurnGroundingRuntimeSafe =
+    input.runDeepTurnGroundingRuntime ?? runAssistantDeepTurnGroundingRuntime;
+  const runDeepTurnCompositionRuntimeSafe =
+    input.runDeepTurnCompositionRuntime ?? buildAssistantDeepTurnComposition;
+
+  return runDeepTurnAnalysisRuntimeSafe({
+    userMessage: input.userMessage,
+    runContextRuntime: () =>
+      runDeepTurnContextRuntimeSafe({
+        userMessage: input.userMessage,
+        normalizedPayload: input.normalizedPayload,
+        routeSummary: input.routeSummary,
+        runtimeAnalysisContext: input.runtimeAnalysisContext,
+        followupUsage: input.followupUsage,
+        resolveCompanyAnchors,
+        resolveBusinessScopeAlignment: input.resolveBusinessScopeAlignment,
+        inferP0DomainFromMessage: input.inferP0DomainFromMessage,
+        resolveTemporalGuard: resolveTemporalGuard as any,
+        resolveDomainPolarityGuard: resolveDomainPolarityGuard as any,
+        resolveClaimBoundAnchors: resolveClaimBoundAnchors as any,
+        resolveBusinessScopeFromLiveContext: input.resolveBusinessScopeFromLiveContext
+      }) as any,
+    runExecutionPlanRuntime: ({
+      resolvedRouteSummary,
+      claimAnchorAudit,
+      temporalGuard,
+      domainPolarityGuardInitial
+    }) =>
+      runDeepTurnPlanRuntimeSafe({
+        routeSummary: resolvedRouteSummary,
+        normalizedPayload: input.normalizedPayload,
+        userMessage: input.userMessage,
+        claimType: claimAnchorAudit.claim_type,
+        temporalGuard,
+        domainPolarityGuardInitial,
+        extractRequirements: input.extractRequirements,
+        toExecutionPlan: input.toExecutionPlan,
+        enforceRbpLiveRoutePlan: input.enforceRbpLiveRoutePlan,
+        enforceFaLiveRoutePlan: input.enforceFaLiveRoutePlan,
+        applyTemporalHintToExecutionPlan: applyTemporalHintToExecutionPlan as any,
+        applyPolarityHintToExecutionPlan: applyPolarityHintToExecutionPlan as any
+      }) as any,
+    runRetrievalRuntime: ({ executionPlan, liveTemporalHint }) =>
+      runDeepTurnRetrievalRuntimeSafe({
+        executionPlan: executionPlan as AssistantExecutionPlanItem[],
+        liveTemporalHint,
+        executeRouteRuntime: input.executeRouteRuntime,
+        mapNoRouteReason: input.mapNoRouteReason,
+        buildSkippedResult: input.buildSkippedResult
+      }) as any,
+    runGuardRuntime: ({
+      retrievalResults,
+      domainPolarityGuardInitial,
+      claimAnchorAudit,
+      temporalGuard,
+      focusDomainForGuards,
+      companyAnchors,
+      userMessage: runtimeUserMessage
+    }) =>
+      runDeepTurnGuardRuntimeSafe({
+        retrievalResults,
+        domainPolarityGuardInitial: domainPolarityGuardInitial as any,
+        claimAnchorAudit: claimAnchorAudit as any,
+        temporalGuard: temporalGuard as any,
+        focusDomainForGuards: focusDomainForGuards as any,
+        companyAnchors: companyAnchors as any,
+        userMessage: runtimeUserMessage
+      } as any),
+    runGroundingRuntime: ({
+      claimType,
+      retrievalResults,
+      rbpPlanAudit,
+      faPlanAudit,
+      routeSummary,
+      requirementExtraction,
+      temporalGuard,
+      polarityAudit,
+      evidenceAudit,
+      claimAnchorAudit,
+      targetedEvidenceHitRate,
+      businessScopeResolved
+    }) =>
+      runDeepTurnGroundingRuntimeSafe({
+        claimType,
+        retrievalResults,
+        rbpPlanAudit,
+        faPlanAudit,
+        routeSummary,
+        normalizedPayload: input.normalizedPayload,
+        userMessage: input.userMessage,
+        requirementExtraction: requirementExtraction as AssistantRequirementExtractionLike,
+        extractRequirements: input.extractRequirements as any,
+        evaluateCoverage: input.evaluateCoverage as any,
+        checkGrounding: input.checkGrounding as any,
+        temporalGuard,
+        polarityAudit,
+        evidenceAudit,
+        claimAnchorAudit,
+        targetedEvidenceHitRate,
+        businessScopeResolved,
+        collectRbpLiveRouteAudit: input.collectRbpLiveRouteAudit as any,
+        collectFaLiveRouteAudit: input.collectFaLiveRouteAudit as any
+      } as any),
+    runCompositionRuntime: ({
+      resolvedRouteSummary,
+      retrievalResults,
+      requirements,
+      coverageReport,
+      groundingCheck,
+      companyAnchors
+    }) =>
+      runDeepTurnCompositionRuntimeSafe({
+        userMessage: input.userMessage,
+        routeSummary: resolvedRouteSummary,
+        retrievalResults,
+        requirements,
+        coverageReport,
+        groundingCheck,
+        followupUsage: input.followupUsage,
+        investigationState: input.investigationState,
+        companyAnchors,
+        normalizedPayload: input.normalizedPayload,
+        featureAnswerPolicyV11: input.featureAnswerPolicyV11,
+        featureProblemCentricAnswerV1: input.featureProblemCentricAnswerV1,
+        featureLifecycleAnswerV1: input.featureLifecycleAnswerV1,
+        hasExplicitPeriodAnchor: input.hasExplicitPeriodAnchor
+      }) as any
+  });
+}
@@ -7,9 +7,6 @@ import * as assistantDataLayer_1 from "./assistantDataLayer";
 import * as assistantSessionLogger_1 from "./assistantSessionLogger";
 import * as investigationState_1 from "./investigationState";
 import * as retrievalResultNormalizer_1 from "./retrievalResultNormalizer";
-import * as companyAnchorResolver_1 from "./companyAnchorResolver";
-import * as assistantRuntimeGuards_1 from "./assistantRuntimeGuards";
-import * as assistantClaimBoundEvidence_1 from "./assistantClaimBoundEvidence";
 import * as addressQueryService_1 from "./addressQueryService";
 import * as addressQueryClassifier_1 from "./addressQueryClassifier";
 import * as addressIntentResolver_1 from "./addressIntentResolver";
@@ -21,17 +18,11 @@ import * as capabilitiesRegistry_1 from "./capabilitiesRegistry";
 import * as assistantCanon_1 from "./assistantCanon";
 import * as assistantAddressLaneResponseAttemptRuntimeAdapter_1 from "./assistantAddressLaneResponseAttemptRuntimeAdapter";
 import * as assistantCoverageGrounding_1 from "./assistantCoverageGrounding";
-import * as assistantDeepTurnAnalysisRuntimeAdapter_1 from "./assistantDeepTurnAnalysisRuntimeAdapter";
-import * as assistantDeepTurnCompositionRuntimeAdapter_1 from "./assistantDeepTurnCompositionRuntimeAdapter";
-import * as assistantDeepTurnContextRuntimeAdapter_1 from "./assistantDeepTurnContextRuntimeAdapter";
+import * as assistantDeepTurnAnalysisAttemptRuntimeAdapter_1 from "./assistantDeepTurnAnalysisAttemptRuntimeAdapter";
 import * as assistantDeepTurnFinalizeRuntimeAdapter_1 from "./assistantDeepTurnFinalizeRuntimeAdapter";
-import * as assistantDeepTurnGuardRuntimeAdapter_1 from "./assistantDeepTurnGuardRuntimeAdapter";
-import * as assistantDeepTurnGroundingRuntimeAdapter_1 from "./assistantDeepTurnGroundingRuntimeAdapter";
 import * as assistantDeepTurnPackagingRuntimeAdapter_1 from "./assistantDeepTurnPackagingRuntimeAdapter";
-import * as assistantDeepTurnPlanRuntimeAdapter_1 from "./assistantDeepTurnPlanRuntimeAdapter";
 import * as assistantDeepTurnNormalizationRuntimeAdapter_1 from "./assistantDeepTurnNormalizationRuntimeAdapter";
 import * as assistantDeepTurnResponseRuntimeAdapter_1 from "./assistantDeepTurnResponseRuntimeAdapter";
-import * as assistantDeepTurnRetrievalRuntimeAdapter_1 from "./assistantDeepTurnRetrievalRuntimeAdapter";
 import * as assistantAddressRuntimeAdapter_1 from "./assistantAddressRuntimeAdapter";
 import * as assistantAddressLaneAttemptRuntimeAdapter_1 from "./assistantAddressLaneAttemptRuntimeAdapter";
 import * as assistantLivingChatAttemptRuntimeAdapter_1 from "./assistantLivingChatAttemptRuntimeAdapter";
@@ -4470,89 +4461,31 @@ export class AssistantService {
        });
        const followupBinding = normalizationRuntime.followupBinding;
        const normalized = normalizationRuntime.normalized;
-        const deepTurnAnalysisRuntime = await (0, assistantDeepTurnAnalysisRuntimeAdapter_1.runAssistantDeepTurnAnalysisRuntime)({
+        const deepTurnAnalysisRuntime = await (0, assistantDeepTurnAnalysisAttemptRuntimeAdapter_1.runAssistantDeepTurnAnalysisAttemptRuntime)({
            userMessage,
-            runContextRuntime: () => (0, assistantDeepTurnContextRuntimeAdapter_1.buildAssistantDeepTurnRuntimeContext)({
-                userMessage,
-                normalizedPayload: normalized.normalized,
-                routeSummary: normalized.route_hint_summary,
-                runtimeAnalysisContext,
-                followupUsage: followupBinding.usage,
-                resolveCompanyAnchors: companyAnchorResolver_1.resolveCompanyAnchors,
-                resolveBusinessScopeAlignment,
-                inferP0DomainFromMessage,
-                resolveTemporalGuard: assistantRuntimeGuards_1.resolveTemporalGuard,
-                resolveDomainPolarityGuard: assistantRuntimeGuards_1.resolveDomainPolarityGuard,
-                resolveClaimBoundAnchors: assistantClaimBoundEvidence_1.resolveClaimBoundAnchors,
-                resolveBusinessScopeFromLiveContext
-            }),
-            runExecutionPlanRuntime: ({ resolvedRouteSummary, claimAnchorAudit, temporalGuard, domainPolarityGuardInitial }) => (0, assistantDeepTurnPlanRuntimeAdapter_1.buildAssistantDeepTurnExecutionPlan)({
-                routeSummary: resolvedRouteSummary,
-                normalizedPayload: normalized.normalized,
-                userMessage,
-                claimType: claimAnchorAudit.claim_type,
-                temporalGuard,
-                domainPolarityGuardInitial,
-                extractRequirements,
-                toExecutionPlan,
-                enforceRbpLiveRoutePlan,
-                enforceFaLiveRoutePlan,
-                applyTemporalHintToExecutionPlan: assistantRuntimeGuards_1.applyTemporalHintToExecutionPlan,
-                applyPolarityHintToExecutionPlan: assistantRuntimeGuards_1.applyPolarityHintToExecutionPlan
-            }),
-            runRetrievalRuntime: ({ executionPlan, liveTemporalHint }) => (0, assistantDeepTurnRetrievalRuntimeAdapter_1.executeAssistantDeepTurnRetrievalPlan)({
-                executionPlan: executionPlan,
-                liveTemporalHint,
-                executeRouteRuntime: (route, fragmentText, options) => this.dataLayer.executeRouteRuntime(route, fragmentText, options),
-                mapNoRouteReason,
-                buildSkippedResult
-            }),
-            runGuardRuntime: ({ retrievalResults, domainPolarityGuardInitial, claimAnchorAudit, temporalGuard, focusDomainForGuards, companyAnchors, userMessage: runtimeUserMessage }) => (0, assistantDeepTurnGuardRuntimeAdapter_1.applyAssistantDeepTurnRetrievalGuards)({
-                retrievalResults,
-                domainPolarityGuardInitial,
-                claimAnchorAudit,
-                temporalGuard,
-                focusDomainForGuards,
-                companyAnchors,
-                userMessage: runtimeUserMessage
-            }),
-            runGroundingRuntime: ({ claimType, retrievalResults, rbpPlanAudit, faPlanAudit, routeSummary, requirementExtraction, temporalGuard, polarityAudit, evidenceAudit, claimAnchorAudit, targetedEvidenceHitRate, businessScopeResolved }) => (0, assistantDeepTurnGroundingRuntimeAdapter_1.runAssistantDeepTurnGroundingRuntime)({
-                claimType,
-                retrievalResults,
-                rbpPlanAudit,
-                faPlanAudit,
-                routeSummary,
-                normalizedPayload: normalized.normalized,
-                userMessage,
-                requirementExtraction,
-                extractRequirements,
-                evaluateCoverage,
-                checkGrounding,
-                temporalGuard,
-                polarityAudit,
-                evidenceAudit,
-                claimAnchorAudit,
-                targetedEvidenceHitRate,
-                businessScopeResolved,
-                collectRbpLiveRouteAudit,
-                collectFaLiveRouteAudit
-            }),
-            runCompositionRuntime: ({ resolvedRouteSummary, retrievalResults, requirements, coverageReport, groundingCheck, companyAnchors }) => (0, assistantDeepTurnCompositionRuntimeAdapter_1.buildAssistantDeepTurnComposition)({
-                userMessage,
-                routeSummary: resolvedRouteSummary,
-                retrievalResults,
-                requirements,
-                coverageReport,
-                groundingCheck,
-                followupUsage: followupBinding.usage,
-                investigationState: session.investigation_state,
-                companyAnchors,
-                normalizedPayload: normalized.normalized,
-                featureAnswerPolicyV11: config_1.FEATURE_ASSISTANT_ANSWER_POLICY_V11,
-                featureProblemCentricAnswerV1: config_1.FEATURE_ASSISTANT_PROBLEM_CENTRIC_ANSWER_V1,
-                featureLifecycleAnswerV1: config_1.FEATURE_ASSISTANT_LIFECYCLE_ANSWER_V1,
-                hasExplicitPeriodAnchor: (normalizedPayload) => hasExplicitPeriodAnchorFromNormalized(normalizedPayload)
-            })
+            normalizedPayload: normalized.normalized,
+            routeSummary: normalized.route_hint_summary,
+            runtimeAnalysisContext,
+            followupUsage: followupBinding.usage,
+            investigationState: session.investigation_state,
+            featureAnswerPolicyV11: config_1.FEATURE_ASSISTANT_ANSWER_POLICY_V11,
+            featureProblemCentricAnswerV1: config_1.FEATURE_ASSISTANT_PROBLEM_CENTRIC_ANSWER_V1,
+            featureLifecycleAnswerV1: config_1.FEATURE_ASSISTANT_LIFECYCLE_ANSWER_V1,
+            resolveBusinessScopeAlignment,
+            inferP0DomainFromMessage,
+            resolveBusinessScopeFromLiveContext,
+            extractRequirements,
+            toExecutionPlan,
+            enforceRbpLiveRoutePlan,
+            enforceFaLiveRoutePlan,
+            executeRouteRuntime: (route, fragmentText, options) => this.dataLayer.executeRouteRuntime(route, fragmentText, options),
+            mapNoRouteReason,
+            buildSkippedResult,
+            evaluateCoverage,
+            checkGrounding,
+            collectRbpLiveRouteAudit,
+            collectFaLiveRouteAudit,
+            hasExplicitPeriodAnchor: (normalizedPayload) => hasExplicitPeriodAnchorFromNormalized(normalizedPayload)
        });
        const companyAnchors = deepTurnAnalysisRuntime.companyAnchors;
        const temporalGuard = deepTurnAnalysisRuntime.temporalGuard;