562 lines
26 KiB
JavaScript
562 lines
26 KiB
JavaScript
"use strict";
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.ASSISTANT_MCP_DISCOVERY_TURN_INPUT_SCHEMA_VERSION = void 0;
|
||
exports.buildAssistantMcpDiscoveryTurnInput = buildAssistantMcpDiscoveryTurnInput;
|
||
exports.ASSISTANT_MCP_DISCOVERY_TURN_INPUT_SCHEMA_VERSION = "assistant_mcp_discovery_turn_input_v1";
|
||
function toRecordObject(value) {
|
||
if (!value || typeof value !== "object" || Array.isArray(value)) {
|
||
return null;
|
||
}
|
||
return value;
|
||
}
|
||
function toNonEmptyString(value) {
|
||
if (value === null || value === undefined) {
|
||
return null;
|
||
}
|
||
const text = String(value).trim();
|
||
return text.length > 0 ? text : null;
|
||
}
|
||
function normalizeReasonCode(value) {
|
||
const normalized = value
|
||
.trim()
|
||
.replace(/[^\p{L}\p{N}_.:-]+/gu, "_")
|
||
.replace(/^_+|_+$/g, "")
|
||
.toLowerCase();
|
||
return normalized.length > 0 ? normalized.slice(0, 120) : null;
|
||
}
|
||
function pushReason(target, value) {
|
||
const normalized = normalizeReasonCode(value);
|
||
if (normalized && !target.includes(normalized)) {
|
||
target.push(normalized);
|
||
}
|
||
}
|
||
function pushUnique(target, value) {
|
||
const text = toNonEmptyString(value);
|
||
if (text && !target.includes(text)) {
|
||
target.push(text);
|
||
}
|
||
}
|
||
function compactLower(value) {
|
||
return String(value ?? "")
|
||
.toLowerCase()
|
||
.replace(/\s+/g, " ")
|
||
.trim();
|
||
}
|
||
function candidateValue(value) {
|
||
const direct = toNonEmptyString(value);
|
||
if (direct && direct !== "[object Object]") {
|
||
return direct;
|
||
}
|
||
const record = toRecordObject(value);
|
||
if (!record) {
|
||
return null;
|
||
}
|
||
return (toNonEmptyString(record.value) ??
|
||
toNonEmptyString(record.name) ??
|
||
toNonEmptyString(record.ref) ??
|
||
toNonEmptyString(record.text));
|
||
}
|
||
function collectEntityCandidates(value) {
|
||
const result = [];
|
||
if (Array.isArray(value)) {
|
||
for (const item of value) {
|
||
pushUnique(result, candidateValue(item));
|
||
}
|
||
return result;
|
||
}
|
||
pushUnique(result, candidateValue(value));
|
||
return result;
|
||
}
|
||
function collectPredecomposeEntities(predecompose) {
|
||
const entities = toRecordObject(predecompose?.entities);
|
||
return {
|
||
counterparty: toNonEmptyString(entities?.counterparty),
|
||
organization: toNonEmptyString(entities?.organization)
|
||
};
|
||
}
|
||
function collectDateScope(predecompose) {
|
||
const period = toRecordObject(predecompose?.period);
|
||
const asOfDate = toNonEmptyString(period?.as_of_date);
|
||
const periodFrom = toNonEmptyString(period?.period_from);
|
||
const periodTo = toNonEmptyString(period?.period_to);
|
||
if (asOfDate) {
|
||
return asOfDate;
|
||
}
|
||
const yearFrom = periodFrom?.match(/^(\d{4})-01-01$/);
|
||
const yearTo = periodTo?.match(/^(\d{4})-12-31$/);
|
||
if (yearFrom && yearTo && yearFrom[1] === yearTo[1]) {
|
||
return yearFrom[1];
|
||
}
|
||
if (periodFrom && periodTo) {
|
||
return `${periodFrom}..${periodTo}`;
|
||
}
|
||
return periodFrom ?? periodTo ?? null;
|
||
}
|
||
function collectDateScopeFromFilters(filters) {
|
||
if (!filters) {
|
||
return null;
|
||
}
|
||
const asOfDate = toNonEmptyString(filters.as_of_date);
|
||
const periodFrom = toNonEmptyString(filters.period_from);
|
||
const periodTo = toNonEmptyString(filters.period_to);
|
||
if (asOfDate) {
|
||
return asOfDate;
|
||
}
|
||
const yearFrom = periodFrom?.match(/^(\d{4})-01-01$/);
|
||
const yearTo = periodTo?.match(/^(\d{4})-12-31$/);
|
||
if (yearFrom && yearTo && yearFrom[1] === yearTo[1]) {
|
||
return yearFrom[1];
|
||
}
|
||
if (periodFrom && periodTo) {
|
||
return `${periodFrom}..${periodTo}`;
|
||
}
|
||
return periodFrom ?? periodTo ?? null;
|
||
}
|
||
function mapPilotScopeToFollowupMeaning(pilotScope) {
|
||
if (pilotScope === "counterparty_lifecycle_query_documents_v1") {
|
||
return {
|
||
domain: "counterparty_lifecycle",
|
||
action: "activity_duration",
|
||
unsupported: "counterparty_lifecycle"
|
||
};
|
||
}
|
||
if (pilotScope === "counterparty_supplier_payout_query_movements_v1") {
|
||
return {
|
||
domain: "counterparty_value",
|
||
action: "payout",
|
||
unsupported: "counterparty_payouts_or_outflow"
|
||
};
|
||
}
|
||
if (pilotScope === "counterparty_value_flow_query_movements_v1") {
|
||
return {
|
||
domain: "counterparty_value",
|
||
action: "turnover",
|
||
unsupported: "counterparty_value_or_turnover"
|
||
};
|
||
}
|
||
if (pilotScope === "counterparty_bidirectional_value_flow_query_movements_v1") {
|
||
return {
|
||
domain: "counterparty_value",
|
||
action: "net_value_flow",
|
||
unsupported: "counterparty_bidirectional_value_flow_or_netting"
|
||
};
|
||
}
|
||
if (pilotScope === "metadata_inspection_v1") {
|
||
return {
|
||
domain: "metadata",
|
||
action: "inspect_catalog",
|
||
unsupported: "1c_metadata_surface"
|
||
};
|
||
}
|
||
return {
|
||
domain: null,
|
||
action: null,
|
||
unsupported: null
|
||
};
|
||
}
|
||
function mapAddressIntentToFollowupMeaning(intent) {
|
||
if (intent === "counterparty_activity_lifecycle") {
|
||
return {
|
||
domain: "counterparty_lifecycle",
|
||
action: "activity_duration",
|
||
unsupported: "counterparty_lifecycle"
|
||
};
|
||
}
|
||
if (intent === "supplier_payouts_profile") {
|
||
return {
|
||
domain: "counterparty_value",
|
||
action: "payout",
|
||
unsupported: "counterparty_payouts_or_outflow"
|
||
};
|
||
}
|
||
if (intent === "customer_revenue_and_payments") {
|
||
return {
|
||
domain: "counterparty_value",
|
||
action: "turnover",
|
||
unsupported: "counterparty_value_or_turnover"
|
||
};
|
||
}
|
||
return {
|
||
domain: null,
|
||
action: null,
|
||
unsupported: null
|
||
};
|
||
}
|
||
function collectFollowupDiscoverySeed(followupContext) {
|
||
const previousFilters = toRecordObject(followupContext?.previous_filters);
|
||
const rootFilters = toRecordObject(followupContext?.root_filters);
|
||
const pilotScope = toNonEmptyString(followupContext?.previous_discovery_pilot_scope);
|
||
const previousIntent = toNonEmptyString(followupContext?.target_intent) ?? toNonEmptyString(followupContext?.previous_intent);
|
||
const mapped = mapPilotScopeToFollowupMeaning(pilotScope).domain !== null
|
||
? mapPilotScopeToFollowupMeaning(pilotScope)
|
||
: mapAddressIntentToFollowupMeaning(previousIntent);
|
||
const discoveryEntities = collectEntityCandidates(followupContext?.previous_discovery_entity_candidates);
|
||
const counterparty = toNonEmptyString(previousFilters?.counterparty) ??
|
||
toNonEmptyString(rootFilters?.counterparty) ??
|
||
(toNonEmptyString(followupContext?.previous_anchor_type) === "counterparty"
|
||
? toNonEmptyString(followupContext?.previous_anchor_value)
|
||
: null);
|
||
const organization = toNonEmptyString(previousFilters?.organization) ??
|
||
toNonEmptyString(rootFilters?.organization) ??
|
||
(toNonEmptyString(followupContext?.previous_anchor_type) === "organization"
|
||
? toNonEmptyString(followupContext?.previous_anchor_value)
|
||
: null);
|
||
const dateScope = collectDateScopeFromFilters(previousFilters) ??
|
||
collectDateScopeFromFilters(rootFilters);
|
||
return {
|
||
pilotScope,
|
||
domain: mapped.domain,
|
||
action: mapped.action,
|
||
unsupported: mapped.unsupported,
|
||
counterparty,
|
||
discoveryEntity: discoveryEntities[0] ?? null,
|
||
organization,
|
||
dateScope,
|
||
metadataRouteFamily: toNonEmptyString(followupContext?.previous_discovery_metadata_route_family),
|
||
metadataSelectedEntitySet: toNonEmptyString(followupContext?.previous_discovery_metadata_selected_entity_set),
|
||
metadataAmbiguityDetected: followupContext?.previous_discovery_metadata_ambiguity_detected === true
|
||
};
|
||
}
|
||
function hasLifecycleSignal(text) {
|
||
return /(?:сколько\s+лет|как\s+давно|давно\s+ли|возраст|перв(?:ая|ый)\s+актив|когда\s+начал|когда\s+появ|lifecycle|activity\s+duration|business\s+age|how\s+long)/iu.test(text);
|
||
}
|
||
function hasValueFlowSignal(text) {
|
||
return /(?:оборот|выручк|оплат|плат[её]ж|заплат|перечисл|списан|расход|исходящ|поступлен|денежн[а-яёa-z0-9_-]*\s+поток|supplier|value[-\s]?flow|turnover|revenue|payment|payout|outflow|cash\s+flow)/iu.test(text);
|
||
}
|
||
function hasPayoutSignal(text) {
|
||
return /(?:\bмы\s+(?:за)?плат|(?:за)?платил|оплатил|перечисл|списан|расход|поставщик|исходящ|supplier|payout|outflow|paid\s+to|payment\s+to)/iu.test(text);
|
||
}
|
||
function hasBidirectionalValueFlowSignal(text) {
|
||
return /(?:нетто|сальдо|баланс\s+(?:плат|денег|денеж)|взаиморасч[её]т|получил[иа]?.*(?:за)?платил|(?:за)?платил[иа]?.*получил|входящ.*исходящ|исходящ.*входящ|дебет.*кредит|кредит.*дебет|net\s+(?:flow|cash|payment)|cash\s+net|incoming\s+and\s+outgoing|received\s+and\s+paid|paid\s+and\s+received)/iu.test(text);
|
||
}
|
||
function hasMonthlyAggregationSignal(text) {
|
||
return /(?:\u043f\u043e\s+\u043c\u0435\u0441\u044f\u0446\u0430\u043c|\u043f\u043e\u043c\u0435\u0441\u044f\u0447\u043d\u043e|\u0435\u0436\u0435\u043c\u0435\u0441\u044f\u0447\u043d\u043e|month\s+by\s+month|by\s+month|monthly)/iu.test(text);
|
||
}
|
||
function hasMetadataSignal(text) {
|
||
if (/(?:\u043c\u0435\u0442\u0430\u0434\u0430\u043d|schema|catalog|metadata\s+surface|\u0441\u0442\u0440\u0443\u043a\u0442\u0443\u0440[\u0430\u044b]\s+1\u0441|\u0441\u0445\u0435\u043c[\u0430\u044b]\s+1\u0441)/iu.test(text)) {
|
||
return true;
|
||
}
|
||
return (/(?:\u0440\u0435\u0433\u0438\u0441\u0442\u0440\u044b|\u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442\u044b|\u0441\u043f\u0440\u0430\u0432\u043e\u0447\u043d\u0438\u043a\u0438|\u043f\u043e\u043b(?:\u0435|\u044f)|registers?|documents?|catalogs?|fields?)/iu.test(text) &&
|
||
/(?:\u0435\u0441\u0442\u044c|\u0434\u043e\u0441\u0442\u0443\u043f\u043d|\u0432\s+1\u0441|available|exist)/iu.test(text));
|
||
}
|
||
function hasMetadataObjectHint(text) {
|
||
return /(?:\u0440\u0435\u0433\u0438\u0441\u0442\u0440(?:\u044b)?|\u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442(?:\u044b)?|\u0441\u043f\u0440\u0430\u0432\u043e\u0447\u043d\u0438\u043a(?:\u0438)?|\u043f\u043e\u043b(?:\u0435|\u044f)|registers?|documents?|catalogs?|fields?)/iu.test(text);
|
||
}
|
||
function hasDocumentEvidenceFollowupSignal(text) {
|
||
return /(?:\u043f\u043e\s+\u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442(?:\u0430\u043c|\u044b)?|\u0434\u0430\u0432\u0430\u0439\s+\u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442(?:\u044b)?|\u0438\u0449\u0438\s+\u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442(?:\u044b)?|\u043f\u043e\u043a\u0430\u0436\u0438\s+\u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442(?:\u044b)?|document(?:s)?\s+(?:then|next)?|(?:then|next)\s+documents?|go\s+to\s+documents?)/iu.test(text);
|
||
}
|
||
function metadataActionFromRawText(text) {
|
||
if (/(?:\u043f\u043e\u043b(?:\u0435|\u044f)|field)/iu.test(text)) {
|
||
return "inspect_fields";
|
||
}
|
||
if (/(?:\u0440\u0435\u0433\u0438\u0441\u0442\u0440|register)/iu.test(text)) {
|
||
return "inspect_registers";
|
||
}
|
||
if (/(?:\u0434\u043e\u043a\u0443\u043c\u0435\u043d\u0442|document)/iu.test(text)) {
|
||
return "inspect_documents";
|
||
}
|
||
if (/(?:\u0441\u043f\u0440\u0430\u0432\u043e\u0447\u043d\u0438\u043a|directory|catalog)/iu.test(text)) {
|
||
return "inspect_catalog";
|
||
}
|
||
return "inspect_catalog";
|
||
}
|
||
function hasExplicitDateScopeLiteral(text) {
|
||
return /(?:\b(?:19|20)\d{2}\b|\b\d{4}-\d{2}-\d{2}\b|\b\d{4}-\d{2}\b)/iu.test(text);
|
||
}
|
||
function collectDateScopeFromRawText(text) {
|
||
const isoDate = text.match(/\b(\d{4}-\d{2}-\d{2})\b/u);
|
||
if (isoDate?.[1]) {
|
||
return isoDate[1];
|
||
}
|
||
const yearMonth = text.match(/\b(\d{4}-\d{2})\b/u);
|
||
if (yearMonth?.[1]) {
|
||
return yearMonth[1];
|
||
}
|
||
const year = text.match(/\b((?:19|20)\d{2})\b/u);
|
||
if (year?.[1]) {
|
||
return year[1];
|
||
}
|
||
return null;
|
||
}
|
||
function semanticNeedFor(input) {
|
||
const combined = compactLower(`${input.domain ?? ""} ${input.action ?? ""} ${input.unsupported ?? ""}`);
|
||
if (input.metadataSignal || /(?:metadata|schema|catalog|inspect_(?:catalog|documents|registers|fields))/iu.test(combined)) {
|
||
return "1C metadata evidence";
|
||
}
|
||
if (input.lifecycleSignal || /(?:lifecycle|activity|duration|age)/iu.test(combined)) {
|
||
return "counterparty lifecycle evidence";
|
||
}
|
||
if (input.valueFlowSignal || /(?:turnover|revenue|payment|payout|value|net|netting|balance|cashflow)/iu.test(combined)) {
|
||
return "counterparty value-flow evidence";
|
||
}
|
||
if (/(?:document|documents|list_documents)/iu.test(combined)) {
|
||
return "document evidence";
|
||
}
|
||
return null;
|
||
}
|
||
function shouldRunDiscovery(input) {
|
||
if (input.lifecycleSignal || input.unsupported) {
|
||
return true;
|
||
}
|
||
if (input.metadataSignal) {
|
||
return true;
|
||
}
|
||
if (input.valueFlowSignal && !input.explicitIntentCandidate) {
|
||
return true;
|
||
}
|
||
if (input.followupDiscoverySeedApplicable && !input.explicitIntentCandidate && input.semanticDataNeed) {
|
||
return true;
|
||
}
|
||
if (!input.explicitIntentCandidate && input.semanticDataNeed) {
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
function buildAssistantMcpDiscoveryTurnInput(input) {
|
||
const assistantTurnMeaning = toRecordObject(input.assistantTurnMeaning);
|
||
const predecomposeContract = toRecordObject(input.predecomposeContract);
|
||
const followupContext = toRecordObject(input.followupContext);
|
||
const predecomposeEntities = collectPredecomposeEntities(predecomposeContract);
|
||
const followupSeed = collectFollowupDiscoverySeed(followupContext);
|
||
const reasonCodes = [];
|
||
const rawText = compactLower(`${input.userMessage ?? ""} ${input.effectiveMessage ?? ""}`);
|
||
const rawLifecycleSignal = hasLifecycleSignal(rawText);
|
||
const rawBidirectionalValueFlowSignal = !rawLifecycleSignal && hasBidirectionalValueFlowSignal(rawText);
|
||
const rawValueFlowSignal = !rawLifecycleSignal && (hasValueFlowSignal(rawText) || rawBidirectionalValueFlowSignal);
|
||
const rawMetadataSignal = !rawLifecycleSignal && !rawValueFlowSignal && hasMetadataSignal(rawText);
|
||
const rawPayoutSignal = rawValueFlowSignal && !rawBidirectionalValueFlowSignal && hasPayoutSignal(rawText);
|
||
const monthlyAggregationSignal = hasMonthlyAggregationSignal(rawText);
|
||
const explicitDateScopeLiteralDetected = hasExplicitDateScopeLiteral(rawText);
|
||
const rawDateScope = collectDateScopeFromRawText(rawText);
|
||
const rawDomain = toNonEmptyString(assistantTurnMeaning?.asked_domain_family);
|
||
const rawAction = toNonEmptyString(assistantTurnMeaning?.asked_action_family);
|
||
const rawAggregationAxis = toNonEmptyString(assistantTurnMeaning?.asked_aggregation_axis);
|
||
const unsupported = toNonEmptyString(assistantTurnMeaning?.unsupported_but_understood_family);
|
||
const explicitIntentCandidate = toNonEmptyString(assistantTurnMeaning?.explicit_intent_candidate);
|
||
const assistantTurnMeaningDateScope = toNonEmptyString(assistantTurnMeaning?.explicit_date_scope);
|
||
const assistantTurnMeaningOrganizationScope = toNonEmptyString(assistantTurnMeaning?.explicit_organization_scope);
|
||
const predecomposeDateScope = collectDateScope(predecomposeContract);
|
||
const followupDiscoverySeedApplicable = Boolean(followupSeed.domain &&
|
||
!rawLifecycleSignal &&
|
||
!rawValueFlowSignal &&
|
||
(monthlyAggregationSignal || explicitDateScopeLiteralDetected || predecomposeDateScope));
|
||
const metadataFollowupSeedApplicable = Boolean(followupSeed.domain === "metadata" &&
|
||
!rawLifecycleSignal &&
|
||
!rawValueFlowSignal &&
|
||
hasMetadataObjectHint(rawText));
|
||
const metadataGroundedDocumentFollowupApplicable = Boolean(followupSeed.pilotScope === "metadata_inspection_v1" &&
|
||
followupSeed.metadataRouteFamily === "document_evidence" &&
|
||
!followupSeed.metadataAmbiguityDetected &&
|
||
followupSeed.counterparty &&
|
||
!rawLifecycleSignal &&
|
||
!rawValueFlowSignal &&
|
||
hasDocumentEvidenceFollowupSignal(rawText));
|
||
const effectiveMetadataFollowupSeedApplicable = metadataFollowupSeedApplicable && !metadataGroundedDocumentFollowupApplicable;
|
||
const seededDomain = metadataGroundedDocumentFollowupApplicable
|
||
? "documents"
|
||
: followupDiscoverySeedApplicable || effectiveMetadataFollowupSeedApplicable
|
||
? followupSeed.domain
|
||
: null;
|
||
const seededAction = metadataGroundedDocumentFollowupApplicable
|
||
? "list_documents"
|
||
: followupDiscoverySeedApplicable || effectiveMetadataFollowupSeedApplicable
|
||
? followupSeed.action
|
||
: null;
|
||
const seededUnsupported = metadataGroundedDocumentFollowupApplicable
|
||
? "document_evidence"
|
||
: followupDiscoverySeedApplicable || effectiveMetadataFollowupSeedApplicable
|
||
? followupSeed.unsupported
|
||
: null;
|
||
const lifecycleSignal = rawLifecycleSignal || seededDomain === "counterparty_lifecycle";
|
||
const bidirectionalValueFlowSignal = !lifecycleSignal &&
|
||
(rawBidirectionalValueFlowSignal || seededAction === "net_value_flow");
|
||
const valueFlowSignal = !lifecycleSignal && (rawValueFlowSignal || seededDomain === "counterparty_value");
|
||
const payoutSignal = valueFlowSignal &&
|
||
!bidirectionalValueFlowSignal &&
|
||
(rawPayoutSignal || seededAction === "payout");
|
||
const semanticDataNeed = semanticNeedFor({
|
||
domain: rawDomain ?? seededDomain,
|
||
action: rawAction ?? seededAction,
|
||
unsupported: unsupported ?? seededUnsupported,
|
||
lifecycleSignal,
|
||
valueFlowSignal,
|
||
metadataSignal: rawMetadataSignal || effectiveMetadataFollowupSeedApplicable
|
||
});
|
||
const entityCandidates = collectEntityCandidates(assistantTurnMeaning?.explicit_entity_candidates);
|
||
pushUnique(entityCandidates, predecomposeEntities.counterparty);
|
||
pushUnique(entityCandidates, followupSeed.counterparty);
|
||
if ((rawMetadataSignal || metadataFollowupSeedApplicable) && !followupSeed.counterparty) {
|
||
pushUnique(entityCandidates, followupSeed.discoveryEntity);
|
||
}
|
||
if (valueFlowSignal && !predecomposeEntities.counterparty && !followupSeed.counterparty) {
|
||
pushUnique(entityCandidates, predecomposeEntities.organization);
|
||
pushUnique(entityCandidates, followupSeed.organization);
|
||
}
|
||
const explicitOrganizationScope = valueFlowSignal && !predecomposeEntities.counterparty && !followupSeed.counterparty
|
||
? null
|
||
: predecomposeEntities.organization ?? assistantTurnMeaningOrganizationScope ?? followupSeed.organization;
|
||
const explicitDateScope = assistantTurnMeaningDateScope ?? predecomposeDateScope ?? rawDateScope ?? followupSeed.dateScope;
|
||
const turnMeaning = {
|
||
asked_domain_family: lifecycleSignal
|
||
? "counterparty_lifecycle"
|
||
: valueFlowSignal
|
||
? "counterparty_value"
|
||
: metadataGroundedDocumentFollowupApplicable
|
||
? "documents"
|
||
: rawMetadataSignal || effectiveMetadataFollowupSeedApplicable
|
||
? "metadata"
|
||
: rawDomain ?? seededDomain,
|
||
asked_action_family: lifecycleSignal
|
||
? "activity_duration"
|
||
: valueFlowSignal
|
||
? bidirectionalValueFlowSignal
|
||
? "net_value_flow"
|
||
: payoutSignal
|
||
? "payout"
|
||
: rawAction ?? seededAction ?? "turnover"
|
||
: metadataGroundedDocumentFollowupApplicable
|
||
? "list_documents"
|
||
: rawMetadataSignal || effectiveMetadataFollowupSeedApplicable
|
||
? metadataActionFromRawText(rawText) ?? seededAction
|
||
: rawAction ?? seededAction,
|
||
asked_aggregation_axis: monthlyAggregationSignal ? "month" : rawAggregationAxis,
|
||
explicit_entity_candidates: entityCandidates,
|
||
explicit_organization_scope: explicitOrganizationScope,
|
||
explicit_date_scope: explicitDateScope,
|
||
unsupported_but_understood_family: unsupported ??
|
||
(lifecycleSignal
|
||
? "counterparty_lifecycle"
|
||
: valueFlowSignal
|
||
? bidirectionalValueFlowSignal
|
||
? "counterparty_bidirectional_value_flow_or_netting"
|
||
: payoutSignal
|
||
? "counterparty_payouts_or_outflow"
|
||
: seededUnsupported ?? "counterparty_value_or_turnover"
|
||
: metadataGroundedDocumentFollowupApplicable
|
||
? "document_evidence"
|
||
: rawMetadataSignal || effectiveMetadataFollowupSeedApplicable
|
||
? "1c_metadata_surface"
|
||
: followupDiscoverySeedApplicable
|
||
? seededUnsupported
|
||
: null),
|
||
stale_replay_forbidden: Boolean(assistantTurnMeaning?.stale_replay_forbidden ||
|
||
unsupported ||
|
||
lifecycleSignal ||
|
||
valueFlowSignal ||
|
||
metadataGroundedDocumentFollowupApplicable ||
|
||
rawMetadataSignal ||
|
||
effectiveMetadataFollowupSeedApplicable ||
|
||
followupDiscoverySeedApplicable)
|
||
};
|
||
const cleanTurnMeaning = {};
|
||
if (toNonEmptyString(turnMeaning.asked_domain_family)) {
|
||
cleanTurnMeaning.asked_domain_family = turnMeaning.asked_domain_family;
|
||
}
|
||
if (toNonEmptyString(turnMeaning.asked_action_family)) {
|
||
cleanTurnMeaning.asked_action_family = turnMeaning.asked_action_family;
|
||
}
|
||
if (toNonEmptyString(turnMeaning.asked_aggregation_axis)) {
|
||
cleanTurnMeaning.asked_aggregation_axis = turnMeaning.asked_aggregation_axis;
|
||
}
|
||
if ((turnMeaning.explicit_entity_candidates?.length ?? 0) > 0) {
|
||
cleanTurnMeaning.explicit_entity_candidates = turnMeaning.explicit_entity_candidates;
|
||
}
|
||
if (toNonEmptyString(turnMeaning.explicit_organization_scope)) {
|
||
cleanTurnMeaning.explicit_organization_scope = turnMeaning.explicit_organization_scope;
|
||
}
|
||
if (toNonEmptyString(turnMeaning.explicit_date_scope)) {
|
||
cleanTurnMeaning.explicit_date_scope = turnMeaning.explicit_date_scope;
|
||
}
|
||
if (toNonEmptyString(turnMeaning.unsupported_but_understood_family)) {
|
||
cleanTurnMeaning.unsupported_but_understood_family = turnMeaning.unsupported_but_understood_family;
|
||
}
|
||
if (turnMeaning.stale_replay_forbidden) {
|
||
cleanTurnMeaning.stale_replay_forbidden = true;
|
||
}
|
||
const runDiscovery = shouldRunDiscovery({
|
||
unsupported: unsupported ?? seededUnsupported,
|
||
lifecycleSignal,
|
||
valueFlowSignal,
|
||
metadataSignal: rawMetadataSignal || effectiveMetadataFollowupSeedApplicable,
|
||
semanticDataNeed,
|
||
explicitIntentCandidate,
|
||
followupDiscoverySeedApplicable: followupDiscoverySeedApplicable ||
|
||
effectiveMetadataFollowupSeedApplicable ||
|
||
metadataGroundedDocumentFollowupApplicable
|
||
});
|
||
const hasTurnMeaning = Object.keys(cleanTurnMeaning).length > 0;
|
||
const sourceSignal = assistantTurnMeaning
|
||
? "assistant_turn_meaning"
|
||
: followupDiscoverySeedApplicable || effectiveMetadataFollowupSeedApplicable
|
||
? "followup_context"
|
||
: metadataGroundedDocumentFollowupApplicable
|
||
? "followup_context"
|
||
: predecomposeContract
|
||
? "predecompose_contract"
|
||
: lifecycleSignal
|
||
? "raw_text"
|
||
: valueFlowSignal
|
||
? "raw_text"
|
||
: rawMetadataSignal || effectiveMetadataFollowupSeedApplicable
|
||
? "raw_text"
|
||
: "none";
|
||
if (lifecycleSignal) {
|
||
pushReason(reasonCodes, "mcp_discovery_lifecycle_signal_detected");
|
||
}
|
||
if (valueFlowSignal) {
|
||
pushReason(reasonCodes, "mcp_discovery_value_flow_signal_detected");
|
||
}
|
||
if (rawMetadataSignal) {
|
||
pushReason(reasonCodes, "mcp_discovery_metadata_signal_detected");
|
||
}
|
||
if (payoutSignal) {
|
||
pushReason(reasonCodes, "mcp_discovery_payout_signal_detected");
|
||
}
|
||
if (bidirectionalValueFlowSignal) {
|
||
pushReason(reasonCodes, "mcp_discovery_bidirectional_value_flow_signal_detected");
|
||
}
|
||
if (monthlyAggregationSignal) {
|
||
pushReason(reasonCodes, "mcp_discovery_monthly_aggregation_signal_detected");
|
||
}
|
||
if (followupDiscoverySeedApplicable) {
|
||
pushReason(reasonCodes, "mcp_discovery_seeded_from_followup_context");
|
||
}
|
||
if (effectiveMetadataFollowupSeedApplicable) {
|
||
pushReason(reasonCodes, "mcp_discovery_metadata_seeded_from_followup_context");
|
||
}
|
||
if (metadataGroundedDocumentFollowupApplicable) {
|
||
pushReason(reasonCodes, "mcp_discovery_metadata_grounded_document_followup");
|
||
}
|
||
if (unsupported) {
|
||
pushReason(reasonCodes, "mcp_discovery_unsupported_but_understood_turn");
|
||
}
|
||
if (predecomposeEntities.counterparty) {
|
||
pushReason(reasonCodes, "mcp_discovery_counterparty_from_predecompose");
|
||
}
|
||
if (followupSeed.counterparty) {
|
||
pushReason(reasonCodes, "mcp_discovery_counterparty_from_followup_context");
|
||
}
|
||
if (followupSeed.dateScope) {
|
||
pushReason(reasonCodes, "mcp_discovery_date_scope_from_followup_context");
|
||
}
|
||
if (entityCandidates.length > 0) {
|
||
pushReason(reasonCodes, "mcp_discovery_entity_scope_available");
|
||
}
|
||
if (!runDiscovery) {
|
||
pushReason(reasonCodes, "mcp_discovery_not_applicable_for_supported_exact_turn");
|
||
}
|
||
if (runDiscovery && !hasTurnMeaning) {
|
||
pushReason(reasonCodes, "mcp_discovery_turn_meaning_missing");
|
||
}
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_TURN_INPUT_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryTurnInputAdapter",
|
||
adapter_status: !runDiscovery ? "not_applicable" : hasTurnMeaning ? "ready" : "needs_more_context",
|
||
should_run_discovery: runDiscovery,
|
||
semantic_data_need: runDiscovery ? semanticDataNeed : null,
|
||
turn_meaning_ref: runDiscovery && hasTurnMeaning ? cleanTurnMeaning : null,
|
||
source_signal: sourceSignal,
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|