SILVER/NODEDC_1C
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

ГЛОБАЛЬНЫЙ РЕФАКТОРИНГ АРХИТЕКТУРЫ - Рефакторинг этапов 2.30: вынос ветки tool_gate_skip + chat fallback из assistantService в отдельный runtime-адаптер, чтобы в сервисе остался только orchestration flow.

Browse Source
This commit is contained in:
dctouch
2026-04-10 20:52:04 +03:00
parent 3531f7ddfe
commit 353cbc1763
16 changed files with 1706 additions and 405 deletions
Download Patch File Download Diff File Expand all files Collapse all files
llm_normalizer/backend/dist/services/assistantAddressToolGateRuntimeAdapter.js
Vendored
+56
View File
@@ -0,0 +1,56 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.runAssistantAddressToolGateRuntime = runAssistantAddressToolGateRuntime;
async function runAssistantAddressToolGateRuntime(input) {
if (Boolean(input.orchestrationDecision?.runAddressLane)) {
return {
handled: false,
response: null
};
}
const runtimeMeta = input.addressRuntimeMeta && typeof input.addressRuntimeMeta === "object"
? input.addressRuntimeMeta
: {};
const predecomposeContract = runtimeMeta.predecomposeContract && typeof runtimeMeta.predecomposeContract === "object"
? runtimeMeta.predecomposeContract
: null;
const predecomposePeriod = predecomposeContract?.period && typeof predecomposeContract.period === "object"
? predecomposeContract.period
: null;
input.logEvent({
timestamp: input.nowIso(),
level: "info",
service: "assistant_loop",
message: "assistant_address_tool_gate_skip",
sessionId: input.sessionId,
details: {
session_id: input.sessionId,
user_message: input.userMessage,
effective_address_user_message: input.addressInputMessage,
address_llm_predecompose_attempted: Boolean(runtimeMeta.attempted),
address_llm_predecompose_applied: Boolean(runtimeMeta.applied),
address_llm_predecompose_reason: runtimeMeta.reason ?? null,
address_fallback_rule_hit: runtimeMeta.fallbackRuleHit ?? null,
address_sanitized_user_message: runtimeMeta.sanitizedUserMessage ?? null,
assistant_orchestration_contract_v1: runtimeMeta.orchestrationContract ?? null,
address_tool_gate_decision: runtimeMeta.toolGateDecision ?? null,
address_tool_gate_reason: runtimeMeta.toolGateReason ?? null,
address_llm_predecompose_contract_intent: predecomposeContract?.intent ?? null,
address_llm_predecompose_contract_aggregation_profile: predecomposeContract?.aggregation_profile ?? null,
address_llm_predecompose_contract_period_scope: predecomposePeriod?.scope ?? null
}
});
if (input.livingModeDecision?.mode === "chat") {
const chatHandled = await input.tryHandleLivingChat(input.livingModeDecision, runtimeMeta);
if (chatHandled) {
return {
handled: true,
response: chatHandled
};
}
}
return {
handled: false,
response: null
};
}
llm_normalizer/backend/dist/services/assistantDeepTurnAnalysisRuntimeAdapter.js
Vendored
+69
View File
@@ -0,0 +1,69 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.runAssistantDeepTurnAnalysisRuntime = runAssistantDeepTurnAnalysisRuntime;
async function runAssistantDeepTurnAnalysisRuntime(input) {
const contextRuntime = input.runContextRuntime();
const executionPlanRuntime = input.runExecutionPlanRuntime({
resolvedRouteSummary: contextRuntime.resolvedRouteSummary,
claimAnchorAudit: contextRuntime.claimAnchorAudit,
temporalGuard: contextRuntime.temporalGuard,
domainPolarityGuardInitial: contextRuntime.domainPolarityGuardInitial
});
const retrievalRuntime = await input.runRetrievalRuntime({
executionPlan: executionPlanRuntime.executionPlan,
liveTemporalHint: contextRuntime.liveTemporalHint
});
const guardRuntime = input.runGuardRuntime({
retrievalResults: retrievalRuntime.retrievalResults,
domainPolarityGuardInitial: contextRuntime.domainPolarityGuardInitial,
claimAnchorAudit: contextRuntime.claimAnchorAudit,
temporalGuard: contextRuntime.temporalGuard,
focusDomainForGuards: contextRuntime.focusDomainForGuards,
companyAnchors: contextRuntime.companyAnchors,
userMessage: input.userMessage
});
const groundingRuntime = input.runGroundingRuntime({
claimType: contextRuntime.claimAnchorAudit.claim_type,
retrievalResults: guardRuntime.retrievalResults,
rbpPlanAudit: executionPlanRuntime.rbpRoutePlanEnforcement.audit,
faPlanAudit: executionPlanRuntime.faRoutePlanEnforcement.audit,
routeSummary: contextRuntime.resolvedRouteSummary,
requirementExtraction: executionPlanRuntime.requirementExtraction,
temporalGuard: contextRuntime.temporalGuard,
polarityAudit: guardRuntime.polarityGuardResult.audit,
evidenceAudit: guardRuntime.evidenceGateResult.audit,
claimAnchorAudit: contextRuntime.claimAnchorAudit,
targetedEvidenceHitRate: guardRuntime.targetedEvidenceResult.audit.targeted_evidence_hit_rate,
businessScopeResolved: contextRuntime.businessScopeResolution.business_scope_resolved ?? null
});
const compositionRuntime = input.runCompositionRuntime({
resolvedRouteSummary: contextRuntime.resolvedRouteSummary,
retrievalResults: guardRuntime.retrievalResults,
requirements: groundingRuntime.coverageEvaluation.requirements,
coverageReport: groundingRuntime.coverageEvaluation.coverage,
groundingCheck: groundingRuntime.groundingCheck,
companyAnchors: contextRuntime.companyAnchors
});
return {
companyAnchors: contextRuntime.companyAnchors,
temporalGuard: contextRuntime.temporalGuard,
claimAnchorAudit: contextRuntime.claimAnchorAudit,
businessScopeResolution: contextRuntime.businessScopeResolution,
resolvedRouteSummary: contextRuntime.resolvedRouteSummary,
requirementExtraction: executionPlanRuntime.requirementExtraction,
executionPlan: executionPlanRuntime.executionPlan,
retrievalCalls: retrievalRuntime.retrievalCalls,
retrievalResultsRaw: retrievalRuntime.retrievalResultsRaw,
retrievalResults: guardRuntime.retrievalResults,
polarityGuardResult: guardRuntime.polarityGuardResult,
targetedEvidenceResult: guardRuntime.targetedEvidenceResult,
evidenceGateResult: guardRuntime.evidenceGateResult,
rbpLiveRouteAudit: groundingRuntime.rbpLiveRouteAudit,
faLiveRouteAudit: groundingRuntime.faLiveRouteAudit,
coverageEvaluation: groundingRuntime.coverageEvaluation,
groundedAnswerEligibilityGuard: groundingRuntime.groundedAnswerEligibilityGuard,
groundingCheck: groundingRuntime.groundingCheck,
questionTypeClass: compositionRuntime.questionTypeClass,
composition: compositionRuntime.composition
};
}
llm_normalizer/backend/dist/services/assistantDeepTurnNormalizationRuntimeAdapter.js
Vendored
+40
View File
@@ -0,0 +1,40 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.buildAssistantDeepTurnNormalizationRuntime = buildAssistantDeepTurnNormalizationRuntime;
async function buildAssistantDeepTurnNormalizationRuntime(input) {
const followupBinding = input.featureInvestigationStateV1 &&
input.featureStateFollowupBindingV1 &&
Boolean(input.sessionInvestigationState)
? input.buildFollowupStateBinding({
userMessage: input.userMessage,
payloadContext: input.payload.context,
investigationState: input.sessionInvestigationState
})
: {
normalizedQuestion: input.userMessage,
mergedContext: input.payload.context,
usage: null
};
const normalizePayload = {
llmProvider: input.payload.llmProvider,
apiKey: input.payload.apiKey,
model: input.payload.model,
baseUrl: input.payload.baseUrl,
temperature: input.payload.temperature,
maxOutputTokens: input.payload.maxOutputTokens,
promptVersion: input.payload.promptVersion ?? "address_query_runtime_v1",
systemPrompt: input.payload.systemPrompt,
developerPrompt: input.payload.developerPrompt,
domainPrompt: input.payload.domainPrompt,
fewShotExamples: input.payload.fewShotExamples,
userQuestion: followupBinding.normalizedQuestion,
context: followupBinding.mergedContext,
useMock: Boolean(input.payload.useMock)
};
const normalized = await input.normalize(normalizePayload);
return {
followupBinding,
normalizePayload,
normalized
};
}
llm_normalizer/backend/dist/services/assistantDeepTurnResponseRuntimeAdapter.js
Vendored
+68
View File
@@ -0,0 +1,68 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.runAssistantDeepTurnResponseRuntime = runAssistantDeepTurnResponseRuntime;
const assistantDeepTurnPackagingRuntimeAdapter_1 = require("./assistantDeepTurnPackagingRuntimeAdapter");
const assistantDeepTurnFinalizeRuntimeAdapter_1 = require("./assistantDeepTurnFinalizeRuntimeAdapter");
function runAssistantDeepTurnResponseRuntime(input) {
const runPackagingRuntimeSafe = input.runPackagingRuntime ?? assistantDeepTurnPackagingRuntimeAdapter_1.runAssistantDeepTurnPackagingRuntime;
const runFinalizeDeepTurnSafe = input.runFinalizeDeepTurn ?? assistantDeepTurnFinalizeRuntimeAdapter_1.finalizeAssistantDeepTurn;
const packagingRuntime = runPackagingRuntimeSafe({
featureInvestigationStateV1: input.featureInvestigationStateV1,
sessionId: input.sessionId,
questionId: input.questionId,
userMessage: input.userMessage,
normalized: input.normalized,
normalizedQuestion: input.normalizedQuestion,
routeSummary: input.routeSummary,
executionPlan: input.executionPlan,
requirementExtractionRequirements: input.requirementExtractionRequirements,
coverageEvaluationRequirements: input.coverageEvaluationRequirements,
coverageReport: input.coverageReport,
groundingCheck: input.groundingCheck,
retrievalCalls: input.retrievalCalls,
retrievalResultsRaw: input.retrievalResultsRaw,
retrievalResults: input.retrievalResults,
questionTypeClass: input.questionTypeClass,
companyAnchors: input.companyAnchors,
runtimeAnalysisContext: input.runtimeAnalysisContext,
businessScopeResolution: input.businessScopeResolution,
temporalGuard: input.temporalGuard,
polarityAudit: input.polarityAudit,
claimAnchorAudit: input.claimAnchorAudit,
targetedEvidenceAudit: input.targetedEvidenceAudit,
evidenceAdmissibilityGateAudit: input.evidenceAdmissibilityGateAudit,
rbpLiveRouteAudit: input.rbpLiveRouteAudit,
faLiveRouteAudit: input.faLiveRouteAudit,
groundedAnswerEligibilityGuard: input.groundedAnswerEligibilityGuard,
followupStateUsage: input.followupStateUsage,
followupApplied: input.followupApplied,
composition: input.composition,
featureContractsV11: input.featureContractsV11,
featureAnswerPolicyV11: input.featureAnswerPolicyV11,
previousInvestigationState: input.previousInvestigationState ?? null,
addressRuntimeMetaForDeep: input.addressRuntimeMetaForDeep,
extractDroppedIntentSegments: input.extractDroppedIntentSegments,
buildDebugRoutes: input.buildDebugRoutes,
extractExecutionState: input.extractExecutionState,
sanitizeReply: input.sanitizeReply,
persistInvestigationState: input.persistInvestigationState,
messageIdFactory: input.messageIdFactory
});
const finalization = runFinalizeDeepTurnSafe({
sessionId: input.sessionId,
assistantReply: packagingRuntime.safeAssistantReply,
replyType: input.composition.reply_type,
assistantItem: packagingRuntime.assistantItem,
debug: packagingRuntime.debug,
deepAnalysisLogDetails: packagingRuntime.deepAnalysisLogDetails,
appendItem: input.appendItem,
getSession: input.getSession,
persistSession: input.persistSession,
cloneConversation: input.cloneConversation,
logEvent: input.logEvent
});
return {
response: finalization.response,
debug: packagingRuntime.debug
};
}
llm_normalizer/backend/dist/services/assistantService.js
Vendored
+139 -184
View File
@@ -67,6 +67,7 @@ const capabilitiesRegistry_1 = __importStar(require("./capabilitiesRegistry"));
const assistantCanon_1 = __importStar(require("./assistantCanon"));
const assistantAddressTurnFinalizeRuntimeAdapter_1 = __importStar(require("./assistantAddressTurnFinalizeRuntimeAdapter"));
const assistantCoverageGrounding_1 = __importStar(require("./assistantCoverageGrounding"));
const assistantDeepTurnAnalysisRuntimeAdapter_1 = __importStar(require("./assistantDeepTurnAnalysisRuntimeAdapter"));
const assistantDeepTurnCompositionRuntimeAdapter_1 = __importStar(require("./assistantDeepTurnCompositionRuntimeAdapter"));
const assistantDeepTurnContextRuntimeAdapter_1 = __importStar(require("./assistantDeepTurnContextRuntimeAdapter"));
const assistantDeepTurnFinalizeRuntimeAdapter_1 = __importStar(require("./assistantDeepTurnFinalizeRuntimeAdapter"));
@@ -74,9 +75,12 @@ const assistantDeepTurnGuardRuntimeAdapter_1 = __importStar(require("./assistant
const assistantDeepTurnGroundingRuntimeAdapter_1 = __importStar(require("./assistantDeepTurnGroundingRuntimeAdapter"));
const assistantDeepTurnPackagingRuntimeAdapter_1 = __importStar(require("./assistantDeepTurnPackagingRuntimeAdapter"));
const assistantDeepTurnPlanRuntimeAdapter_1 = __importStar(require("./assistantDeepTurnPlanRuntimeAdapter"));
const assistantDeepTurnNormalizationRuntimeAdapter_1 = __importStar(require("./assistantDeepTurnNormalizationRuntimeAdapter"));
const assistantDeepTurnResponseRuntimeAdapter_1 = __importStar(require("./assistantDeepTurnResponseRuntimeAdapter"));
const assistantDeepTurnRetrievalRuntimeAdapter_1 = __importStar(require("./assistantDeepTurnRetrievalRuntimeAdapter"));
const assistantAddressLaneRuntimeAdapter_1 = __importStar(require("./assistantAddressLaneRuntimeAdapter"));
const assistantAddressOrchestrationRuntimeAdapter_1 = __importStar(require("./assistantAddressOrchestrationRuntimeAdapter"));
const assistantAddressToolGateRuntimeAdapter_1 = __importStar(require("./assistantAddressToolGateRuntimeAdapter"));
const assistantLivingChatTurnFinalizeRuntimeAdapter_1 = __importStar(require("./assistantLivingChatTurnFinalizeRuntimeAdapter"));
const assistantLivingChatRuntimeAdapter_1 = __importStar(require("./assistantLivingChatRuntimeAdapter"));
const assistantQueryPlanning_1 = __importStar(require("./assistantQueryPlanning"));
@@ -4583,36 +4587,19 @@ class AssistantService {
const addressRuntimeMeta = addressOrchestrationRuntime.addressRuntimeMeta;
addressRuntimeMetaForDeep = addressRuntimeMeta;
const livingModeDecision = addressOrchestrationRuntime.livingModeDecision;
if (!orchestrationDecision.runAddressLane) {
(0, log_1.logJson)({
timestamp: new Date().toISOString(),
level: "info",
service: "assistant_loop",
message: "assistant_address_tool_gate_skip",
sessionId,
details: {
session_id: sessionId,
user_message: userMessage,
effective_address_user_message: addressInputMessage,
address_llm_predecompose_attempted: Boolean(addressRuntimeMeta?.attempted),
address_llm_predecompose_applied: Boolean(addressRuntimeMeta?.applied),
address_llm_predecompose_reason: addressRuntimeMeta?.reason ?? null,
address_fallback_rule_hit: addressRuntimeMeta?.fallbackRuleHit ?? null,
address_sanitized_user_message: addressRuntimeMeta?.sanitizedUserMessage ?? null,
assistant_orchestration_contract_v1: addressRuntimeMeta?.orchestrationContract ?? null,
address_tool_gate_decision: addressRuntimeMeta?.toolGateDecision ?? null,
address_tool_gate_reason: addressRuntimeMeta?.toolGateReason ?? null,
address_llm_predecompose_contract_intent: addressRuntimeMeta?.predecomposeContract?.intent ?? null,
address_llm_predecompose_contract_aggregation_profile: addressRuntimeMeta?.predecomposeContract?.aggregation_profile ?? null,
address_llm_predecompose_contract_period_scope: addressRuntimeMeta?.predecomposeContract?.period?.scope ?? null
}
});
if (livingModeDecision.mode === "chat") {
const chatHandled = await tryHandleLivingChat(livingModeDecision, addressRuntimeMeta);
if (chatHandled) {
return chatHandled;
}
}
const toolGateRuntime = await (0, assistantAddressToolGateRuntimeAdapter_1.runAssistantAddressToolGateRuntime)({
sessionId,
userMessage,
addressInputMessage,
orchestrationDecision,
livingModeDecision,
addressRuntimeMeta,
logEvent: (payload) => (0, log_1.logJson)(payload),
tryHandleLivingChat: (modeDecision, runtimeMeta) => tryHandleLivingChat(modeDecision, runtimeMeta),
nowIso: () => new Date().toISOString()
});
if (toolGateRuntime.handled && toolGateRuntime.response) {
return toolGateRuntime.response;
}
if (orchestrationDecision.runAddressLane) {
const shouldPreferContextualLane = Boolean(carryover?.followupContext);
@@ -4648,145 +4635,125 @@ class AssistantService {
}
}
}
const followupBinding = config_1.FEATURE_ASSISTANT_INVESTIGATION_STATE_V1 &&
config_1.FEATURE_ASSISTANT_STATE_FOLLOWUP_BINDING_V1 &&
session.investigation_state
? buildFollowupStateBinding({
userMessage,
payloadContext: payload.context,
investigationState: session.investigation_state
})
: {
normalizedQuestion: userMessage,
mergedContext: payload.context,
usage: null
};
const normalizePayload = {
llmProvider: payload.llmProvider,
apiKey: payload.apiKey,
model: payload.model,
baseUrl: payload.baseUrl,
temperature: payload.temperature,
maxOutputTokens: payload.maxOutputTokens,
promptVersion: payload.promptVersion ?? "address_query_runtime_v1",
systemPrompt: payload.systemPrompt,
developerPrompt: payload.developerPrompt,
domainPrompt: payload.domainPrompt,
fewShotExamples: payload.fewShotExamples,
userQuestion: followupBinding.normalizedQuestion,
context: followupBinding.mergedContext,
useMock: Boolean(payload.useMock)
};
const normalized = await this.normalizerService.normalize(normalizePayload);
const contextRuntime = (0, assistantDeepTurnContextRuntimeAdapter_1.buildAssistantDeepTurnRuntimeContext)({
const normalizationRuntime = await (0, assistantDeepTurnNormalizationRuntimeAdapter_1.buildAssistantDeepTurnNormalizationRuntime)({
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
});
const companyAnchors = contextRuntime.companyAnchors;
const focusDomainForGuards = contextRuntime.focusDomainForGuards;
const temporalGuard = contextRuntime.temporalGuard;
const domainPolarityGuardInitial = contextRuntime.domainPolarityGuardInitial;
const claimAnchorAudit = contextRuntime.claimAnchorAudit;
const businessScopeResolution = contextRuntime.businessScopeResolution;
const resolvedRouteSummary = contextRuntime.resolvedRouteSummary;
const liveTemporalHint = contextRuntime.liveTemporalHint;
const executionPlanRuntime = (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
});
const requirementExtraction = executionPlanRuntime.requirementExtraction;
const rbpRoutePlanEnforcement = executionPlanRuntime.rbpRoutePlanEnforcement;
const faRoutePlanEnforcement = executionPlanRuntime.faRoutePlanEnforcement;
const executionPlan = executionPlanRuntime.executionPlan;
const retrievalRuntime = await (0, assistantDeepTurnRetrievalRuntimeAdapter_1.executeAssistantDeepTurnRetrievalPlan)({
executionPlan,
liveTemporalHint,
executeRouteRuntime: (route, fragmentText, options) => this.dataLayer.executeRouteRuntime(route, fragmentText, options),
mapNoRouteReason,
buildSkippedResult
});
const retrievalCalls = retrievalRuntime.retrievalCalls;
const retrievalResultsRaw = retrievalRuntime.retrievalResultsRaw;
let retrievalResults = retrievalRuntime.retrievalResults;
const guardRuntime = (0, assistantDeepTurnGuardRuntimeAdapter_1.applyAssistantDeepTurnRetrievalGuards)({
retrievalResults,
domainPolarityGuardInitial,
claimAnchorAudit,
temporalGuard,
focusDomainForGuards,
companyAnchors,
userMessage
});
retrievalResults = guardRuntime.retrievalResults;
const polarityGuardResult = guardRuntime.polarityGuardResult;
const targetedEvidenceResult = guardRuntime.targetedEvidenceResult;
const evidenceGateResult = guardRuntime.evidenceGateResult;
const groundingRuntime = (0, assistantDeepTurnGroundingRuntimeAdapter_1.runAssistantDeepTurnGroundingRuntime)({
claimType: claimAnchorAudit.claim_type,
retrievalResults,
rbpPlanAudit: rbpRoutePlanEnforcement.audit,
faPlanAudit: faRoutePlanEnforcement.audit,
routeSummary: resolvedRouteSummary,
normalizedPayload: normalized.normalized,
userMessage,
requirementExtraction,
extractRequirements,
evaluateCoverage,
checkGrounding,
temporalGuard,
polarityAudit: polarityGuardResult.audit,
evidenceAudit: evidenceGateResult.audit,
claimAnchorAudit,
targetedEvidenceHitRate: targetedEvidenceResult.audit.targeted_evidence_hit_rate,
businessScopeResolved: businessScopeResolution.business_scope_resolved,
collectRbpLiveRouteAudit,
collectFaLiveRouteAudit
});
const rbpLiveRouteAudit = groundingRuntime.rbpLiveRouteAudit;
const faLiveRouteAudit = groundingRuntime.faLiveRouteAudit;
const coverageEvaluation = groundingRuntime.coverageEvaluation;
const groundedAnswerEligibilityGuard = groundingRuntime.groundedAnswerEligibilityGuard;
const groundingCheck = groundingRuntime.groundingCheck;
const deepTurnComposition = (0, assistantDeepTurnCompositionRuntimeAdapter_1.buildAssistantDeepTurnComposition)({
userMessage,
routeSummary: resolvedRouteSummary,
retrievalResults,
requirements: coverageEvaluation.requirements,
coverageReport: coverageEvaluation.coverage,
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)
});
const questionTypeClass = deepTurnComposition.questionTypeClass;
const composition = deepTurnComposition.composition;
const packagingRuntime = (0, assistantDeepTurnPackagingRuntimeAdapter_1.runAssistantDeepTurnPackagingRuntime)({
payload,
featureInvestigationStateV1: config_1.FEATURE_ASSISTANT_INVESTIGATION_STATE_V1,
featureStateFollowupBindingV1: config_1.FEATURE_ASSISTANT_STATE_FOLLOWUP_BINDING_V1,
sessionInvestigationState: session.investigation_state,
buildFollowupStateBinding,
normalize: (normalizePayload) => this.normalizerService.normalize(normalizePayload)
});
const followupBinding = normalizationRuntime.followupBinding;
const normalized = normalizationRuntime.normalized;
const deepTurnAnalysisRuntime = await (0, assistantDeepTurnAnalysisRuntimeAdapter_1.runAssistantDeepTurnAnalysisRuntime)({
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)
})
});
const companyAnchors = deepTurnAnalysisRuntime.companyAnchors;
const temporalGuard = deepTurnAnalysisRuntime.temporalGuard;
const claimAnchorAudit = deepTurnAnalysisRuntime.claimAnchorAudit;
const businessScopeResolution = deepTurnAnalysisRuntime.businessScopeResolution;
const resolvedRouteSummary = deepTurnAnalysisRuntime.resolvedRouteSummary;
const requirementExtraction = deepTurnAnalysisRuntime.requirementExtraction;
const executionPlan = deepTurnAnalysisRuntime.executionPlan;
const retrievalCalls = deepTurnAnalysisRuntime.retrievalCalls;
const retrievalResultsRaw = deepTurnAnalysisRuntime.retrievalResultsRaw;
const retrievalResults = deepTurnAnalysisRuntime.retrievalResults;
const polarityGuardResult = deepTurnAnalysisRuntime.polarityGuardResult;
const targetedEvidenceResult = deepTurnAnalysisRuntime.targetedEvidenceResult;
const evidenceGateResult = deepTurnAnalysisRuntime.evidenceGateResult;
const rbpLiveRouteAudit = deepTurnAnalysisRuntime.rbpLiveRouteAudit;
const faLiveRouteAudit = deepTurnAnalysisRuntime.faLiveRouteAudit;
const coverageEvaluation = deepTurnAnalysisRuntime.coverageEvaluation;
const groundedAnswerEligibilityGuard = deepTurnAnalysisRuntime.groundedAnswerEligibilityGuard;
const groundingCheck = deepTurnAnalysisRuntime.groundingCheck;
const questionTypeClass = deepTurnAnalysisRuntime.questionTypeClass;
const composition = deepTurnAnalysisRuntime.composition;
const deepTurnResponseRuntime = (0, assistantDeepTurnResponseRuntimeAdapter_1.runAssistantDeepTurnResponseRuntime)({
featureInvestigationStateV1: config_1.FEATURE_ASSISTANT_INVESTIGATION_STATE_V1,
featureContractsV11: config_1.FEATURE_ASSISTANT_CONTRACTS_V11,
featureAnswerPolicyV11: config_1.FEATURE_ASSISTANT_ANSWER_POLICY_V11,
sessionId,
questionId: userItem.message_id,
userMessage,
@@ -4821,8 +4788,6 @@ class AssistantService {
followupStateUsage: followupBinding.usage,
followupApplied: Boolean(followupBinding.usage?.applied),
composition,
featureContractsV11: config_1.FEATURE_ASSISTANT_CONTRACTS_V11,
featureAnswerPolicyV11: config_1.FEATURE_ASSISTANT_ANSWER_POLICY_V11,
previousInvestigationState: session.investigation_state,
addressRuntimeMetaForDeep,
extractDroppedIntentSegments: (normalizedPayload) => extractDiscardedIntentSegments(normalizedPayload),
@@ -4830,26 +4795,16 @@ class AssistantService {
extractExecutionState: (normalizedPayload) => extractExecutionState(normalizedPayload),
sanitizeReply: (value, fallback) => sanitizeOutgoingAssistantText(value, fallback),
persistInvestigationState: (targetSessionId, snapshot) => this.sessions.setInvestigationState(targetSessionId, snapshot),
messageIdFactory: () => `msg-${(0, nanoid_1.nanoid)(10)}`
});
const safeAssistantReply = packagingRuntime.safeAssistantReply;
const debug = packagingRuntime.debug;
const assistantItem = packagingRuntime.assistantItem;
const deepAnalysisLogDetails = packagingRuntime.deepAnalysisLogDetails;
const finalization = (0, assistantDeepTurnFinalizeRuntimeAdapter_1.finalizeAssistantDeepTurn)({
sessionId,
assistantReply: safeAssistantReply,
replyType: composition.reply_type,
assistantItem,
debug,
deepAnalysisLogDetails,
messageIdFactory: () => `msg-${(0, nanoid_1.nanoid)(10)}`,
appendItem: (targetSessionId, item) => this.sessions.appendItem(targetSessionId, item),
getSession: (targetSessionId) => this.sessions.getSession(targetSessionId),
persistSession: (sessionState) => this.sessionLogger.persistSession(sessionState),
cloneConversation: (items) => cloneItems(items),
logEvent: (payload) => (0, log_1.logJson)(payload)
logEvent: (payload) => (0, log_1.logJson)(payload),
runPackagingRuntime: (input) => (0, assistantDeepTurnPackagingRuntimeAdapter_1.runAssistantDeepTurnPackagingRuntime)(input),
runFinalizeDeepTurn: (input) => (0, assistantDeepTurnFinalizeRuntimeAdapter_1.finalizeAssistantDeepTurn)(input)
});
return finalization.response;
return deepTurnResponseRuntime.response;
}
}
exports.AssistantService = AssistantService;