5777 lines
282 KiB
JavaScript
5777 lines
282 KiB
JavaScript
"use strict";
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION = void 0;
|
||
exports.executeAssistantMcpDiscoveryPilot = executeAssistantMcpDiscoveryPilot;
|
||
const addressMcpClient_1 = require("./addressMcpClient");
|
||
const assistantMcpDiscoveryRuntimeAdapter_1 = require("./assistantMcpDiscoveryRuntimeAdapter");
|
||
const assistantMcpDiscoveryPolicy_1 = require("./assistantMcpDiscoveryPolicy");
|
||
const addressRecipeCatalog_1 = require("./addressRecipeCatalog");
|
||
const counterpartyRoleHeuristics_1 = require("./counterpartyRoleHeuristics");
|
||
exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION = "assistant_mcp_discovery_pilot_executor_v1";
|
||
const DEFAULT_DEPS = {
|
||
executeAddressMcpQuery: addressMcpClient_1.executeAddressMcpQuery,
|
||
executeAddressMcpMetadata: addressMcpClient_1.executeAddressMcpMetadata
|
||
};
|
||
const ENTITY_RESOLUTION_COUNTERPARTY_LOOKUP_LIMIT = 1000;
|
||
const ENTITY_RESOLUTION_COUNTERPARTY_QUERY_TEMPLATE = `
|
||
ВЫБРАТЬ ПЕРВЫЕ __LIMIT__
|
||
ПРЕДСТАВЛЕНИЕ(Контрагенты.Ссылка) КАК Контрагент,
|
||
ПРЕДСТАВЛЕНИЕ(Контрагенты.Ссылка) КАК Counterparty,
|
||
Контрагенты.Ссылка КАК КонтрагентСсылка,
|
||
Контрагенты.Ссылка КАК CounterpartyRef,
|
||
Контрагенты.Наименование КАК Наименование
|
||
ИЗ
|
||
Справочник.Контрагенты КАК Контрагенты
|
||
`;
|
||
const ENTITY_RESOLUTION_STOPWORDS = new Set([
|
||
"ооо",
|
||
"ао",
|
||
"зао",
|
||
"ип",
|
||
"llc",
|
||
"ltd",
|
||
"company",
|
||
"контрагент",
|
||
"counterparty",
|
||
"поставщик",
|
||
"supplier",
|
||
"клиент",
|
||
"customer",
|
||
"в",
|
||
"1с",
|
||
"1c",
|
||
"найди",
|
||
"найти",
|
||
"поищи",
|
||
"search",
|
||
"find"
|
||
]);
|
||
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 = value.trim();
|
||
if (text && !target.includes(text)) {
|
||
target.push(text);
|
||
}
|
||
}
|
||
function aggregationAxisForPlanner(planner) {
|
||
const axis = toNonEmptyString(planner.discovery_plan.turn_meaning_ref?.asked_aggregation_axis)?.toLowerCase();
|
||
return axis === "month" ? "month" : null;
|
||
}
|
||
function firstEntityCandidate(planner) {
|
||
const candidates = planner.discovery_plan.turn_meaning_ref?.explicit_entity_candidates ?? [];
|
||
for (const candidate of candidates) {
|
||
const text = toNonEmptyString(candidate);
|
||
if (text) {
|
||
return text;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
function dateScopeToFilters(dateScope) {
|
||
if (!dateScope) {
|
||
return {};
|
||
}
|
||
const yearMatch = dateScope.match(/^(\d{4})$/);
|
||
if (yearMatch) {
|
||
return {
|
||
period_from: `${yearMatch[1]}-01-01`,
|
||
period_to: `${yearMatch[1]}-12-31`
|
||
};
|
||
}
|
||
const rangeMatch = dateScope.match(/^(\d{4}-\d{2}-\d{2})\.\.(\d{4}-\d{2}-\d{2})$/);
|
||
if (rangeMatch) {
|
||
return {
|
||
period_from: rangeMatch[1],
|
||
period_to: rangeMatch[2]
|
||
};
|
||
}
|
||
const dateMatch = dateScope.match(/^(\d{4})-(\d{2})-(\d{2})/);
|
||
if (dateMatch) {
|
||
const date = `${dateMatch[1]}-${dateMatch[2]}-${dateMatch[3]}`;
|
||
return {
|
||
period_from: date,
|
||
period_to: date
|
||
};
|
||
}
|
||
return {};
|
||
}
|
||
function asOfDateFromDateScope(dateScope) {
|
||
if (!dateScope) {
|
||
return null;
|
||
}
|
||
const dateMatch = dateScope.match(/^(\d{4})-(\d{2})-(\d{2})/);
|
||
if (dateMatch) {
|
||
return `${dateMatch[1]}-${dateMatch[2]}-${dateMatch[3]}`;
|
||
}
|
||
const monthMatch = dateScope.match(/^(\d{4})-(\d{2})$/);
|
||
if (monthMatch) {
|
||
const year = Number(monthMatch[1]);
|
||
const month = Number(monthMatch[2]);
|
||
if (Number.isFinite(year) && Number.isFinite(month) && month >= 1 && month <= 12) {
|
||
const lastDay = new Date(Date.UTC(year, month, 0)).getUTCDate();
|
||
return `${monthMatch[1]}-${monthMatch[2]}-${String(lastDay).padStart(2, "0")}`;
|
||
}
|
||
}
|
||
const yearMatch = dateScope.match(/^(\d{4})$/);
|
||
return yearMatch ? `${yearMatch[1]}-12-31` : null;
|
||
}
|
||
function buildLifecycleFilters(planner) {
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const counterparty = firstEntityCandidate(planner);
|
||
const organization = toNonEmptyString(meaning?.explicit_organization_scope);
|
||
const dateScope = toNonEmptyString(meaning?.explicit_date_scope);
|
||
return {
|
||
...dateScopeToFilters(dateScope),
|
||
...(counterparty ? { counterparty } : {}),
|
||
...(organization ? { organization } : {}),
|
||
limit: planner.discovery_plan.execution_budget.max_rows_per_probe,
|
||
sort: "period_asc"
|
||
};
|
||
}
|
||
function buildValueFlowFilters(planner) {
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const counterparty = firstEntityCandidate(planner);
|
||
const organization = toNonEmptyString(meaning?.explicit_organization_scope);
|
||
const dateScope = toNonEmptyString(meaning?.explicit_date_scope);
|
||
return {
|
||
...dateScopeToFilters(dateScope),
|
||
...(counterparty ? { counterparty } : {}),
|
||
...(organization ? { organization } : {}),
|
||
limit: planner.discovery_plan.execution_budget.max_rows_per_probe,
|
||
sort: "period_asc"
|
||
};
|
||
}
|
||
function buildBusinessOverviewProfileFilters(planner) {
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const organization = toNonEmptyString(meaning?.explicit_organization_scope);
|
||
const dateScope = toNonEmptyString(meaning?.explicit_date_scope);
|
||
return {
|
||
...dateScopeToFilters(dateScope),
|
||
...(organization ? { organization } : {}),
|
||
limit: planner.discovery_plan.execution_budget.max_rows_per_probe,
|
||
sort: "period_asc"
|
||
};
|
||
}
|
||
function buildBusinessOverviewTaxFilters(planner) {
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const organization = toNonEmptyString(meaning?.explicit_organization_scope);
|
||
const dateScope = toNonEmptyString(meaning?.explicit_date_scope);
|
||
const periodFilters = dateScopeToFilters(dateScope);
|
||
if (!periodFilters.period_from || !periodFilters.period_to) {
|
||
return null;
|
||
}
|
||
return {
|
||
...periodFilters,
|
||
...(organization ? { organization } : {})
|
||
};
|
||
}
|
||
function buildBusinessOverviewDebtFilters(planner) {
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const organization = toNonEmptyString(meaning?.explicit_organization_scope);
|
||
const dateScope = toNonEmptyString(meaning?.explicit_date_scope);
|
||
const asOfDate = asOfDateFromDateScope(dateScope);
|
||
if (!asOfDate) {
|
||
return null;
|
||
}
|
||
return {
|
||
...dateScopeToFilters(dateScope),
|
||
as_of_date: asOfDate,
|
||
...(organization ? { organization } : {}),
|
||
limit: planner.discovery_plan.execution_budget.max_rows_per_probe,
|
||
sort: "period_asc"
|
||
};
|
||
}
|
||
function shouldRunDebtDueDateAgingProbe(planner) {
|
||
const actionFamily = toNonEmptyString(planner.data_need_graph?.action_family);
|
||
const turnActionFamily = toNonEmptyString(planner.discovery_plan.turn_meaning_ref?.asked_action_family);
|
||
const unsupportedFamily = toNonEmptyString(planner.discovery_plan.turn_meaning_ref?.unsupported_but_understood_family);
|
||
const proofExpectation = toNonEmptyString(planner.data_need_graph?.proof_expectation);
|
||
const combined = [actionFamily, turnActionFamily, unsupportedFamily, proofExpectation]
|
||
.filter((item) => Boolean(item))
|
||
.join(" ");
|
||
return /(?:debt_due_date_boundary|due[-_ ]?date|overdue|aging|просроч|срок\s+оплат|дебиторк|кредиторск)/iu.test(combined);
|
||
}
|
||
function shouldRunInventoryQualityEventsProbe(planner) {
|
||
const actionFamily = toNonEmptyString(planner.data_need_graph?.action_family);
|
||
const turnActionFamily = toNonEmptyString(planner.discovery_plan.turn_meaning_ref?.asked_action_family);
|
||
const unsupportedFamily = toNonEmptyString(planner.discovery_plan.turn_meaning_ref?.unsupported_but_understood_family);
|
||
const proofExpectation = toNonEmptyString(planner.data_need_graph?.proof_expectation);
|
||
const combined = [actionFamily, turnActionFamily, unsupportedFamily, proofExpectation]
|
||
.filter((item) => Boolean(item))
|
||
.join(" ");
|
||
return /(?:inventory_reserve|reserve_liquidation|liquidation|write[-_ ]?off|obsolete|obsolescence|inventory_reserve_liquidation_quality|резерв|списан|ликвидац|неликвид|обесцен)/iu.test(combined);
|
||
}
|
||
function buildBusinessOverviewInventoryFilters(planner) {
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const organization = toNonEmptyString(meaning?.explicit_organization_scope);
|
||
const dateScope = toNonEmptyString(meaning?.explicit_date_scope);
|
||
const asOfDate = asOfDateFromDateScope(dateScope);
|
||
if (!asOfDate) {
|
||
return null;
|
||
}
|
||
return {
|
||
...dateScopeToFilters(dateScope),
|
||
as_of_date: asOfDate,
|
||
...(organization ? { organization } : {}),
|
||
limit: planner.discovery_plan.execution_budget.max_rows_per_probe,
|
||
sort: "period_asc"
|
||
};
|
||
}
|
||
function buildBusinessOverviewTradingMarginFilters(planner) {
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const organization = toNonEmptyString(meaning?.explicit_organization_scope);
|
||
const dateScope = toNonEmptyString(meaning?.explicit_date_scope);
|
||
const periodFilters = dateScopeToFilters(dateScope);
|
||
if (!periodFilters.period_from || !periodFilters.period_to) {
|
||
return null;
|
||
}
|
||
return {
|
||
...periodFilters,
|
||
...(organization ? { organization } : {}),
|
||
limit: planner.discovery_plan.execution_budget.max_rows_per_probe,
|
||
sort: "period_asc"
|
||
};
|
||
}
|
||
function buildBusinessOverviewAccountingFinancialResultFilters(planner) {
|
||
const filters = buildBusinessOverviewTradingMarginFilters(planner);
|
||
if (!filters) {
|
||
return null;
|
||
}
|
||
return {
|
||
...filters,
|
||
limit: Math.max(32, planner.discovery_plan.execution_budget.max_rows_per_probe),
|
||
sort: "period_asc"
|
||
};
|
||
}
|
||
function buildInventoryExactFilters(planner) {
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const subject = firstEntityCandidate(planner);
|
||
const organization = toNonEmptyString(meaning?.explicit_organization_scope);
|
||
const dateScope = toNonEmptyString(meaning?.explicit_date_scope);
|
||
const asOfDate = asOfDateFromDateScope(dateScope);
|
||
const filters = {
|
||
...dateScopeToFilters(dateScope),
|
||
...(asOfDate ? { as_of_date: asOfDate } : {}),
|
||
...(organization ? { organization } : {}),
|
||
limit: planner.discovery_plan.execution_budget.max_rows_per_probe,
|
||
sort: "period_asc"
|
||
};
|
||
if (planner.selected_chain_id === "inventory_purchase_provenance" ||
|
||
planner.selected_chain_id === "inventory_sale_trace") {
|
||
return {
|
||
...filters,
|
||
...(subject ? { item: subject } : {})
|
||
};
|
||
}
|
||
if (planner.selected_chain_id === "inventory_supplier_overlap") {
|
||
return {
|
||
...filters,
|
||
...(subject ? { counterparty: subject } : {})
|
||
};
|
||
}
|
||
return filters;
|
||
}
|
||
function organizationScopeForPlanner(planner) {
|
||
return toNonEmptyString(planner.discovery_plan.turn_meaning_ref?.explicit_organization_scope);
|
||
}
|
||
function rankingNeedForPlanner(planner) {
|
||
const rankingNeed = toNonEmptyString(planner.data_need_graph?.ranking_need)?.toLowerCase();
|
||
if (rankingNeed === "top_desc" || rankingNeed === "bottom_asc") {
|
||
return rankingNeed;
|
||
}
|
||
return null;
|
||
}
|
||
function normalizeEntityResolutionText(value) {
|
||
return String(value ?? "")
|
||
.toLowerCase()
|
||
.replace(/ё/g, "е")
|
||
.replace(/[«»"'`]/g, " ")
|
||
.replace(/[^\p{L}\p{N}\s-]+/gu, " ")
|
||
.replace(/\s+/g, " ")
|
||
.trim();
|
||
}
|
||
function tokenizeEntityResolutionText(value) {
|
||
return normalizeEntityResolutionText(value)
|
||
.split(" ")
|
||
.map((token) => token.trim())
|
||
.filter((token) => token.length >= 2 && !ENTITY_RESOLUTION_STOPWORDS.has(token));
|
||
}
|
||
function isLowQualityEntityResolutionAnchor(value) {
|
||
return tokenizeEntityResolutionText(value).length <= 0;
|
||
}
|
||
function entityResolutionCandidateName(row) {
|
||
const candidates = [
|
||
row["Контрагент"],
|
||
row["Counterparty"],
|
||
row["Наименование"],
|
||
row["name"],
|
||
row["Name"],
|
||
row["registrator"],
|
||
row["Registrator"]
|
||
];
|
||
for (const candidate of candidates) {
|
||
const text = toNonEmptyString(candidate);
|
||
if (text) {
|
||
return text;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
function entityResolutionCandidateRef(row) {
|
||
const candidates = [row["КонтрагентСсылка"], row["CounterpartyRef"], row["ref"], row["Ref"]];
|
||
for (const candidate of candidates) {
|
||
const text = toNonEmptyString(candidate);
|
||
if (text) {
|
||
return text;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
function scoreEntityResolutionCandidate(name, requested) {
|
||
const normalizedName = normalizeEntityResolutionText(name);
|
||
const normalizedRequested = normalizeEntityResolutionText(requested);
|
||
const requestedTokens = tokenizeEntityResolutionText(requested);
|
||
if (!normalizedName || !normalizedRequested || requestedTokens.length <= 0) {
|
||
return null;
|
||
}
|
||
let score = 0;
|
||
if (normalizedName === normalizedRequested) {
|
||
score += 10_000;
|
||
}
|
||
else if (normalizedName.includes(normalizedRequested)) {
|
||
score += 5_000;
|
||
}
|
||
else if (normalizedRequested.includes(normalizedName) && normalizedName.length >= 4) {
|
||
score += 2_000;
|
||
}
|
||
for (const token of requestedTokens) {
|
||
if (!normalizedName.includes(token)) {
|
||
return null;
|
||
}
|
||
score += Math.max(40, token.length * 20);
|
||
}
|
||
score -= Math.abs(normalizedName.length - normalizedRequested.length);
|
||
return score;
|
||
}
|
||
function deriveEntityResolution(result, requestedEntity) {
|
||
if (!result || result.error || !requestedEntity) {
|
||
return null;
|
||
}
|
||
const checkedCandidates = uniqueCandidateStrings(result.raw_rows
|
||
.map((row) => entityResolutionCandidateName(row))
|
||
.filter((value) => Boolean(value)));
|
||
const scoredCandidates = checkedCandidates
|
||
.map((name) => {
|
||
const score = scoreEntityResolutionCandidate(name, requestedEntity);
|
||
return score === null ? null : { name, score };
|
||
})
|
||
.filter((value) => Boolean(value))
|
||
.sort((left, right) => right.score - left.score || left.name.length - right.name.length || left.name.localeCompare(right.name, "ru"));
|
||
if (scoredCandidates.length <= 0) {
|
||
return {
|
||
requested_entity: requestedEntity,
|
||
resolution_status: "not_found",
|
||
resolved_entity: null,
|
||
resolved_reference: null,
|
||
matched_rows: result.rows.length,
|
||
checked_candidates: checkedCandidates.slice(0, 12),
|
||
ambiguity_candidates: [],
|
||
confidence: null,
|
||
inference_basis: "catalog_counterparty_search_rows"
|
||
};
|
||
}
|
||
const bestCandidate = scoredCandidates[0];
|
||
const bestNormalized = normalizeEntityResolutionText(bestCandidate.name);
|
||
const requestedNormalized = normalizeEntityResolutionText(requestedEntity);
|
||
const requestedTokens = tokenizeEntityResolutionText(requestedEntity);
|
||
const exactMatch = bestNormalized === requestedNormalized;
|
||
const strongContains = requestedTokens.length > 1 && bestNormalized.includes(requestedNormalized);
|
||
const topCandidates = scoredCandidates.filter((candidate) => candidate.score === bestCandidate.score);
|
||
if (topCandidates.length > 1 && !exactMatch && !strongContains) {
|
||
return {
|
||
requested_entity: requestedEntity,
|
||
resolution_status: "ambiguous",
|
||
resolved_entity: null,
|
||
resolved_reference: null,
|
||
matched_rows: result.rows.length,
|
||
checked_candidates: checkedCandidates.slice(0, 12),
|
||
ambiguity_candidates: topCandidates.map((candidate) => candidate.name).slice(0, 6),
|
||
confidence: "low",
|
||
inference_basis: "catalog_counterparty_search_rows"
|
||
};
|
||
}
|
||
const matchedRow = result.raw_rows.find((row) => normalizeEntityResolutionText(entityResolutionCandidateName(row)) === bestNormalized) ?? null;
|
||
return {
|
||
requested_entity: requestedEntity,
|
||
resolution_status: "resolved",
|
||
resolved_entity: bestCandidate.name,
|
||
resolved_reference: matchedRow ? entityResolutionCandidateRef(matchedRow) : null,
|
||
matched_rows: result.rows.length,
|
||
checked_candidates: checkedCandidates.slice(0, 12),
|
||
ambiguity_candidates: [],
|
||
confidence: exactMatch ? "high" : strongContains ? "medium" : "low",
|
||
inference_basis: "catalog_counterparty_search_rows"
|
||
};
|
||
}
|
||
function uniqueCandidateStrings(values) {
|
||
const result = [];
|
||
for (const value of values) {
|
||
pushUnique(result, value);
|
||
}
|
||
return result;
|
||
}
|
||
function isLifecyclePilotEligible(planner) {
|
||
if (planner.selected_chain_id === "lifecycle") {
|
||
return true;
|
||
}
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const domain = String(meaning?.asked_domain_family ?? "").toLowerCase();
|
||
const action = String(meaning?.asked_action_family ?? "").toLowerCase();
|
||
const combined = `${domain} ${action}`;
|
||
return (planner.proposed_primitives.includes("query_documents") &&
|
||
(combined.includes("lifecycle") || combined.includes("activity") || combined.includes("duration") || combined.includes("age")));
|
||
}
|
||
function isDocumentEvidencePilotEligible(planner) {
|
||
if (planner.selected_chain_id === "document_evidence") {
|
||
return true;
|
||
}
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const domain = String(meaning?.asked_domain_family ?? "").toLowerCase();
|
||
const action = String(meaning?.asked_action_family ?? "").toLowerCase();
|
||
const unsupported = String(meaning?.unsupported_but_understood_family ?? "").toLowerCase();
|
||
const combined = `${domain} ${action} ${unsupported}`;
|
||
return (planner.proposed_primitives.includes("query_documents") &&
|
||
(combined.includes("document") || combined.includes("list_documents")));
|
||
}
|
||
function isMovementEvidencePilotEligible(planner) {
|
||
if (planner.selected_chain_id === "movement_evidence") {
|
||
return true;
|
||
}
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const domain = String(meaning?.asked_domain_family ?? "").toLowerCase();
|
||
const action = String(meaning?.asked_action_family ?? "").toLowerCase();
|
||
const unsupported = String(meaning?.unsupported_but_understood_family ?? "").toLowerCase();
|
||
const semanticNeed = String(planner.semantic_data_need ?? "").toLowerCase();
|
||
const combined = `${domain} ${action} ${unsupported} ${semanticNeed}`;
|
||
return (planner.proposed_primitives.includes("query_movements") &&
|
||
(combined.includes("movement") ||
|
||
combined.includes("movements") ||
|
||
combined.includes("bank_operations") ||
|
||
combined.includes("movement_evidence") ||
|
||
combined.includes("list_movements")));
|
||
}
|
||
function isValueFlowPilotEligible(planner) {
|
||
if (planner.selected_chain_id === "value_flow" ||
|
||
planner.selected_chain_id === "value_flow_ranking" ||
|
||
planner.selected_chain_id === "value_flow_comparison") {
|
||
return true;
|
||
}
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const domain = String(meaning?.asked_domain_family ?? "").toLowerCase();
|
||
const action = String(meaning?.asked_action_family ?? "").toLowerCase();
|
||
const unsupported = String(meaning?.unsupported_but_understood_family ?? "").toLowerCase();
|
||
const combined = `${domain} ${action} ${unsupported}`;
|
||
return (planner.proposed_primitives.includes("query_movements") &&
|
||
(combined.includes("turnover") ||
|
||
combined.includes("revenue") ||
|
||
combined.includes("payment") ||
|
||
combined.includes("payout") ||
|
||
combined.includes("value")));
|
||
}
|
||
function isBusinessOverviewPilotEligible(planner) {
|
||
return planner.selected_chain_id === "business_overview";
|
||
}
|
||
function isInventoryPilotEligible(planner) {
|
||
return (planner.selected_chain_id === "inventory_stock_snapshot" ||
|
||
planner.selected_chain_id === "inventory_supplier_overlap" ||
|
||
planner.selected_chain_id === "inventory_purchase_provenance" ||
|
||
planner.selected_chain_id === "inventory_sale_trace");
|
||
}
|
||
function isMetadataPilotEligible(planner) {
|
||
if (planner.selected_chain_id === "metadata_inspection" ||
|
||
planner.selected_chain_id === "metadata_lane_clarification" ||
|
||
planner.selected_chain_id === "catalog_drilldown") {
|
||
return true;
|
||
}
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const domain = String(meaning?.asked_domain_family ?? "").toLowerCase();
|
||
const action = String(meaning?.asked_action_family ?? "").toLowerCase();
|
||
const unsupported = String(meaning?.unsupported_but_understood_family ?? "").toLowerCase();
|
||
const semanticNeed = String(planner.semantic_data_need ?? "").toLowerCase();
|
||
const combined = `${domain} ${action} ${unsupported} ${semanticNeed}`;
|
||
return (planner.proposed_primitives.includes("inspect_1c_metadata") &&
|
||
(combined.includes("metadata") ||
|
||
combined.includes("schema") ||
|
||
combined.includes("catalog") ||
|
||
combined.includes("inspect_documents") ||
|
||
combined.includes("inspect_registers") ||
|
||
combined.includes("inspect_fields")));
|
||
}
|
||
function isEntityResolutionPilotEligible(planner) {
|
||
if (planner.selected_chain_id === "entity_resolution") {
|
||
return true;
|
||
}
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const domain = String(meaning?.asked_domain_family ?? "").toLowerCase();
|
||
const action = String(meaning?.asked_action_family ?? "").toLowerCase();
|
||
const unsupported = String(meaning?.unsupported_but_understood_family ?? "").toLowerCase();
|
||
const semanticNeed = String(planner.semantic_data_need ?? "").toLowerCase();
|
||
const combined = `${domain} ${action} ${unsupported} ${semanticNeed}`;
|
||
return (planner.proposed_primitives.includes("search_business_entity") &&
|
||
(combined.includes("entity_resolution") ||
|
||
combined.includes("search_business_entity") ||
|
||
combined.includes("entity discovery") ||
|
||
combined.includes("counterparty search")));
|
||
}
|
||
function metadataScopeForPlanner(planner) {
|
||
const entityCandidate = firstEntityCandidate(planner);
|
||
if (entityCandidate) {
|
||
return entityCandidate;
|
||
}
|
||
if (planner.selected_chain_id === "catalog_drilldown") {
|
||
const surface = planner.metadata_surface_ref;
|
||
const scopeCandidate = [
|
||
...(surface?.selected_surface_objects ?? []),
|
||
surface?.selected_entity_set ?? ""
|
||
]
|
||
.map((value) => toNonEmptyString(value))
|
||
.filter((value) => Boolean(value))
|
||
.map((value) => {
|
||
const parts = value.split(".").map((item) => item.trim()).filter((item) => item.length > 0);
|
||
return parts.length > 0 ? parts[parts.length - 1] ?? value : value;
|
||
})
|
||
.find((value) => value.length > 0);
|
||
if (scopeCandidate) {
|
||
return scopeCandidate;
|
||
}
|
||
}
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const combined = `${meaning?.asked_domain_family ?? ""} ${meaning?.asked_action_family ?? ""} ${meaning?.unsupported_but_understood_family ?? ""}`
|
||
.toLowerCase()
|
||
.trim();
|
||
if (combined.includes("vat")) {
|
||
return "НДС";
|
||
}
|
||
if (combined.includes("inventory")) {
|
||
return "склад";
|
||
}
|
||
if (combined.includes("counterparty")) {
|
||
return "контрагент";
|
||
}
|
||
return null;
|
||
}
|
||
function metadataTypesForPlanner(planner) {
|
||
if (planner.selected_chain_id === "catalog_drilldown") {
|
||
const selectedEntitySet = toNonEmptyString(planner.metadata_surface_ref?.selected_entity_set);
|
||
if (selectedEntitySet) {
|
||
return [selectedEntitySet];
|
||
}
|
||
}
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const action = String(meaning?.asked_action_family ?? "").toLowerCase();
|
||
if (action === "inspect_registers") {
|
||
return ["РегистрНакопления", "РегистрСведений"];
|
||
}
|
||
if (action === "inspect_documents") {
|
||
return ["Документ"];
|
||
}
|
||
if (action === "inspect_catalog") {
|
||
return ["Справочник"];
|
||
}
|
||
return ["Документ", "РегистрНакопления", "РегистрСведений", "Справочник"];
|
||
}
|
||
function metadataScopeRankingAllowedForPlanner(planner) {
|
||
const action = String(planner.discovery_plan.turn_meaning_ref?.asked_action_family ?? "").toLowerCase().trim();
|
||
return action === "inspect_surface";
|
||
}
|
||
function valueFlowPilotProfile(planner) {
|
||
const meaning = planner.discovery_plan.turn_meaning_ref;
|
||
const action = String(meaning?.asked_action_family ?? "").toLowerCase();
|
||
const unsupported = String(meaning?.unsupported_but_understood_family ?? "").toLowerCase();
|
||
const combined = `${action} ${unsupported}`;
|
||
if (combined.includes("net_value_flow") ||
|
||
combined.includes("bidirectional") ||
|
||
combined.includes("netting") ||
|
||
combined.includes("net")) {
|
||
return {
|
||
scope: "counterparty_bidirectional_value_flow_query_movements_v1",
|
||
recipe_intent: null,
|
||
direction: "bidirectional_net_value_flow"
|
||
};
|
||
}
|
||
if (combined.includes("payout") ||
|
||
combined.includes("outflow") ||
|
||
combined.includes("supplier") ||
|
||
combined.includes("paid")) {
|
||
return {
|
||
scope: "counterparty_supplier_payout_query_movements_v1",
|
||
recipe_intent: "supplier_payouts_profile",
|
||
direction: "outgoing_supplier_payout"
|
||
};
|
||
}
|
||
return {
|
||
scope: "counterparty_value_flow_query_movements_v1",
|
||
recipe_intent: "customer_revenue_and_payments",
|
||
direction: "incoming_customer_revenue"
|
||
};
|
||
}
|
||
function inventoryIntentForPlanner(planner) {
|
||
switch (planner.selected_chain_id) {
|
||
case "inventory_stock_snapshot":
|
||
return "inventory_on_hand_as_of_date";
|
||
case "inventory_supplier_overlap":
|
||
return "inventory_supplier_stock_overlap_as_of_date";
|
||
case "inventory_purchase_provenance":
|
||
return "inventory_purchase_provenance_for_item";
|
||
case "inventory_sale_trace":
|
||
return "inventory_sale_trace_for_item";
|
||
default:
|
||
return null;
|
||
}
|
||
}
|
||
function inventoryExecutablePrimitiveForPlanner(planner) {
|
||
switch (planner.selected_chain_id) {
|
||
case "inventory_stock_snapshot":
|
||
case "inventory_supplier_overlap":
|
||
return "query_movements";
|
||
case "inventory_purchase_provenance":
|
||
case "inventory_sale_trace":
|
||
return "query_documents";
|
||
default:
|
||
return null;
|
||
}
|
||
}
|
||
function skippedProbeResult(step, limitation) {
|
||
return {
|
||
primitive_id: step.primitive_id,
|
||
status: "skipped",
|
||
rows_received: 0,
|
||
rows_matched: 0,
|
||
limitation
|
||
};
|
||
}
|
||
function queryResultToProbeResult(primitiveId, result) {
|
||
return {
|
||
primitive_id: primitiveId,
|
||
status: result.error ? "error" : "ok",
|
||
rows_received: result.fetched_rows,
|
||
rows_matched: result.matched_rows,
|
||
limitation: result.error
|
||
};
|
||
}
|
||
function metadataResultToProbeResult(primitiveId, result) {
|
||
return {
|
||
primitive_id: primitiveId,
|
||
status: result.error ? "error" : "ok",
|
||
rows_received: result.fetched_rows,
|
||
rows_matched: result.error ? 0 : result.rows.length,
|
||
limitation: result.error
|
||
};
|
||
}
|
||
function toCoverageAwareQueryResult(result, options = {}) {
|
||
if (!result) {
|
||
return null;
|
||
}
|
||
return {
|
||
...result,
|
||
coverage_limited_by_probe_limit: options.coverageLimitedByProbeLimit ?? false,
|
||
coverage_recovered_by_period_chunking: options.coverageRecoveredByPeriodChunking ?? false,
|
||
period_chunking_granularity: options.periodChunkingGranularity ?? null,
|
||
period_chunk_count: options.periodChunkCount ?? 0
|
||
};
|
||
}
|
||
function monthWindowsForYear(year) {
|
||
const result = [];
|
||
for (let month = 0; month < 12; month += 1) {
|
||
const start = new Date(Date.UTC(Number(year), month, 1));
|
||
const end = new Date(Date.UTC(Number(year), month + 1, 0));
|
||
result.push({
|
||
period_from: `${start.getUTCFullYear()}-${String(start.getUTCMonth() + 1).padStart(2, "0")}-${String(start.getUTCDate()).padStart(2, "0")}`,
|
||
period_to: `${end.getUTCFullYear()}-${String(end.getUTCMonth() + 1).padStart(2, "0")}-${String(end.getUTCDate()).padStart(2, "0")}`
|
||
});
|
||
}
|
||
return result;
|
||
}
|
||
function periodWindowsForDateScope(dateScope) {
|
||
const yearMatch = dateScope?.match(/^(\d{4})$/);
|
||
if (yearMatch) {
|
||
return monthWindowsForYear(yearMatch[1]);
|
||
}
|
||
return [];
|
||
}
|
||
function mergeCoverageAwareQueryResults(results, options) {
|
||
const rawRows = results.flatMap((item) => item.raw_rows);
|
||
const rows = results.flatMap((item) => item.rows);
|
||
const errors = results.map((item) => toNonEmptyString(item.error)).filter((item) => Boolean(item));
|
||
return {
|
||
fetched_rows: results.reduce((sum, item) => sum + item.fetched_rows, 0),
|
||
matched_rows: results.reduce((sum, item) => sum + item.matched_rows, 0),
|
||
raw_rows: rawRows,
|
||
rows,
|
||
error: errors[0] ?? null,
|
||
coverage_limited_by_probe_limit: options.coverageLimitedByProbeLimit,
|
||
coverage_recovered_by_period_chunking: options.coverageRecoveredByPeriodChunking,
|
||
period_chunking_granularity: options.periodChunkingGranularity,
|
||
period_chunk_count: options.periodChunkCount
|
||
};
|
||
}
|
||
async function executeCoverageAwareValueFlowQuery(input) {
|
||
const queryLimitations = [];
|
||
const probeResults = [];
|
||
let executedProbeCount = 0;
|
||
const broadRecipePlan = input.recipePlanBuilder(input.baseFilters);
|
||
const broadResult = await input.deps.executeAddressMcpQuery({
|
||
query: broadRecipePlan.query,
|
||
limit: broadRecipePlan.limit,
|
||
account_scope: broadRecipePlan.account_scope
|
||
});
|
||
executedProbeCount += 1;
|
||
probeResults.push(queryResultToProbeResult(input.primitiveId, broadResult));
|
||
const broadLimitThreshold = Math.max(1, Math.min(input.maxRowsPerProbe, broadRecipePlan.limit));
|
||
const broadCoverageLimited = !broadResult.error && broadResult.matched_rows >= broadLimitThreshold;
|
||
if (broadResult.error) {
|
||
pushUnique(queryLimitations, broadResult.error);
|
||
return {
|
||
result: toCoverageAwareQueryResult(broadResult, {
|
||
coverageLimitedByProbeLimit: false
|
||
}),
|
||
probe_results: probeResults,
|
||
query_limitations: queryLimitations,
|
||
executed_probe_count: executedProbeCount
|
||
};
|
||
}
|
||
const periodWindows = periodWindowsForDateScope(input.dateScope);
|
||
if (!broadCoverageLimited || periodWindows.length === 0) {
|
||
return {
|
||
result: toCoverageAwareQueryResult(broadResult, {
|
||
coverageLimitedByProbeLimit: broadCoverageLimited
|
||
}),
|
||
probe_results: probeResults,
|
||
query_limitations: queryLimitations,
|
||
executed_probe_count: executedProbeCount
|
||
};
|
||
}
|
||
const requiredChunkProbeCount = periodWindows.length;
|
||
if (executedProbeCount + requiredChunkProbeCount > input.maxProbeCount) {
|
||
pushUnique(queryLimitations, "Requested period hit the MCP row limit, but the approved monthly recovery probe budget is smaller than the required subperiod count");
|
||
return {
|
||
result: toCoverageAwareQueryResult(broadResult, {
|
||
coverageLimitedByProbeLimit: true
|
||
}),
|
||
probe_results: probeResults,
|
||
query_limitations: queryLimitations,
|
||
executed_probe_count: executedProbeCount
|
||
};
|
||
}
|
||
const chunkResults = [];
|
||
let anyChunkLimited = false;
|
||
let anyChunkError = false;
|
||
for (const window of periodWindows) {
|
||
const chunkFilters = {
|
||
...input.baseFilters,
|
||
period_from: window.period_from,
|
||
period_to: window.period_to
|
||
};
|
||
const chunkPlan = input.recipePlanBuilder(chunkFilters);
|
||
const chunkResult = await input.deps.executeAddressMcpQuery({
|
||
query: chunkPlan.query,
|
||
limit: chunkPlan.limit,
|
||
account_scope: chunkPlan.account_scope
|
||
});
|
||
executedProbeCount += 1;
|
||
probeResults.push(queryResultToProbeResult(input.primitiveId, chunkResult));
|
||
if (chunkResult.error) {
|
||
anyChunkError = true;
|
||
pushUnique(queryLimitations, chunkResult.error);
|
||
continue;
|
||
}
|
||
const chunkLimitThreshold = Math.max(1, Math.min(input.maxRowsPerProbe, chunkPlan.limit));
|
||
if (chunkResult.matched_rows >= chunkLimitThreshold) {
|
||
anyChunkLimited = true;
|
||
}
|
||
chunkResults.push(chunkResult);
|
||
}
|
||
if (chunkResults.length === 0 && anyChunkError) {
|
||
return {
|
||
result: toCoverageAwareQueryResult(broadResult, {
|
||
coverageLimitedByProbeLimit: true
|
||
}),
|
||
probe_results: probeResults,
|
||
query_limitations: queryLimitations,
|
||
executed_probe_count: executedProbeCount
|
||
};
|
||
}
|
||
return {
|
||
result: mergeCoverageAwareQueryResults(chunkResults, {
|
||
coverageLimitedByProbeLimit: anyChunkLimited || anyChunkError,
|
||
coverageRecoveredByPeriodChunking: true,
|
||
periodChunkingGranularity: "month",
|
||
periodChunkCount: periodWindows.length
|
||
}),
|
||
probe_results: probeResults,
|
||
query_limitations: queryLimitations,
|
||
executed_probe_count: executedProbeCount
|
||
};
|
||
}
|
||
function summarizeLifecycleRows(result) {
|
||
if (result.error) {
|
||
return null;
|
||
}
|
||
if (result.fetched_rows <= 0) {
|
||
return "0 MCP document rows fetched";
|
||
}
|
||
return `${result.fetched_rows} MCP document rows fetched, ${result.matched_rows} matched lifecycle scope`;
|
||
}
|
||
function summarizeDocumentRows(result) {
|
||
if (result.error) {
|
||
return null;
|
||
}
|
||
if (result.fetched_rows <= 0) {
|
||
return "0 MCP document rows fetched";
|
||
}
|
||
return `${result.fetched_rows} MCP document rows fetched, ${result.matched_rows} matched document scope`;
|
||
}
|
||
function summarizeMovementRows(result) {
|
||
if (result.error) {
|
||
return null;
|
||
}
|
||
if (result.fetched_rows <= 0) {
|
||
return "0 MCP movement rows fetched";
|
||
}
|
||
return `${result.fetched_rows} MCP movement rows fetched, ${result.matched_rows} matched movement scope`;
|
||
}
|
||
function summarizeValueFlowRows(result) {
|
||
if (result.error) {
|
||
return null;
|
||
}
|
||
if (result.fetched_rows <= 0) {
|
||
return "0 MCP value-flow rows fetched";
|
||
}
|
||
if (result.coverage_recovered_by_period_chunking && result.period_chunking_granularity === "month") {
|
||
return `${result.period_chunk_count} monthly MCP value-flow probes fetched ${result.fetched_rows} rows total, ${result.matched_rows} matched value-flow scope after the broad probe hit the row limit`;
|
||
}
|
||
return `${result.fetched_rows} MCP value-flow rows fetched, ${result.matched_rows} matched value-flow scope`;
|
||
}
|
||
function summarizeInventoryRows(result) {
|
||
if (result.error) {
|
||
return null;
|
||
}
|
||
if (result.fetched_rows <= 0) {
|
||
return "0 MCP inventory exact rows fetched";
|
||
}
|
||
return `${result.fetched_rows} MCP inventory exact rows fetched, ${result.matched_rows} matched inventory scope`;
|
||
}
|
||
function summarizeMetadataRows(result) {
|
||
if (result.error) {
|
||
return null;
|
||
}
|
||
if (result.fetched_rows <= 0) {
|
||
return "0 MCP metadata rows fetched";
|
||
}
|
||
return `${result.fetched_rows} MCP metadata rows fetched`;
|
||
}
|
||
function summarizeEntityResolutionRows(result) {
|
||
if (result.error) {
|
||
return null;
|
||
}
|
||
if (result.fetched_rows <= 0) {
|
||
return "0 MCP catalog rows fetched";
|
||
}
|
||
return `${result.fetched_rows} MCP catalog rows fetched for entity search`;
|
||
}
|
||
function entityResolutionFollowupStepLimitation() {
|
||
return "Entity-resolution could not continue because the checked catalog search step did not return a confirmed slice";
|
||
}
|
||
function buildEntityResolutionResolveProbeResult(input) {
|
||
if (!input.resolution) {
|
||
return {
|
||
primitive_id: "resolve_entity_reference",
|
||
status: "ok",
|
||
rows_received: input.queryResult.fetched_rows,
|
||
rows_matched: 0,
|
||
limitation: null
|
||
};
|
||
}
|
||
if (input.resolution.resolution_status === "resolved") {
|
||
return {
|
||
primitive_id: "resolve_entity_reference",
|
||
status: "ok",
|
||
rows_received: input.queryResult.fetched_rows,
|
||
rows_matched: 1,
|
||
limitation: null
|
||
};
|
||
}
|
||
return {
|
||
primitive_id: "resolve_entity_reference",
|
||
status: "ok",
|
||
rows_received: input.queryResult.fetched_rows,
|
||
rows_matched: 0,
|
||
limitation: null
|
||
};
|
||
}
|
||
function buildEntityResolutionCoverageProbeResult(input) {
|
||
const resolved = input.resolution?.resolution_status === "resolved";
|
||
return {
|
||
primitive_id: "probe_coverage",
|
||
status: "ok",
|
||
rows_received: 1,
|
||
rows_matched: resolved ? 1 : 0,
|
||
limitation: null
|
||
};
|
||
}
|
||
function metadataRowText(row, keys) {
|
||
for (const key of keys) {
|
||
const text = toNonEmptyString(row[key]);
|
||
if (text) {
|
||
return text;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
function metadataObjectName(row) {
|
||
return metadataRowText(row, [
|
||
"ПолноеИмя",
|
||
"full_name",
|
||
"FullName",
|
||
"Имя",
|
||
"name",
|
||
"Name",
|
||
"presentation",
|
||
"Представление",
|
||
"synonym",
|
||
"Synonym"
|
||
]);
|
||
}
|
||
function metadataEntitySet(row) {
|
||
return metadataRowText(row, [
|
||
"ТипМетаданных",
|
||
"type",
|
||
"Type",
|
||
"meta_type",
|
||
"MetaType",
|
||
"ВидМетаданных",
|
||
"kind"
|
||
]);
|
||
}
|
||
function inferMetadataEntitySetFromObjectName(objectName) {
|
||
const text = String(objectName ?? "").trim();
|
||
if (!text) {
|
||
return null;
|
||
}
|
||
const dotIndex = text.indexOf(".");
|
||
if (dotIndex <= 0) {
|
||
return null;
|
||
}
|
||
const entitySet = text.slice(0, dotIndex).trim();
|
||
return entitySet.length > 0 ? entitySet : null;
|
||
}
|
||
function metadataChildNames(value) {
|
||
if (!Array.isArray(value)) {
|
||
return [];
|
||
}
|
||
const result = [];
|
||
for (const item of value) {
|
||
if (!item || typeof item !== "object" || Array.isArray(item)) {
|
||
continue;
|
||
}
|
||
const record = item;
|
||
const fieldName = metadataRowText(record, ["Имя", "name", "Name", "full_name", "FullName"]);
|
||
if (fieldName) {
|
||
pushUnique(result, fieldName);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
function metadataAvailableFields(rows) {
|
||
const result = [];
|
||
for (const row of rows) {
|
||
for (const field of metadataChildNames(row["Реквизиты"])) {
|
||
pushUnique(result, field);
|
||
}
|
||
for (const field of metadataChildNames(row["attributes"])) {
|
||
pushUnique(result, field);
|
||
}
|
||
for (const field of metadataChildNames(row["Attributes"])) {
|
||
pushUnique(result, field);
|
||
}
|
||
for (const field of metadataChildNames(row["Измерения"])) {
|
||
pushUnique(result, field);
|
||
}
|
||
for (const field of metadataChildNames(row["dimensions"])) {
|
||
pushUnique(result, field);
|
||
}
|
||
for (const field of metadataChildNames(row["Ресурсы"])) {
|
||
pushUnique(result, field);
|
||
}
|
||
for (const field of metadataChildNames(row["resources"])) {
|
||
pushUnique(result, field);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
function normalizeMetadataEntitySetToken(value) {
|
||
return String(value ?? "")
|
||
.toLowerCase()
|
||
.replace(/[\s_.-]+/g, "");
|
||
}
|
||
function metadataMatchesRequestedType(entitySet, requestedMetaType) {
|
||
const entityToken = normalizeMetadataEntitySetToken(entitySet);
|
||
const requestedToken = normalizeMetadataEntitySetToken(requestedMetaType);
|
||
return entityToken.includes(requestedToken) || requestedToken.includes(entityToken);
|
||
}
|
||
function metadataRouteFamilyForEntitySet(entitySet) {
|
||
const token = normalizeMetadataEntitySetToken(entitySet);
|
||
if (token.includes("документ") || token.includes("document")) {
|
||
return "document_evidence";
|
||
}
|
||
if (token.includes("регистрнакопления") ||
|
||
token.includes("регистсведений") ||
|
||
token.includes("регистрсведений") ||
|
||
token.includes("accumulationregister") ||
|
||
token.includes("informationregister")) {
|
||
return "movement_evidence";
|
||
}
|
||
if (token.includes("справочник") || token.includes("catalog") || token.includes("directory")) {
|
||
return "catalog_drilldown";
|
||
}
|
||
return null;
|
||
}
|
||
function metadataRouteFamilyForEntitySetRelaxed(entitySet) {
|
||
const strict = metadataRouteFamilyForEntitySet(entitySet);
|
||
if (strict) {
|
||
return strict;
|
||
}
|
||
const raw = String(entitySet ?? "").trim();
|
||
if (!raw) {
|
||
return null;
|
||
}
|
||
if (raw.includes("Документ") || raw.includes("Документ")) {
|
||
return "document_evidence";
|
||
}
|
||
if (raw.includes("РегистрНакопления") ||
|
||
raw.includes("РегистрСведений") ||
|
||
raw.includes("РегистрНакопления") ||
|
||
raw.includes("РегистрСведений")) {
|
||
return "movement_evidence";
|
||
}
|
||
if (raw.includes("Справочник") || raw.includes("Справочник")) {
|
||
return "catalog_drilldown";
|
||
}
|
||
return null;
|
||
}
|
||
function metadataNextPrimitiveForRouteFamily(routeFamily) {
|
||
if (routeFamily === "document_evidence") {
|
||
return "query_documents";
|
||
}
|
||
if (routeFamily === "movement_evidence") {
|
||
return "query_movements";
|
||
}
|
||
if (routeFamily === "catalog_drilldown") {
|
||
return "drilldown_related_objects";
|
||
}
|
||
return null;
|
||
}
|
||
function selectMetadataEntityGrounding(availableEntitySets, requestedMetaTypes) {
|
||
const requestedMatches = availableEntitySets.filter((entitySet) => requestedMetaTypes.some((requestedMetaType) => metadataMatchesRequestedType(entitySet, requestedMetaType)));
|
||
if (requestedMatches.length === 1) {
|
||
return {
|
||
selectedEntitySet: requestedMatches[0] ?? null,
|
||
ambiguityDetected: false,
|
||
ambiguityEntitySets: []
|
||
};
|
||
}
|
||
if (requestedMatches.length > 1) {
|
||
return {
|
||
selectedEntitySet: null,
|
||
ambiguityDetected: true,
|
||
ambiguityEntitySets: requestedMatches
|
||
};
|
||
}
|
||
if (availableEntitySets.length === 1) {
|
||
return {
|
||
selectedEntitySet: availableEntitySets[0] ?? null,
|
||
ambiguityDetected: false,
|
||
ambiguityEntitySets: []
|
||
};
|
||
}
|
||
return {
|
||
selectedEntitySet: null,
|
||
ambiguityDetected: availableEntitySets.length > 1,
|
||
ambiguityEntitySets: availableEntitySets
|
||
};
|
||
}
|
||
function metadataObjectsForEntitySet(entitySet, matchedObjects) {
|
||
if (!entitySet) {
|
||
return [];
|
||
}
|
||
return matchedObjects.filter((item) => item.startsWith(`${entitySet}.`) || item.includes(entitySet));
|
||
}
|
||
function emptyMetadataSurfaceFamilyScores() {
|
||
return {
|
||
document_evidence: 0,
|
||
movement_evidence: 0,
|
||
catalog_drilldown: 0
|
||
};
|
||
}
|
||
function metadataSurfaceFamilyScores(matchedObjects) {
|
||
const scores = emptyMetadataSurfaceFamilyScores();
|
||
for (const objectName of matchedObjects) {
|
||
const entitySet = inferMetadataEntitySetFromObjectName(objectName);
|
||
const routeFamily = entitySet ? metadataRouteFamilyForEntitySetRelaxed(entitySet) : null;
|
||
if (routeFamily) {
|
||
scores[routeFamily] += 1;
|
||
}
|
||
}
|
||
return scores;
|
||
}
|
||
function normalizeMetadataObjectRankingToken(value) {
|
||
return String(value ?? "")
|
||
.toLowerCase()
|
||
.replace(/[^\p{L}\p{N}]+/gu, "");
|
||
}
|
||
function metadataScopeRankingTokens(metadataScope) {
|
||
const scope = String(metadataScope ?? "").trim();
|
||
if (!scope) {
|
||
return [];
|
||
}
|
||
const condensed = normalizeMetadataObjectRankingToken(scope);
|
||
const result = [];
|
||
if (condensed.length >= 2) {
|
||
pushUnique(result, condensed);
|
||
}
|
||
for (const token of scope.toLowerCase().split(/[^\p{L}\p{N}]+/gu)) {
|
||
const normalized = normalizeMetadataObjectRankingToken(token);
|
||
if (normalized.length >= 2) {
|
||
pushUnique(result, normalized);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
function metadataObjectRelevanceScore(metadataScope, objectName) {
|
||
const objectToken = normalizeMetadataObjectRankingToken(objectName);
|
||
if (!objectToken) {
|
||
return 1;
|
||
}
|
||
let score = 1;
|
||
for (const token of metadataScopeRankingTokens(metadataScope)) {
|
||
if (objectToken.includes(token)) {
|
||
score += token.length >= 6 ? 4 : 3;
|
||
}
|
||
}
|
||
return score;
|
||
}
|
||
function metadataWeightedSurfaceFamilyScores(matchedObjects, metadataScope) {
|
||
const scores = emptyMetadataSurfaceFamilyScores();
|
||
for (const objectName of matchedObjects) {
|
||
const entitySet = inferMetadataEntitySetFromObjectName(objectName);
|
||
const routeFamily = entitySet ? metadataRouteFamilyForEntitySetRelaxed(entitySet) : null;
|
||
if (routeFamily) {
|
||
scores[routeFamily] += metadataObjectRelevanceScore(metadataScope, objectName);
|
||
}
|
||
}
|
||
return scores;
|
||
}
|
||
function sortMetadataObjectsByRelevance(matchedObjects, metadataScope) {
|
||
return [...matchedObjects].sort((left, right) => {
|
||
const scoreDelta = metadataObjectRelevanceScore(metadataScope, right) - metadataObjectRelevanceScore(metadataScope, left);
|
||
if (scoreDelta !== 0) {
|
||
return scoreDelta;
|
||
}
|
||
return left.localeCompare(right, "ru");
|
||
});
|
||
}
|
||
function metadataObjectsForRouteFamily(routeFamily, matchedObjects, metadataScope) {
|
||
if (!routeFamily) {
|
||
return [];
|
||
}
|
||
const filtered = matchedObjects.filter((objectName) => {
|
||
const entitySet = inferMetadataEntitySetFromObjectName(objectName);
|
||
return entitySet ? metadataRouteFamilyForEntitySetRelaxed(entitySet) === routeFamily : false;
|
||
});
|
||
return sortMetadataObjectsByRelevance(filtered, metadataScope);
|
||
}
|
||
function selectDominantMetadataRouteFamilyFromScores(scores) {
|
||
const ranked = Object.entries(scores)
|
||
.filter(([, score]) => score > 0)
|
||
.sort((left, right) => right[1] - left[1]);
|
||
const top = ranked[0];
|
||
const second = ranked[1];
|
||
if (!top) {
|
||
return null;
|
||
}
|
||
if (!second) {
|
||
return top[0];
|
||
}
|
||
const absoluteMargin = top[1] - second[1];
|
||
const relativeRatio = second[1] > 0 ? top[1] / second[1] : Number.POSITIVE_INFINITY;
|
||
const clearlyDominant = absoluteMargin >= 2 || relativeRatio >= 1.5;
|
||
return clearlyDominant ? top[0] : null;
|
||
}
|
||
function selectMetadataRouteFamilyFromSurfaceScores(input) {
|
||
const countDominant = selectDominantMetadataRouteFamilyFromScores(input.countScores);
|
||
if (countDominant) {
|
||
return {
|
||
routeFamily: countDominant,
|
||
rankingApplied: false
|
||
};
|
||
}
|
||
if (!input.allowScopeRanking) {
|
||
return {
|
||
routeFamily: null,
|
||
rankingApplied: false
|
||
};
|
||
}
|
||
const rankedCounts = Object.entries(input.countScores)
|
||
.filter(([, score]) => score > 0)
|
||
.sort((left, right) => right[1] - left[1]);
|
||
const topCount = rankedCounts[0]?.[1] ?? 0;
|
||
const secondCount = rankedCounts[1]?.[1] ?? 0;
|
||
if (topCount <= 0 || topCount !== secondCount) {
|
||
return {
|
||
routeFamily: null,
|
||
rankingApplied: false
|
||
};
|
||
}
|
||
const weightedScores = metadataWeightedSurfaceFamilyScores(input.matchedObjects, input.metadataScope);
|
||
const weightedDominant = selectDominantMetadataRouteFamilyFromScores(weightedScores);
|
||
return {
|
||
routeFamily: weightedDominant,
|
||
rankingApplied: Boolean(weightedDominant)
|
||
};
|
||
}
|
||
function deriveMetadataSurface(result, metadataScope, requestedMetaTypes, allowScopeRanking) {
|
||
if (!result || result.error || result.rows.length <= 0) {
|
||
return null;
|
||
}
|
||
const matchedObjects = [];
|
||
const availableEntitySets = [];
|
||
for (const row of result.rows) {
|
||
const objectName = metadataObjectName(row);
|
||
if (objectName) {
|
||
pushUnique(matchedObjects, objectName);
|
||
}
|
||
const entitySet = metadataEntitySet(row) ?? inferMetadataEntitySetFromObjectName(objectName);
|
||
if (entitySet) {
|
||
pushUnique(availableEntitySets, entitySet);
|
||
}
|
||
}
|
||
const grounding = selectMetadataEntityGrounding(availableEntitySets, requestedMetaTypes);
|
||
const surfaceFamilyScores = metadataSurfaceFamilyScores(matchedObjects);
|
||
const selectedEntitySetRouteFamily = grounding.selectedEntitySet
|
||
? metadataRouteFamilyForEntitySetRelaxed(grounding.selectedEntitySet)
|
||
: null;
|
||
const scoredRouteSelection = selectedEntitySetRouteFamily === null
|
||
? selectMetadataRouteFamilyFromSurfaceScores({
|
||
matchedObjects,
|
||
metadataScope,
|
||
countScores: surfaceFamilyScores,
|
||
allowScopeRanking
|
||
})
|
||
: { routeFamily: null, rankingApplied: false };
|
||
const scoredRouteFamily = scoredRouteSelection.routeFamily;
|
||
const downstreamRouteFamily = selectedEntitySetRouteFamily ?? scoredRouteFamily;
|
||
const routeFamilySelectionBasis = selectedEntitySetRouteFamily
|
||
? "selected_entity_set"
|
||
: scoredRouteFamily
|
||
? "dominant_surface_objects"
|
||
: null;
|
||
const selectedSurfaceObjects = grounding.selectedEntitySet !== null
|
||
? sortMetadataObjectsByRelevance(metadataObjectsForEntitySet(grounding.selectedEntitySet, matchedObjects), metadataScope)
|
||
: metadataObjectsForRouteFamily(downstreamRouteFamily, matchedObjects, metadataScope);
|
||
const knownLimitations = [];
|
||
const ambiguityRemainsUnresolved = grounding.ambiguityDetected && !downstreamRouteFamily;
|
||
if (ambiguityRemainsUnresolved && grounding.ambiguityEntitySets.length > 0) {
|
||
knownLimitations.push(`Exact downstream metadata surface remains ambiguous across: ${grounding.ambiguityEntitySets.join(", ")}`);
|
||
}
|
||
if (grounding.ambiguityDetected && downstreamRouteFamily && routeFamilySelectionBasis === "dominant_surface_objects") {
|
||
knownLimitations.push(`Metadata surface spans multiple object sets, but dominant confirmed objects point to ${downstreamRouteFamily}`);
|
||
}
|
||
return {
|
||
metadata_scope: metadataScope,
|
||
requested_meta_types: requestedMetaTypes,
|
||
matched_rows: result.rows.length,
|
||
available_entity_sets: availableEntitySets,
|
||
matched_objects: matchedObjects,
|
||
selected_entity_set: grounding.selectedEntitySet,
|
||
selected_surface_objects: selectedSurfaceObjects,
|
||
surface_family_scores: surfaceFamilyScores,
|
||
downstream_route_family: downstreamRouteFamily,
|
||
route_family_selection_basis: routeFamilySelectionBasis,
|
||
recommended_next_primitive: metadataNextPrimitiveForRouteFamily(downstreamRouteFamily),
|
||
ambiguity_detected: ambiguityRemainsUnresolved,
|
||
ambiguity_entity_sets: ambiguityRemainsUnresolved ? grounding.ambiguityEntitySets : [],
|
||
surface_object_ranking_applied: scoredRouteSelection.rankingApplied,
|
||
available_fields: metadataAvailableFields(result.rows),
|
||
known_limitations: knownLimitations,
|
||
inference_basis: "confirmed_1c_metadata_surface_rows"
|
||
};
|
||
}
|
||
function buildMetadataConfirmedFacts(surface) {
|
||
if (!surface) {
|
||
return [];
|
||
}
|
||
const facts = [];
|
||
const scopeSuffix = surface.metadata_scope ? ` for ${surface.metadata_scope}` : "";
|
||
facts.push(`Confirmed 1C metadata surface${scopeSuffix}: ${surface.matched_rows} rows and ${surface.matched_objects.length} matching objects`);
|
||
if (surface.available_entity_sets.length > 0) {
|
||
facts.push(`Available metadata object sets: ${surface.available_entity_sets.join(", ")}`);
|
||
}
|
||
if (surface.selected_entity_set) {
|
||
facts.push(`Selected metadata entity set: ${surface.selected_entity_set}`);
|
||
}
|
||
if (surface.selected_surface_objects.length > 0) {
|
||
facts.push(`Selected metadata objects: ${surface.selected_surface_objects.slice(0, 8).join(", ")}`);
|
||
}
|
||
if (surface.surface_family_scores.document_evidence > 0 ||
|
||
surface.surface_family_scores.movement_evidence > 0 ||
|
||
surface.surface_family_scores.catalog_drilldown > 0) {
|
||
facts.push(`Metadata surface family scores: document=${surface.surface_family_scores.document_evidence}, movement=${surface.surface_family_scores.movement_evidence}, catalog=${surface.surface_family_scores.catalog_drilldown}`);
|
||
}
|
||
if (surface.available_fields.length > 0) {
|
||
facts.push(`Available metadata fields/sections: ${surface.available_fields.slice(0, 12).join(", ")}`);
|
||
}
|
||
return facts;
|
||
}
|
||
function buildMetadataInferredFacts(surface) {
|
||
if (!surface || !surface.downstream_route_family || !surface.recommended_next_primitive) {
|
||
return [];
|
||
}
|
||
return [
|
||
`A likely next checked lane may be inferred as ${surface.downstream_route_family} from the confirmed metadata surface`
|
||
];
|
||
}
|
||
function buildMetadataUnknownFacts(surface, metadataScope) {
|
||
if (surface) {
|
||
if (surface.ambiguity_detected && surface.ambiguity_entity_sets.length > 0) {
|
||
return [...surface.known_limitations];
|
||
}
|
||
if (surface.available_fields.length > 0) {
|
||
return [];
|
||
}
|
||
return ["Detailed metadata fields were not returned by this MCP metadata probe"];
|
||
}
|
||
if (metadataScope) {
|
||
return [`No matching 1C metadata objects were confirmed for scope "${metadataScope}"`];
|
||
}
|
||
return ["No matching 1C metadata objects were confirmed by this MCP metadata probe"];
|
||
}
|
||
function buildEntityResolutionConfirmedFacts(resolution) {
|
||
if (!resolution || resolution.resolution_status !== "resolved" || !resolution.resolved_entity) {
|
||
return [];
|
||
}
|
||
if (resolution.requested_entity && normalizeEntityResolutionText(resolution.requested_entity) === normalizeEntityResolutionText(resolution.resolved_entity)) {
|
||
return [`В проверенном каталожном срезе 1С найден контрагент: ${resolution.resolved_entity}`];
|
||
}
|
||
return [
|
||
`В проверенном каталожном срезе 1С найден наиболее вероятный контрагент: ${resolution.resolved_entity}`
|
||
];
|
||
}
|
||
function buildEntityResolutionInferredFacts(resolution) {
|
||
if (!resolution) {
|
||
return [];
|
||
}
|
||
if (resolution.resolution_status === "resolved") {
|
||
const facts = ["Пока проверено только заземление сущности по каталогу 1С; документы, движения и денежные показатели еще не проверялись"];
|
||
if (resolution.requested_entity && resolution.resolved_entity) {
|
||
const requestedNormalized = normalizeEntityResolutionText(resolution.requested_entity);
|
||
const resolvedNormalized = normalizeEntityResolutionText(resolution.resolved_entity);
|
||
if (requestedNormalized !== resolvedNormalized) {
|
||
facts.push("Контрагент выбран как ближайшее подтвержденное совпадение имени в проверенном каталоге 1С");
|
||
}
|
||
}
|
||
return facts;
|
||
}
|
||
if (resolution.resolution_status === "ambiguous") {
|
||
return ["В проверенном каталожном срезе осталось несколько близких кандидатов, поэтому точного контрагента в 1С еще нужно уточнить"];
|
||
}
|
||
return [];
|
||
}
|
||
function buildEntityResolutionUnknownFacts(resolution, requestedEntity) {
|
||
if (!resolution) {
|
||
return ["По проверенному каталожному поиску 1С не удалось заземлить сущность контрагента"];
|
||
}
|
||
const unknownFacts = ["Документы, движения и денежные показатели по этому контрагенту еще не проверялись; пока был только каталожный поиск"];
|
||
if (resolution.resolution_status === "ambiguous" && resolution.ambiguity_candidates.length > 0) {
|
||
unknownFacts.unshift(`Точное заземление контрагента в 1С остается неоднозначным между вариантами: ${resolution.ambiguity_candidates.join(", ")}`);
|
||
return unknownFacts;
|
||
}
|
||
if (resolution.resolution_status === "not_found") {
|
||
unknownFacts.unshift(requestedEntity
|
||
? `В проверенном каталожном срезе 1С не подтвержден контрагент с именем "${requestedEntity}"`
|
||
: "В проверенном каталожном срезе 1С не подтвержден подходящий контрагент");
|
||
}
|
||
return unknownFacts;
|
||
}
|
||
function rowDateValue(row) {
|
||
const candidates = [
|
||
row["Период"],
|
||
row["Period"],
|
||
row["period"],
|
||
row["Дата"],
|
||
row["Date"],
|
||
row["date"]
|
||
];
|
||
for (const candidate of candidates) {
|
||
const text = toNonEmptyString(candidate);
|
||
const match = text?.match(/(\d{4})-(\d{2})-(\d{2})/);
|
||
if (match) {
|
||
return `${match[1]}-${match[2]}-${match[3]}`;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
function rowAmountValue(row) {
|
||
const candidates = [
|
||
row["Сумма"],
|
||
row["РЎСѓРјРјР°"],
|
||
row["СуммаДокумента"],
|
||
row["СуммаДокумента"],
|
||
row["Amount"],
|
||
row["amount"],
|
||
row["Total"],
|
||
row["total"]
|
||
];
|
||
for (const candidate of candidates) {
|
||
if (typeof candidate === "number" && Number.isFinite(candidate)) {
|
||
return candidate;
|
||
}
|
||
const text = toNonEmptyString(candidate);
|
||
if (!text) {
|
||
continue;
|
||
}
|
||
const normalized = text
|
||
.replace(/\s+/g, "")
|
||
.replace(/\u00a0/g, "")
|
||
.replace(",", ".")
|
||
.replace(/[^\d.-]/g, "");
|
||
const parsed = Number(normalized);
|
||
if (Number.isFinite(parsed)) {
|
||
return parsed;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
function rowNumberValue(row, keys) {
|
||
for (const key of keys) {
|
||
const candidate = row[key];
|
||
if (typeof candidate === "number" && Number.isFinite(candidate)) {
|
||
return candidate;
|
||
}
|
||
const text = toNonEmptyString(candidate);
|
||
if (!text) {
|
||
continue;
|
||
}
|
||
const normalized = text
|
||
.replace(/\s+/g, "")
|
||
.replace(/\u00a0/g, "")
|
||
.replace(",", ".")
|
||
.replace(/[^\d.-]/g, "");
|
||
const parsed = Number(normalized);
|
||
if (Number.isFinite(parsed)) {
|
||
return parsed;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
function rowTextValue(row, keys) {
|
||
for (const key of keys) {
|
||
const text = toNonEmptyString(row[key]);
|
||
if (text) {
|
||
return text;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
function rowInventoryItemValue(row) {
|
||
return rowTextValue(row, ["Номенклатура", "Item", "item", "Товар", "Product", "product"]);
|
||
}
|
||
function rowWarehouseValue(row) {
|
||
return rowTextValue(row, ["Склад", "Warehouse", "warehouse"]);
|
||
}
|
||
function rowDocumentValue(row) {
|
||
return rowTextValue(row, ["Регистратор", "Registrator", "registrator", "Документ", "Document", "document"]);
|
||
}
|
||
function rowAccountValue(row) {
|
||
return rowTextValue(row, ["СчетДт", "AccountDt", "account_dt", "Счет", "Account", "account"]);
|
||
}
|
||
function rowDebitAccountValue(row) {
|
||
return rowTextValue(row, ["СчетДт", "AccountDt", "account_dt", "DebitAccount", "debit_account"]);
|
||
}
|
||
function rowCreditAccountValue(row) {
|
||
return rowTextValue(row, ["СчетКт", "AccountKt", "account_kt", "CreditAccount", "credit_account"]);
|
||
}
|
||
function accountTextMatchesPrefix(account, prefixes) {
|
||
const normalized = String(account ?? "").replace(/\s+/g, "");
|
||
return prefixes.some((prefix) => normalized.startsWith(prefix));
|
||
}
|
||
function rowQuantityValue(row) {
|
||
return rowNumberValue(row, ["Количество", "Quantity", "quantity", "Qty", "qty", "Остаток", "Balance", "balance"]);
|
||
}
|
||
function rowAnalyticsTextValues(row) {
|
||
const values = [];
|
||
const analytics = row["analytics"];
|
||
if (Array.isArray(analytics)) {
|
||
for (const item of analytics) {
|
||
const text = toNonEmptyString(item);
|
||
if (text && !values.includes(text)) {
|
||
values.push(text);
|
||
}
|
||
}
|
||
}
|
||
for (const key of [
|
||
"СубконтоДт1",
|
||
"СубконтоДт2",
|
||
"СубконтоДт3",
|
||
"СубконтоКт1",
|
||
"СубконтоКт2",
|
||
"СубконтоКт3",
|
||
"SubcontoDt1",
|
||
"SubcontoDt2",
|
||
"SubcontoDt3",
|
||
"SubcontoKt1",
|
||
"SubcontoKt2",
|
||
"SubcontoKt3"
|
||
]) {
|
||
const text = toNonEmptyString(row[key]);
|
||
if (text && !values.includes(text)) {
|
||
values.push(text);
|
||
}
|
||
}
|
||
return values;
|
||
}
|
||
function isEmptyAnalyticToken(value) {
|
||
return /^(?:0|<пусто>|пустая ссылка)$/iu.test(value.trim());
|
||
}
|
||
function isLikelyContractToken(value) {
|
||
const normalized = value.trim();
|
||
if (!normalized || isEmptyAnalyticToken(normalized)) {
|
||
return false;
|
||
}
|
||
if (/(?:договор|contract|дог\.)/iu.test(normalized)) {
|
||
return true;
|
||
}
|
||
if (/^\d{4}-\d{2}-\d{2}/.test(normalized)) {
|
||
return false;
|
||
}
|
||
return normalized.length >= 3 && /[\\/]/.test(normalized);
|
||
}
|
||
function isLikelyCounterpartyToken(value) {
|
||
const normalized = value.trim();
|
||
if (!normalized || isEmptyAnalyticToken(normalized)) {
|
||
return false;
|
||
}
|
||
if (/^\d{4}-\d{2}-\d{2}/.test(normalized)) {
|
||
return false;
|
||
}
|
||
if (/^\d+(?:[./-]\d+)*$/.test(normalized)) {
|
||
return false;
|
||
}
|
||
if (!/[a-zа-я]/iu.test(normalized)) {
|
||
return false;
|
||
}
|
||
if (/(?:договор|contract|дог\.|документ|операц|счет[-\s]?фактур|накладн|акт|поступлен|списани|плат[её]ж|банк|касса|movement|invoice|payment)/iu.test(normalized)) {
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
function rowContractValue(row) {
|
||
const explicit = rowTextValue(row, ["Договор", "Contract", "contract"]);
|
||
if (explicit && !isEmptyAnalyticToken(explicit)) {
|
||
return explicit;
|
||
}
|
||
return rowAnalyticsTextValues(row).find(isLikelyContractToken) ?? null;
|
||
}
|
||
function rowCounterpartyValue(row) {
|
||
const candidates = [row["Контрагент"], row["Counterparty"], row["counterparty"], row["Наименование"], row["name"]];
|
||
for (const candidate of candidates) {
|
||
const text = toNonEmptyString(candidate);
|
||
if (text) {
|
||
return text;
|
||
}
|
||
}
|
||
return rowAnalyticsTextValues(row).find(isLikelyCounterpartyToken) ?? null;
|
||
}
|
||
const FINANCIAL_FLOW_HINTS = [
|
||
"loan_or_credit",
|
||
"bank_fee_or_service",
|
||
"tax_or_budget",
|
||
"payroll_or_social",
|
||
"supplier_payment",
|
||
"unclear"
|
||
];
|
||
function normalizeFinancialFlowText(value) {
|
||
return String(value ?? "")
|
||
.toLowerCase()
|
||
.replace(/ё/g, "е")
|
||
.replace(/\s+/g, " ")
|
||
.trim();
|
||
}
|
||
function rowFinancialFlowCorpus(row) {
|
||
return [
|
||
rowTextValue(row, ["ВидОперации", "OperationType", "operation_type"]),
|
||
rowTextValue(row, ["НазначениеПлатежа", "PaymentPurpose", "payment_purpose"]),
|
||
rowTextValue(row, ["Комментарий", "Comment", "comment"]),
|
||
rowContractValue(row),
|
||
rowDocumentValue(row)
|
||
]
|
||
.map(normalizeFinancialFlowText)
|
||
.filter(Boolean)
|
||
.join(" ");
|
||
}
|
||
function classifyRowFinancialFlowHint(row) {
|
||
const corpus = rowFinancialFlowCorpus(row);
|
||
if (!corpus) {
|
||
return "unclear";
|
||
}
|
||
if (/(?:кредит|кредитн|заем|займ|овердрафт|процент|ссуд|депозит|loan|credit|overdraft|deposit)/iu.test(corpus)) {
|
||
return "loan_or_credit";
|
||
}
|
||
if (/(?:комисс|эквайр|расчетн[оа -]*кассов|ведение\s+счет|банк[а-я\s-]*услуг|банковск[а-я\s-]*услуг|рко|bank\s*fee|acquiring|bank\s*service)/iu.test(corpus)) {
|
||
return "bank_fee_or_service";
|
||
}
|
||
if (/(?:налог|взнос|фсс|фомс|пфр|бюджет|казнач|пен[ия]|штраф|tax|budget|treasury)/iu.test(corpus)) {
|
||
return "tax_or_budget";
|
||
}
|
||
if (/(?:зарплат|заработн|перечислениезаработнойплаты|salary|payroll|wage)/iu.test(corpus)) {
|
||
return "payroll_or_social";
|
||
}
|
||
if (/(?:оплатапоставщику|оплата\s+поставщ|поставщ|supplier|vendor)/iu.test(corpus)) {
|
||
return "supplier_payment";
|
||
}
|
||
return "unclear";
|
||
}
|
||
function createFinancialFlowHintCounts() {
|
||
return {
|
||
loan_or_credit: 0,
|
||
bank_fee_or_service: 0,
|
||
tax_or_budget: 0,
|
||
payroll_or_social: 0,
|
||
supplier_payment: 0,
|
||
unclear: 0
|
||
};
|
||
}
|
||
function dominantFinancialFlowHint(counts) {
|
||
let bestHint = null;
|
||
let bestRows = 0;
|
||
for (const hint of FINANCIAL_FLOW_HINTS) {
|
||
const rows = counts[hint] ?? 0;
|
||
if (rows > bestRows) {
|
||
bestHint = hint;
|
||
bestRows = rows;
|
||
}
|
||
}
|
||
if (!bestHint || bestRows <= 0 || bestHint === "unclear") {
|
||
return { hint: null, rows: 0 };
|
||
}
|
||
return { hint: bestHint, rows: bestRows };
|
||
}
|
||
function normalizeDateParts(yearText, monthText, dayText) {
|
||
const year = Number(yearText);
|
||
const month = Number(monthText);
|
||
const day = Number(dayText);
|
||
if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day)) {
|
||
return null;
|
||
}
|
||
if (year < 1900 || year > 2100 || month < 1 || month > 12 || day < 1 || day > 31) {
|
||
return null;
|
||
}
|
||
const date = new Date(Date.UTC(year, month - 1, day));
|
||
if (date.getUTCFullYear() !== year ||
|
||
date.getUTCMonth() !== month - 1 ||
|
||
date.getUTCDate() !== day) {
|
||
return null;
|
||
}
|
||
return [
|
||
String(year).padStart(4, "0"),
|
||
String(month).padStart(2, "0"),
|
||
String(day).padStart(2, "0")
|
||
].join("-");
|
||
}
|
||
function extractContractDateFromText(value) {
|
||
const text = toNonEmptyString(value);
|
||
if (!text || !/(?:договор|contract|дог\.)/iu.test(text)) {
|
||
return null;
|
||
}
|
||
return extractAnyDateFromText(text);
|
||
}
|
||
function extractAnyDateFromText(value) {
|
||
const text = toNonEmptyString(value);
|
||
if (!text) {
|
||
return null;
|
||
}
|
||
const isoLikeMatch = text.match(/(\d{4})[-./](\d{1,2})[-./](\d{1,2})/);
|
||
if (isoLikeMatch) {
|
||
return normalizeDateParts(isoLikeMatch[1], isoLikeMatch[2], isoLikeMatch[3]);
|
||
}
|
||
const ruDateMatch = text.match(/(\d{1,2})[./-](\d{1,2})[./-](\d{4})/);
|
||
if (ruDateMatch) {
|
||
return normalizeDateParts(ruDateMatch[3], ruDateMatch[2], ruDateMatch[1]);
|
||
}
|
||
return null;
|
||
}
|
||
function rowContractDateValue(row) {
|
||
const explicit = rowTextValue(row, ["ДатаДоговора", "ContractDate", "contract_date"]);
|
||
return extractAnyDateFromText(explicit) ?? rowOpenSettlementContractStartDateValue(row);
|
||
}
|
||
function rowSettlementDocumentDateValue(row) {
|
||
const explicit = rowTextValue(row, [
|
||
"ДатаДокументаРасчетов",
|
||
"SettlementDocumentDate",
|
||
"settlement_document_date"
|
||
]);
|
||
const settlementDocument = rowTextValue(row, [
|
||
"ДокументРасчетов",
|
||
"SettlementDocument",
|
||
"settlement_document"
|
||
]);
|
||
return extractAnyDateFromText(explicit) ?? extractAnyDateFromText(settlementDocument) ?? extractAnyDateFromText(rowDocumentValue(row));
|
||
}
|
||
function rowPaymentTermIsSetValue(row) {
|
||
const candidate = rowTextValue(row, ["УстановленСрокОплаты", "PaymentTermIsSet", "payment_term_is_set"]);
|
||
if (typeof row["УстановленСрокОплаты"] === "boolean") {
|
||
return row["УстановленСрокОплаты"] === true;
|
||
}
|
||
if (typeof row["PaymentTermIsSet"] === "boolean") {
|
||
return row["PaymentTermIsSet"] === true;
|
||
}
|
||
if (!candidate) {
|
||
return false;
|
||
}
|
||
return /^(?:true|истина|да|yes|1)$/iu.test(candidate.trim());
|
||
}
|
||
function rowPaymentTermDaysValue(row) {
|
||
const value = rowNumberValue(row, ["СрокОплаты", "PaymentTermDays", "payment_term_days"]);
|
||
if (value === null || !Number.isFinite(value) || value <= 0) {
|
||
return null;
|
||
}
|
||
return Math.trunc(value);
|
||
}
|
||
function addDaysToIsoDate(isoDate, days) {
|
||
const match = isoDate.match(/^(\d{4})-(\d{2})-(\d{2})$/);
|
||
if (!match || !Number.isFinite(days)) {
|
||
return null;
|
||
}
|
||
const date = new Date(Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3])));
|
||
date.setUTCDate(date.getUTCDate() + Math.trunc(days));
|
||
if (Number.isNaN(date.getTime())) {
|
||
return null;
|
||
}
|
||
return [
|
||
String(date.getUTCFullYear()).padStart(4, "0"),
|
||
String(date.getUTCMonth() + 1).padStart(2, "0"),
|
||
String(date.getUTCDate()).padStart(2, "0")
|
||
].join("-");
|
||
}
|
||
function earlierIsoDate(left, right) {
|
||
if (!left) {
|
||
return right;
|
||
}
|
||
if (!right) {
|
||
return left;
|
||
}
|
||
return right < left ? right : left;
|
||
}
|
||
function rowOpenSettlementContractStartDateValue(row) {
|
||
const candidates = [
|
||
rowContractValue(row),
|
||
rowDocumentValue(row),
|
||
...rowAnalyticsTextValues(row)
|
||
];
|
||
for (const candidate of candidates) {
|
||
const contractDate = extractContractDateFromText(candidate);
|
||
if (contractDate) {
|
||
return contractDate;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
function monthBucketFromIsoDate(isoDate) {
|
||
const match = isoDate?.match(/^(\d{4})-(\d{2})-\d{2}$/);
|
||
return match ? `${match[1]}-${match[2]}` : null;
|
||
}
|
||
function yearBucketFromIsoDate(isoDate) {
|
||
const match = isoDate?.match(/^(\d{4})-\d{2}-\d{2}$/);
|
||
return match ? match[1] : null;
|
||
}
|
||
function netDirectionFromAmount(amount) {
|
||
if (amount > 0) {
|
||
return "net_incoming";
|
||
}
|
||
if (amount < 0) {
|
||
return "net_outgoing";
|
||
}
|
||
return "balanced";
|
||
}
|
||
function monthDiff(firstIsoDate, latestIsoDate) {
|
||
const first = new Date(`${firstIsoDate}T00:00:00.000Z`);
|
||
const latest = new Date(`${latestIsoDate}T00:00:00.000Z`);
|
||
if (Number.isNaN(first.getTime()) || Number.isNaN(latest.getTime()) || latest < first) {
|
||
return 0;
|
||
}
|
||
let months = (latest.getUTCFullYear() - first.getUTCFullYear()) * 12;
|
||
months += latest.getUTCMonth() - first.getUTCMonth();
|
||
if (latest.getUTCDate() < first.getUTCDate()) {
|
||
months -= 1;
|
||
}
|
||
return Math.max(0, months);
|
||
}
|
||
function formatDurationHumanRu(totalMonths) {
|
||
const years = Math.floor(totalMonths / 12);
|
||
const months = totalMonths % 12;
|
||
const parts = [];
|
||
if (years > 0) {
|
||
parts.push(`${years} ${years === 1 ? "год" : years >= 2 && years <= 4 ? "года" : "лет"}`);
|
||
}
|
||
if (months > 0) {
|
||
parts.push(`${months} ${months === 1 ? "месяц" : months >= 2 && months <= 4 ? "месяца" : "месяцев"}`);
|
||
}
|
||
return parts.length > 0 ? parts.join(" ") : "меньше месяца";
|
||
}
|
||
function deriveActivityPeriod(result) {
|
||
if (!result || result.error || result.matched_rows <= 0) {
|
||
return null;
|
||
}
|
||
const dates = result.rows
|
||
.map((row) => rowDateValue(row))
|
||
.filter((value) => Boolean(value))
|
||
.sort();
|
||
if (dates.length === 0) {
|
||
return null;
|
||
}
|
||
const first = dates[0];
|
||
const latest = dates[dates.length - 1];
|
||
const totalMonths = monthDiff(first, latest);
|
||
return {
|
||
first_activity_date: first,
|
||
latest_activity_date: latest,
|
||
matched_rows: result.matched_rows,
|
||
duration_total_months: totalMonths,
|
||
duration_years: Math.floor(totalMonths / 12),
|
||
duration_months_remainder: totalMonths % 12,
|
||
duration_human_ru: formatDurationHumanRu(totalMonths),
|
||
inference_basis: "first_and_latest_confirmed_1c_activity_rows"
|
||
};
|
||
}
|
||
function formatAmountHumanRu(amount) {
|
||
const formatted = new Intl.NumberFormat("ru-RU", {
|
||
maximumFractionDigits: 2,
|
||
minimumFractionDigits: Number.isInteger(amount) ? 0 : 2
|
||
})
|
||
.format(amount)
|
||
.replace(/\u00a0/g, " ");
|
||
return `${formatted} руб.`;
|
||
}
|
||
function yearCountHumanRu(count) {
|
||
const abs = Math.abs(count) % 100;
|
||
const last = abs % 10;
|
||
const noun = abs >= 11 && abs <= 14
|
||
? "лет"
|
||
: last === 1
|
||
? "год"
|
||
: last >= 2 && last <= 4
|
||
? "года"
|
||
: "лет";
|
||
return `${count} ${noun}`;
|
||
}
|
||
function deriveValueFlowMonthBreakdown(result, aggregationAxis) {
|
||
if (!result || result.error || aggregationAxis !== "month") {
|
||
return [];
|
||
}
|
||
const buckets = new Map();
|
||
for (const row of result.rows) {
|
||
const isoDate = rowDateValue(row);
|
||
const monthBucket = monthBucketFromIsoDate(isoDate);
|
||
const amount = rowAmountValue(row);
|
||
if (!monthBucket || amount === null) {
|
||
continue;
|
||
}
|
||
const current = buckets.get(monthBucket) ?? { rows_with_amount: 0, total_amount: 0 };
|
||
current.rows_with_amount += 1;
|
||
current.total_amount += amount;
|
||
buckets.set(monthBucket, current);
|
||
}
|
||
return Array.from(buckets.entries())
|
||
.sort(([left], [right]) => left.localeCompare(right))
|
||
.map(([monthBucket, bucket]) => ({
|
||
month_bucket: monthBucket,
|
||
rows_with_amount: bucket.rows_with_amount,
|
||
total_amount: bucket.total_amount,
|
||
total_amount_human_ru: formatAmountHumanRu(bucket.total_amount)
|
||
}));
|
||
}
|
||
function deriveBidirectionalValueFlowMonthBreakdown(input) {
|
||
if (input.aggregationAxis !== "month") {
|
||
return [];
|
||
}
|
||
const incomingBuckets = deriveValueFlowMonthBreakdown(input.incomingResult, "month");
|
||
const outgoingBuckets = deriveValueFlowMonthBreakdown(input.outgoingResult, "month");
|
||
const allMonthBuckets = new Set();
|
||
for (const bucket of incomingBuckets) {
|
||
allMonthBuckets.add(bucket.month_bucket);
|
||
}
|
||
for (const bucket of outgoingBuckets) {
|
||
allMonthBuckets.add(bucket.month_bucket);
|
||
}
|
||
const incomingByMonth = new Map(incomingBuckets.map((bucket) => [bucket.month_bucket, bucket]));
|
||
const outgoingByMonth = new Map(outgoingBuckets.map((bucket) => [bucket.month_bucket, bucket]));
|
||
return Array.from(allMonthBuckets)
|
||
.sort((left, right) => left.localeCompare(right))
|
||
.map((monthBucket) => {
|
||
const incoming = incomingByMonth.get(monthBucket);
|
||
const outgoing = outgoingByMonth.get(monthBucket);
|
||
const incomingAmount = incoming?.total_amount ?? 0;
|
||
const outgoingAmount = outgoing?.total_amount ?? 0;
|
||
const netAmount = incomingAmount - outgoingAmount;
|
||
return {
|
||
month_bucket: monthBucket,
|
||
incoming_total_amount: incomingAmount,
|
||
incoming_total_amount_human_ru: formatAmountHumanRu(incomingAmount),
|
||
incoming_rows_with_amount: incoming?.rows_with_amount ?? 0,
|
||
outgoing_total_amount: outgoingAmount,
|
||
outgoing_total_amount_human_ru: formatAmountHumanRu(outgoingAmount),
|
||
outgoing_rows_with_amount: outgoing?.rows_with_amount ?? 0,
|
||
net_amount: netAmount,
|
||
net_amount_human_ru: formatAmountHumanRu(Math.abs(netAmount)),
|
||
net_direction: netDirectionFromAmount(netAmount)
|
||
};
|
||
});
|
||
}
|
||
function deriveBusinessOverviewSideYearBreakdown(result) {
|
||
if (!result || result.error) {
|
||
return [];
|
||
}
|
||
const buckets = new Map();
|
||
for (const row of result.rows) {
|
||
const yearBucket = yearBucketFromIsoDate(rowDateValue(row));
|
||
const amount = rowAmountValue(row);
|
||
if (!yearBucket || amount === null) {
|
||
continue;
|
||
}
|
||
const current = buckets.get(yearBucket) ?? { rows_with_amount: 0, total_amount: 0 };
|
||
current.rows_with_amount += 1;
|
||
current.total_amount += amount;
|
||
buckets.set(yearBucket, current);
|
||
}
|
||
return Array.from(buckets.entries())
|
||
.sort(([left], [right]) => left.localeCompare(right))
|
||
.map(([yearBucket, bucket]) => ({
|
||
year_bucket: yearBucket,
|
||
rows_with_amount: bucket.rows_with_amount,
|
||
total_amount: bucket.total_amount,
|
||
total_amount_human_ru: formatAmountHumanRu(bucket.total_amount)
|
||
}));
|
||
}
|
||
function deriveBusinessOverviewYearlyBreakdown(input) {
|
||
const incomingBuckets = deriveBusinessOverviewSideYearBreakdown(input.incomingResult);
|
||
const outgoingBuckets = deriveBusinessOverviewSideYearBreakdown(input.outgoingResult);
|
||
const allYearBuckets = new Set();
|
||
for (const bucket of incomingBuckets) {
|
||
allYearBuckets.add(bucket.year_bucket);
|
||
}
|
||
for (const bucket of outgoingBuckets) {
|
||
allYearBuckets.add(bucket.year_bucket);
|
||
}
|
||
const incomingByYear = new Map(incomingBuckets.map((bucket) => [bucket.year_bucket, bucket]));
|
||
const outgoingByYear = new Map(outgoingBuckets.map((bucket) => [bucket.year_bucket, bucket]));
|
||
return Array.from(allYearBuckets)
|
||
.sort((left, right) => left.localeCompare(right))
|
||
.map((yearBucket) => {
|
||
const incoming = incomingByYear.get(yearBucket);
|
||
const outgoing = outgoingByYear.get(yearBucket);
|
||
const incomingAmount = incoming?.total_amount ?? 0;
|
||
const outgoingAmount = outgoing?.total_amount ?? 0;
|
||
const netAmount = incomingAmount - outgoingAmount;
|
||
return {
|
||
year_bucket: yearBucket,
|
||
incoming_total_amount: incomingAmount,
|
||
incoming_total_amount_human_ru: formatAmountHumanRu(incomingAmount),
|
||
incoming_rows_with_amount: incoming?.rows_with_amount ?? 0,
|
||
outgoing_total_amount: outgoingAmount,
|
||
outgoing_total_amount_human_ru: formatAmountHumanRu(outgoingAmount),
|
||
outgoing_rows_with_amount: outgoing?.rows_with_amount ?? 0,
|
||
net_amount: netAmount,
|
||
net_amount_human_ru: formatAmountHumanRu(Math.abs(netAmount)),
|
||
net_direction: netDirectionFromAmount(netAmount)
|
||
};
|
||
});
|
||
}
|
||
function normalizeBusinessOverviewActivityMarker(row) {
|
||
const marker = toNonEmptyString(rowDocumentValue(row));
|
||
return marker ? marker.trim().toUpperCase() : null;
|
||
}
|
||
function normalizeBusinessOverviewAccountSection(value) {
|
||
const normalized = String(value ?? "").replace(/\s+/g, "").trim();
|
||
if (!normalized) {
|
||
return null;
|
||
}
|
||
const sectionMatch = normalized.match(/^(\d{2})(?:[.\-_/]|$)/);
|
||
return sectionMatch?.[1] ?? normalized;
|
||
}
|
||
function deriveBusinessOverviewDocumentActivityProfile(result, periodScope) {
|
||
if (!result || result.error || result.matched_rows <= 0) {
|
||
return null;
|
||
}
|
||
const documentTypeBuckets = new Map();
|
||
const accountSectionBuckets = new Map();
|
||
for (const row of result.rows) {
|
||
const marker = normalizeBusinessOverviewActivityMarker(row);
|
||
const count = rowAmountValue(row);
|
||
if (!marker || count === null || count <= 0) {
|
||
continue;
|
||
}
|
||
if (marker === "DOC_TYPE_DOCS") {
|
||
const documentType = rowDebitAccountValue(row) ?? rowAccountValue(row);
|
||
if (documentType) {
|
||
documentTypeBuckets.set(documentType, (documentTypeBuckets.get(documentType) ?? 0) + count);
|
||
}
|
||
continue;
|
||
}
|
||
if (marker === "SECTION_DT_OPS" || marker === "SECTION_KT_OPS") {
|
||
const section = normalizeBusinessOverviewAccountSection(rowDebitAccountValue(row) ?? rowAccountValue(row));
|
||
if (section) {
|
||
accountSectionBuckets.set(section, (accountSectionBuckets.get(section) ?? 0) + count);
|
||
}
|
||
}
|
||
}
|
||
const totalDocumentTypeCount = Array.from(documentTypeBuckets.values()).reduce((sum, count) => sum + count, 0);
|
||
const totalAccountSectionOperations = Array.from(accountSectionBuckets.values()).reduce((sum, count) => sum + count, 0);
|
||
const topDocumentTypes = Array.from(documentTypeBuckets.entries())
|
||
.map(([documentType, count]) => ({
|
||
document_type: documentType,
|
||
count,
|
||
share_pct: percentageOfTotal(count, totalDocumentTypeCount)
|
||
}))
|
||
.sort((left, right) => right.count - left.count || left.document_type.localeCompare(right.document_type, "ru"))
|
||
.slice(0, 5);
|
||
const topAccountSections = Array.from(accountSectionBuckets.entries())
|
||
.map(([accountSection, operationCount]) => ({
|
||
account_section: accountSection,
|
||
operation_count: operationCount,
|
||
share_pct: percentageOfTotal(operationCount, totalAccountSectionOperations)
|
||
}))
|
||
.sort((left, right) => right.operation_count - left.operation_count || left.account_section.localeCompare(right.account_section, "ru"))
|
||
.slice(0, 5);
|
||
if (topDocumentTypes.length <= 0 && topAccountSections.length <= 0) {
|
||
return null;
|
||
}
|
||
return {
|
||
period_scope: periodScope,
|
||
rows_matched: result.matched_rows,
|
||
total_document_type_count: totalDocumentTypeCount,
|
||
total_account_section_operations: totalAccountSectionOperations,
|
||
top_document_types: topDocumentTypes,
|
||
top_account_sections: topAccountSections,
|
||
inference_basis: "document_type_and_account_section_profile_confirmed_1c_rows"
|
||
};
|
||
}
|
||
function sumBusinessOverviewMarker(result, marker) {
|
||
return result.rows.reduce((sum, row) => {
|
||
const currentMarker = normalizeBusinessOverviewActivityMarker(row);
|
||
if (currentMarker !== marker) {
|
||
return sum;
|
||
}
|
||
const amount = rowAmountValue(row);
|
||
return amount === null ? sum : sum + amount;
|
||
}, 0);
|
||
}
|
||
function deriveBusinessOverviewCounterpartyProfile(result, periodScope) {
|
||
if (!result || result.error || result.matched_rows <= 0) {
|
||
return null;
|
||
}
|
||
const totalCounterparties = sumBusinessOverviewMarker(result, "CP_TOTAL");
|
||
const customerActive = sumBusinessOverviewMarker(result, "CP_CUSTOMER_ACTIVE");
|
||
const supplierActive = sumBusinessOverviewMarker(result, "CP_SUPPLIER_ACTIVE");
|
||
const mixedActive = sumBusinessOverviewMarker(result, "CP_MIXED_ACTIVE");
|
||
const activeUnion = sumBusinessOverviewMarker(result, "CP_ACTIVE_UNION");
|
||
const customerOnly = Math.max(0, customerActive - mixedActive);
|
||
const supplierOnly = Math.max(0, supplierActive - mixedActive);
|
||
const resolvedActive = customerOnly + supplierOnly + mixedActive;
|
||
const activeCounterparties = Math.max(activeUnion, resolvedActive);
|
||
if (totalCounterparties <= 0 && activeCounterparties <= 0) {
|
||
return null;
|
||
}
|
||
return {
|
||
period_scope: periodScope,
|
||
rows_matched: result.matched_rows,
|
||
total_counterparties: totalCounterparties > 0 ? totalCounterparties : null,
|
||
active_counterparties: activeCounterparties,
|
||
customer_only_count: customerOnly,
|
||
supplier_only_count: supplierOnly,
|
||
mixed_role_count: mixedActive,
|
||
other_or_inactive_count: totalCounterparties > 0 ? Math.max(0, totalCounterparties - resolvedActive) : null,
|
||
inference_basis: "counterparty_population_roles_confirmed_1c_rows"
|
||
};
|
||
}
|
||
function deriveBusinessOverviewContractUsageProfile(result, periodScope) {
|
||
if (!result || result.error || result.matched_rows <= 0) {
|
||
return null;
|
||
}
|
||
const totalContracts = sumBusinessOverviewMarker(result, "CT_TOTAL");
|
||
const usedContracts = sumBusinessOverviewMarker(result, "CT_USED");
|
||
if (totalContracts <= 0 && usedContracts <= 0) {
|
||
return null;
|
||
}
|
||
const cappedUsedContracts = totalContracts > 0 ? Math.min(usedContracts, totalContracts) : usedContracts;
|
||
return {
|
||
period_scope: periodScope,
|
||
rows_matched: result.matched_rows,
|
||
total_contracts: totalContracts > 0 ? totalContracts : null,
|
||
used_contracts: usedContracts,
|
||
unused_contracts: totalContracts > 0 ? Math.max(0, totalContracts - cappedUsedContracts) : null,
|
||
used_contract_share_pct: totalContracts > 0 ? percentageOfTotal(cappedUsedContracts, totalContracts) : null,
|
||
inference_basis: "contract_usage_overview_confirmed_1c_rows"
|
||
};
|
||
}
|
||
function deriveValueFlow(result, counterparty, periodScope, direction, aggregationAxis) {
|
||
if (!result || result.error || result.matched_rows <= 0) {
|
||
return null;
|
||
}
|
||
let totalAmount = 0;
|
||
let rowsWithAmount = 0;
|
||
for (const row of result.rows) {
|
||
const amount = rowAmountValue(row);
|
||
if (amount !== null) {
|
||
totalAmount += amount;
|
||
rowsWithAmount += 1;
|
||
}
|
||
}
|
||
if (rowsWithAmount <= 0) {
|
||
return null;
|
||
}
|
||
const dates = result.rows
|
||
.map((row) => rowDateValue(row))
|
||
.filter((value) => Boolean(value))
|
||
.sort();
|
||
return {
|
||
value_flow_direction: direction,
|
||
counterparty,
|
||
period_scope: periodScope,
|
||
aggregation_axis: aggregationAxis,
|
||
rows_matched: result.matched_rows,
|
||
rows_with_amount: rowsWithAmount,
|
||
total_amount: totalAmount,
|
||
total_amount_human_ru: formatAmountHumanRu(totalAmount),
|
||
first_movement_date: dates[0] ?? null,
|
||
latest_movement_date: dates[dates.length - 1] ?? null,
|
||
coverage_limited_by_probe_limit: result.coverage_limited_by_probe_limit,
|
||
coverage_recovered_by_period_chunking: result.coverage_recovered_by_period_chunking,
|
||
period_chunking_granularity: result.period_chunking_granularity,
|
||
monthly_breakdown: deriveValueFlowMonthBreakdown(result, aggregationAxis),
|
||
inference_basis: "sum_of_confirmed_1c_value_flow_rows"
|
||
};
|
||
}
|
||
function deriveRankedValueFlow(result, input) {
|
||
if (!result || result.error || result.matched_rows <= 0) {
|
||
return null;
|
||
}
|
||
const buckets = new Map();
|
||
let rowsWithAmount = 0;
|
||
for (const row of result.rows) {
|
||
const axisValue = rowCounterpartyValue(row);
|
||
const amount = rowAmountValue(row);
|
||
if (!axisValue || amount === null) {
|
||
continue;
|
||
}
|
||
rowsWithAmount += 1;
|
||
const current = buckets.get(axisValue) ?? {
|
||
rows_with_amount: 0,
|
||
total_amount: 0,
|
||
financial_flow_hint_counts: createFinancialFlowHintCounts()
|
||
};
|
||
current.rows_with_amount += 1;
|
||
current.total_amount += amount;
|
||
current.financial_flow_hint_counts[classifyRowFinancialFlowHint(row)] += 1;
|
||
buckets.set(axisValue, current);
|
||
}
|
||
if (rowsWithAmount <= 0 || buckets.size <= 0) {
|
||
return null;
|
||
}
|
||
const rankedValues = Array.from(buckets.entries())
|
||
.map(([axisValue, bucket]) => {
|
||
const dominantHint = dominantFinancialFlowHint(bucket.financial_flow_hint_counts);
|
||
return {
|
||
axis_value: axisValue,
|
||
rows_with_amount: bucket.rows_with_amount,
|
||
total_amount: bucket.total_amount,
|
||
total_amount_human_ru: formatAmountHumanRu(bucket.total_amount),
|
||
counterparty_role_hint: (0, counterpartyRoleHeuristics_1.counterpartyRoleHintForName)(axisValue),
|
||
financial_flow_hint: dominantHint.hint ?? undefined,
|
||
financial_flow_hint_rows: dominantHint.hint ? dominantHint.rows : undefined
|
||
};
|
||
})
|
||
.sort((left, right) => {
|
||
const amountDelta = right.total_amount - left.total_amount;
|
||
if (input.rankingNeed === "bottom_asc") {
|
||
if (amountDelta !== 0) {
|
||
return -amountDelta;
|
||
}
|
||
}
|
||
else if (amountDelta !== 0) {
|
||
return amountDelta;
|
||
}
|
||
return left.axis_value.localeCompare(right.axis_value, "ru");
|
||
})
|
||
.slice(0, 5);
|
||
return {
|
||
value_flow_direction: input.direction,
|
||
ranking_need: input.rankingNeed,
|
||
ranking_axis: "counterparty",
|
||
organization_scope: input.organizationScope,
|
||
period_scope: input.periodScope,
|
||
rows_matched: result.matched_rows,
|
||
rows_with_amount: rowsWithAmount,
|
||
ranked_values: rankedValues,
|
||
coverage_limited_by_probe_limit: result.coverage_limited_by_probe_limit,
|
||
coverage_recovered_by_period_chunking: result.coverage_recovered_by_period_chunking,
|
||
period_chunking_granularity: result.period_chunking_granularity,
|
||
inference_basis: "ranked_counterparty_totals_from_confirmed_1c_value_flow_rows"
|
||
};
|
||
}
|
||
function deriveValueFlowSideSummary(result) {
|
||
if (!result || result.error || result.matched_rows <= 0) {
|
||
return {
|
||
rows_matched: 0,
|
||
rows_with_amount: 0,
|
||
total_amount: 0,
|
||
total_amount_human_ru: formatAmountHumanRu(0),
|
||
first_movement_date: null,
|
||
latest_movement_date: null,
|
||
coverage_limited_by_probe_limit: false,
|
||
coverage_recovered_by_period_chunking: false,
|
||
period_chunking_granularity: null
|
||
};
|
||
}
|
||
let totalAmount = 0;
|
||
let rowsWithAmount = 0;
|
||
for (const row of result.rows) {
|
||
const amount = rowAmountValue(row);
|
||
if (amount !== null) {
|
||
totalAmount += amount;
|
||
rowsWithAmount += 1;
|
||
}
|
||
}
|
||
const dates = result.rows
|
||
.map((row) => rowDateValue(row))
|
||
.filter((value) => Boolean(value))
|
||
.sort();
|
||
return {
|
||
rows_matched: result.matched_rows,
|
||
rows_with_amount: rowsWithAmount,
|
||
total_amount: totalAmount,
|
||
total_amount_human_ru: formatAmountHumanRu(totalAmount),
|
||
first_movement_date: dates[0] ?? null,
|
||
latest_movement_date: dates[dates.length - 1] ?? null,
|
||
coverage_limited_by_probe_limit: result.coverage_limited_by_probe_limit,
|
||
coverage_recovered_by_period_chunking: result.coverage_recovered_by_period_chunking,
|
||
period_chunking_granularity: result.period_chunking_granularity
|
||
};
|
||
}
|
||
function deriveBidirectionalValueFlow(input) {
|
||
const incoming = deriveValueFlowSideSummary(input.incomingResult);
|
||
const outgoing = deriveValueFlowSideSummary(input.outgoingResult);
|
||
if (incoming.rows_with_amount <= 0 && outgoing.rows_with_amount <= 0) {
|
||
return null;
|
||
}
|
||
const netAmount = incoming.total_amount - outgoing.total_amount;
|
||
return {
|
||
counterparty: input.counterparty,
|
||
period_scope: input.periodScope,
|
||
aggregation_axis: input.aggregationAxis,
|
||
incoming_customer_revenue: incoming,
|
||
outgoing_supplier_payout: outgoing,
|
||
net_amount: netAmount,
|
||
net_amount_human_ru: formatAmountHumanRu(Math.abs(netAmount)),
|
||
net_direction: netDirectionFromAmount(netAmount),
|
||
coverage_limited_by_probe_limit: incoming.coverage_limited_by_probe_limit || outgoing.coverage_limited_by_probe_limit,
|
||
coverage_recovered_by_period_chunking: incoming.coverage_recovered_by_period_chunking || outgoing.coverage_recovered_by_period_chunking,
|
||
period_chunking_granularity: incoming.period_chunking_granularity ?? outgoing.period_chunking_granularity ?? null,
|
||
monthly_breakdown: deriveBidirectionalValueFlowMonthBreakdown({
|
||
incomingResult: input.incomingResult,
|
||
outgoingResult: input.outgoingResult,
|
||
aggregationAxis: input.aggregationAxis
|
||
}),
|
||
inference_basis: "incoming_minus_outgoing_confirmed_1c_value_flow_rows"
|
||
};
|
||
}
|
||
function summarizeBidirectionalValueFlowRows(input) {
|
||
const incoming = input.incomingResult;
|
||
const outgoing = input.outgoingResult;
|
||
if (!incoming && !outgoing) {
|
||
return null;
|
||
}
|
||
const incomingSummary = incoming?.error
|
||
? "incoming value-flow query failed"
|
||
: incoming?.coverage_recovered_by_period_chunking && incoming.period_chunking_granularity === "month"
|
||
? `${incoming.period_chunk_count} monthly incoming value-flow probes fetched ${incoming.fetched_rows} rows total, ${incoming.matched_rows} matched`
|
||
: `${incoming?.fetched_rows ?? 0} incoming value-flow rows fetched, ${incoming?.matched_rows ?? 0} matched`;
|
||
const outgoingSummary = outgoing?.error
|
||
? "outgoing supplier-payout query failed"
|
||
: outgoing?.coverage_recovered_by_period_chunking && outgoing.period_chunking_granularity === "month"
|
||
? `${outgoing.period_chunk_count} monthly outgoing supplier-payout probes fetched ${outgoing.fetched_rows} rows total, ${outgoing.matched_rows} matched`
|
||
: `${outgoing?.fetched_rows ?? 0} outgoing supplier-payout rows fetched, ${outgoing?.matched_rows ?? 0} matched`;
|
||
return `${incomingSummary}; ${outgoingSummary}`;
|
||
}
|
||
function deriveBusinessOverviewTaxPosition(result, periodScope) {
|
||
if (!result || result.error || result.matched_rows <= 0 || !periodScope) {
|
||
return null;
|
||
}
|
||
let salesVatAmount = 0;
|
||
let purchaseVatAmount = 0;
|
||
let rowsWithAmount = 0;
|
||
for (const row of result.rows) {
|
||
const amount = rowAmountValue(row);
|
||
if (amount === null) {
|
||
continue;
|
||
}
|
||
const marker = String(rowDocumentValue(row) ?? "").toLowerCase();
|
||
const account = String(rowAccountValue(row) ?? "").toLowerCase();
|
||
if (marker.includes("sales") || marker.includes("продаж") || account.startsWith("68")) {
|
||
salesVatAmount += amount;
|
||
rowsWithAmount += 1;
|
||
continue;
|
||
}
|
||
if (marker.includes("purchase") || marker.includes("покуп") || account.startsWith("19")) {
|
||
purchaseVatAmount += amount;
|
||
rowsWithAmount += 1;
|
||
}
|
||
}
|
||
if (rowsWithAmount <= 0) {
|
||
return null;
|
||
}
|
||
const netVatAmount = salesVatAmount - purchaseVatAmount;
|
||
const netVatDirection = netVatAmount > 0
|
||
? "vat_to_pay"
|
||
: netVatAmount < 0
|
||
? "vat_to_recover_or_offset"
|
||
: "balanced";
|
||
return {
|
||
period_scope: periodScope,
|
||
rows_matched: result.matched_rows,
|
||
rows_with_amount: rowsWithAmount,
|
||
sales_vat_amount: salesVatAmount,
|
||
sales_vat_amount_human_ru: formatAmountHumanRu(salesVatAmount),
|
||
purchase_vat_amount: purchaseVatAmount,
|
||
purchase_vat_amount_human_ru: formatAmountHumanRu(purchaseVatAmount),
|
||
net_vat_amount: netVatAmount,
|
||
net_vat_amount_human_ru: formatAmountHumanRu(Math.abs(netVatAmount)),
|
||
net_vat_direction: netVatDirection,
|
||
inference_basis: "sales_book_minus_purchase_book_confirmed_1c_vat_rows"
|
||
};
|
||
}
|
||
function accountingFinancialResultMarkerAmount(result, marker) {
|
||
let total = 0;
|
||
for (const row of result.rows) {
|
||
if (String(rowDocumentValue(row) ?? "") !== marker) {
|
||
continue;
|
||
}
|
||
const amount = rowAmountValue(row);
|
||
if (amount !== null && Number.isFinite(amount)) {
|
||
total += amount;
|
||
}
|
||
}
|
||
return total;
|
||
}
|
||
function accountingFinancialResultNonZeroCount(values) {
|
||
return values.filter((value) => Math.abs(value) > 0).length;
|
||
}
|
||
function deriveBusinessOverviewAccountingFinancialResult(result, periodScope) {
|
||
if (!result || result.error || result.matched_rows <= 0 || !periodScope) {
|
||
return null;
|
||
}
|
||
const salesRevenueAccounting = accountingFinancialResultMarkerAmount(result, "ACC90_REVENUE_KT");
|
||
const costOfSalesAccounting = accountingFinancialResultMarkerAmount(result, "ACC90_COST_DT");
|
||
const sellingExpensesAccounting = accountingFinancialResultMarkerAmount(result, "ACC90_SELLING_DT");
|
||
const adminExpensesAccounting = accountingFinancialResultMarkerAmount(result, "ACC90_ADMIN_DT");
|
||
const salesProfitTo99 = accountingFinancialResultMarkerAmount(result, "ACC90_RESULT_TO_99_PROFIT");
|
||
const salesLossFrom99 = accountingFinancialResultMarkerAmount(result, "ACC90_RESULT_FROM_99_LOSS");
|
||
const otherProfitTo99 = accountingFinancialResultMarkerAmount(result, "ACC91_RESULT_TO_99_PROFIT");
|
||
const otherLossFrom99 = accountingFinancialResultMarkerAmount(result, "ACC91_RESULT_FROM_99_LOSS");
|
||
const profitTransferTo84 = accountingFinancialResultMarkerAmount(result, "ACC99_TO84_PROFIT_TRANSFER");
|
||
const lossTransferFrom84 = accountingFinancialResultMarkerAmount(result, "ACC84_TO99_LOSS_TRANSFER");
|
||
const amountSignals = [
|
||
salesRevenueAccounting,
|
||
costOfSalesAccounting,
|
||
sellingExpensesAccounting,
|
||
adminExpensesAccounting,
|
||
salesProfitTo99,
|
||
salesLossFrom99,
|
||
otherProfitTo99,
|
||
otherLossFrom99,
|
||
profitTransferTo84,
|
||
lossTransferFrom84
|
||
];
|
||
const rowsWithAmount = accountingFinancialResultNonZeroCount(amountSignals);
|
||
if (rowsWithAmount <= 0) {
|
||
return null;
|
||
}
|
||
const salesResultAmount = salesProfitTo99 - salesLossFrom99;
|
||
const otherResultAmount = otherProfitTo99 - otherLossFrom99;
|
||
const hasFinalTransfer = profitTransferTo84 > 0 || lossTransferFrom84 > 0;
|
||
const finalResultAmount = hasFinalTransfer
|
||
? profitTransferTo84 - lossTransferFrom84
|
||
: salesResultAmount + otherResultAmount;
|
||
const finalResultDirection = finalResultAmount > 0
|
||
? "profit"
|
||
: finalResultAmount < 0
|
||
? "loss"
|
||
: "balanced";
|
||
const netMarginToRevenuePct = salesRevenueAccounting > 0 ? percentageOfTotal(finalResultAmount, salesRevenueAccounting) : null;
|
||
const periodCloseRowsWithAmount = accountingFinancialResultNonZeroCount([
|
||
salesProfitTo99,
|
||
salesLossFrom99,
|
||
otherProfitTo99,
|
||
otherLossFrom99,
|
||
profitTransferTo84,
|
||
lossTransferFrom84
|
||
]);
|
||
return {
|
||
period_scope: periodScope,
|
||
rows_matched: result.matched_rows,
|
||
rows_with_amount: rowsWithAmount,
|
||
sales_revenue_accounting: salesRevenueAccounting,
|
||
sales_revenue_accounting_human_ru: formatAmountHumanRu(salesRevenueAccounting),
|
||
cost_of_sales_accounting: costOfSalesAccounting,
|
||
cost_of_sales_accounting_human_ru: formatAmountHumanRu(costOfSalesAccounting),
|
||
selling_expenses_accounting: sellingExpensesAccounting,
|
||
selling_expenses_accounting_human_ru: formatAmountHumanRu(sellingExpensesAccounting),
|
||
admin_expenses_accounting: adminExpensesAccounting,
|
||
admin_expenses_accounting_human_ru: formatAmountHumanRu(adminExpensesAccounting),
|
||
sales_result_amount: salesResultAmount,
|
||
sales_result_amount_human_ru: formatAmountHumanRu(Math.abs(salesResultAmount)),
|
||
other_result_amount: otherResultAmount,
|
||
other_result_amount_human_ru: formatAmountHumanRu(Math.abs(otherResultAmount)),
|
||
final_result_amount: finalResultAmount,
|
||
final_result_amount_human_ru: formatAmountHumanRu(Math.abs(finalResultAmount)),
|
||
final_result_direction: finalResultDirection,
|
||
net_margin_to_revenue_pct: netMarginToRevenuePct,
|
||
final_transfer_basis: hasFinalTransfer
|
||
? "account_99_to_84_period_close"
|
||
: "account_90_91_to_99_period_close",
|
||
period_close_rows_with_amount: periodCloseRowsWithAmount,
|
||
inference_basis: "account_90_91_99_period_close_aggregate_confirmed_1c_rows"
|
||
};
|
||
}
|
||
function deriveBusinessOverviewTradingMarginProxy(result, periodScope) {
|
||
if (!result || result.error || result.matched_rows <= 0 || !periodScope) {
|
||
return null;
|
||
}
|
||
const itemBuckets = new Map();
|
||
let salesRowsWithAmount = 0;
|
||
let purchaseRowsWithAmount = 0;
|
||
let salesRevenue = 0;
|
||
let purchaseCostProxy = 0;
|
||
for (const row of result.rows) {
|
||
const amount = rowAmountValue(row);
|
||
if (amount === null || amount <= 0) {
|
||
continue;
|
||
}
|
||
const isSale = accountTextMatchesPrefix(rowCreditAccountValue(row), ["41.01"]);
|
||
const isPurchase = accountTextMatchesPrefix(rowDebitAccountValue(row), ["41.01"]);
|
||
if (!isSale && !isPurchase) {
|
||
continue;
|
||
}
|
||
const item = rowInventoryItemValue(row) ?? "unknown_item";
|
||
const quantity = rowQuantityValue(row) ?? 0;
|
||
const bucket = itemBuckets.get(item) ?? {
|
||
sales_revenue: 0,
|
||
purchase_cost_proxy: 0,
|
||
sales_quantity: 0,
|
||
purchase_quantity: 0
|
||
};
|
||
if (isSale) {
|
||
salesRowsWithAmount += 1;
|
||
salesRevenue += amount;
|
||
bucket.sales_revenue += amount;
|
||
bucket.sales_quantity += quantity;
|
||
}
|
||
if (isPurchase) {
|
||
purchaseRowsWithAmount += 1;
|
||
purchaseCostProxy += amount;
|
||
bucket.purchase_cost_proxy += amount;
|
||
bucket.purchase_quantity += quantity;
|
||
}
|
||
itemBuckets.set(item, bucket);
|
||
}
|
||
if (salesRowsWithAmount <= 0 && purchaseRowsWithAmount <= 0) {
|
||
return null;
|
||
}
|
||
const grossSpreadProxy = salesRevenue - purchaseCostProxy;
|
||
const marginToRevenuePct = salesRevenue > 0 ? percentageOfTotal(grossSpreadProxy, salesRevenue) : null;
|
||
const markupToPurchasePct = purchaseCostProxy > 0 ? percentageOfTotal(grossSpreadProxy, purchaseCostProxy) : null;
|
||
const topItemsBySales = Array.from(itemBuckets.entries())
|
||
.map(([item, bucket]) => ({
|
||
item,
|
||
sales_revenue: bucket.sales_revenue,
|
||
sales_revenue_human_ru: formatAmountHumanRu(bucket.sales_revenue),
|
||
purchase_cost_proxy: bucket.purchase_cost_proxy,
|
||
purchase_cost_proxy_human_ru: formatAmountHumanRu(bucket.purchase_cost_proxy),
|
||
gross_spread_proxy: bucket.sales_revenue - bucket.purchase_cost_proxy,
|
||
gross_spread_proxy_human_ru: formatAmountHumanRu(bucket.sales_revenue - bucket.purchase_cost_proxy),
|
||
sales_quantity: bucket.sales_quantity,
|
||
purchase_quantity: bucket.purchase_quantity
|
||
}))
|
||
.sort((left, right) => {
|
||
const salesDelta = right.sales_revenue - left.sales_revenue;
|
||
return salesDelta !== 0 ? salesDelta : left.item.localeCompare(right.item, "ru");
|
||
})
|
||
.slice(0, 5);
|
||
return {
|
||
period_scope: periodScope,
|
||
rows_matched: result.matched_rows,
|
||
sales_rows_with_amount: salesRowsWithAmount,
|
||
purchase_rows_with_amount: purchaseRowsWithAmount,
|
||
sales_revenue: salesRevenue,
|
||
sales_revenue_human_ru: formatAmountHumanRu(salesRevenue),
|
||
purchase_cost_proxy: purchaseCostProxy,
|
||
purchase_cost_proxy_human_ru: formatAmountHumanRu(purchaseCostProxy),
|
||
gross_spread_proxy: grossSpreadProxy,
|
||
gross_spread_proxy_human_ru: formatAmountHumanRu(grossSpreadProxy),
|
||
margin_to_revenue_pct: marginToRevenuePct,
|
||
markup_to_purchase_pct: markupToPurchasePct,
|
||
top_items_by_sales: topItemsBySales,
|
||
inference_basis: "sales_documents_minus_purchase_documents_confirmed_1c_rows"
|
||
};
|
||
}
|
||
function deriveBusinessOverviewDebtSide(result) {
|
||
if (!result || result.error || result.matched_rows <= 0) {
|
||
return {
|
||
rows_matched: 0,
|
||
rows_with_amount: 0,
|
||
total_amount: 0,
|
||
total_amount_human_ru: formatAmountHumanRu(0),
|
||
top_counterparties: []
|
||
};
|
||
}
|
||
const buckets = new Map();
|
||
let rowsWithAmount = 0;
|
||
let totalAmount = 0;
|
||
for (const row of result.rows) {
|
||
const amount = rowAmountValue(row);
|
||
if (amount === null) {
|
||
continue;
|
||
}
|
||
rowsWithAmount += 1;
|
||
totalAmount += amount;
|
||
const counterparty = rowCounterpartyValue(row) ?? "unknown_counterparty";
|
||
const current = buckets.get(counterparty) ?? { rows_with_amount: 0, total_amount: 0 };
|
||
current.rows_with_amount += 1;
|
||
current.total_amount += amount;
|
||
buckets.set(counterparty, current);
|
||
}
|
||
const topCounterparties = Array.from(buckets.entries())
|
||
.map(([axisValue, bucket]) => ({
|
||
axis_value: axisValue,
|
||
rows_with_amount: bucket.rows_with_amount,
|
||
total_amount: bucket.total_amount,
|
||
total_amount_human_ru: formatAmountHumanRu(bucket.total_amount)
|
||
}))
|
||
.sort((left, right) => {
|
||
const amountDelta = right.total_amount - left.total_amount;
|
||
return amountDelta !== 0 ? amountDelta : left.axis_value.localeCompare(right.axis_value, "ru");
|
||
})
|
||
.slice(0, 5);
|
||
return {
|
||
rows_matched: result.matched_rows,
|
||
rows_with_amount: rowsWithAmount,
|
||
total_amount: totalAmount,
|
||
total_amount_human_ru: formatAmountHumanRu(totalAmount),
|
||
top_counterparties: topCounterparties
|
||
};
|
||
}
|
||
function deriveBusinessOverviewDebtPosition(input) {
|
||
if (!input.debtAsOfDate) {
|
||
return null;
|
||
}
|
||
const receivables = deriveBusinessOverviewDebtSide(input.receivablesResult);
|
||
const payables = deriveBusinessOverviewDebtSide(input.payablesResult);
|
||
if (receivables.rows_with_amount <= 0 && payables.rows_with_amount <= 0) {
|
||
return null;
|
||
}
|
||
const netDebtPositionAmount = receivables.total_amount - payables.total_amount;
|
||
const netDebtPositionDirection = netDebtPositionAmount > 0
|
||
? "net_receivable"
|
||
: netDebtPositionAmount < 0
|
||
? "net_payable"
|
||
: "balanced";
|
||
return {
|
||
as_of_date: input.debtAsOfDate,
|
||
receivables,
|
||
payables,
|
||
net_debt_position_amount: netDebtPositionAmount,
|
||
net_debt_position_amount_human_ru: formatAmountHumanRu(Math.abs(netDebtPositionAmount)),
|
||
net_debt_position_direction: netDebtPositionDirection,
|
||
inference_basis: "receivables_minus_payables_confirmed_1c_balance_rows"
|
||
};
|
||
}
|
||
function percentageOfTotal(part, total) {
|
||
if (!Number.isFinite(part) || !Number.isFinite(total) || total <= 0) {
|
||
return null;
|
||
}
|
||
return Math.round((part / total) * 10_000) / 100;
|
||
}
|
||
function ratioOfTotal(part, total) {
|
||
if (!Number.isFinite(part) || !Number.isFinite(total) || total <= 0) {
|
||
return null;
|
||
}
|
||
return Math.round((part / total) * 100) / 100;
|
||
}
|
||
function deriveBusinessOverviewDebtOpenSettlementQuality(input) {
|
||
if (!input.debtAsOfDate || !input.openContractsResult || input.openContractsResult.error || input.openContractsResult.matched_rows <= 0) {
|
||
return null;
|
||
}
|
||
const debtAsOfDate = input.debtAsOfDate;
|
||
const counterpartyBuckets = new Map();
|
||
const contractBuckets = new Map();
|
||
const counterparties = new Set();
|
||
const contracts = new Set();
|
||
let rowsWithAmount = 0;
|
||
let grossOpenAmount = 0;
|
||
let rowsWithoutCounterparty = 0;
|
||
let rowsWithoutContract = 0;
|
||
for (const row of input.openContractsResult.rows) {
|
||
const amount = rowAmountValue(row);
|
||
if (amount === null) {
|
||
continue;
|
||
}
|
||
const absAmount = Math.abs(amount);
|
||
if (absAmount <= 0) {
|
||
continue;
|
||
}
|
||
rowsWithAmount += 1;
|
||
grossOpenAmount += absAmount;
|
||
const counterparty = rowCounterpartyValue(row);
|
||
const contract = rowContractValue(row);
|
||
if (counterparty) {
|
||
counterparties.add(counterparty);
|
||
const current = counterpartyBuckets.get(counterparty) ?? { rows_with_amount: 0, total_amount: 0 };
|
||
current.rows_with_amount += 1;
|
||
current.total_amount += absAmount;
|
||
counterpartyBuckets.set(counterparty, current);
|
||
}
|
||
else {
|
||
rowsWithoutCounterparty += 1;
|
||
}
|
||
if (contract) {
|
||
const contractStartDate = rowOpenSettlementContractStartDateValue(row);
|
||
contracts.add(contract);
|
||
const current = contractBuckets.get(contract) ?? {
|
||
counterparty,
|
||
contract_start_date: contractStartDate,
|
||
rows_with_amount: 0,
|
||
total_amount: 0
|
||
};
|
||
if (!current.counterparty && counterparty) {
|
||
current.counterparty = counterparty;
|
||
}
|
||
current.contract_start_date = earlierIsoDate(current.contract_start_date, contractStartDate);
|
||
current.rows_with_amount += 1;
|
||
current.total_amount += absAmount;
|
||
contractBuckets.set(contract, current);
|
||
}
|
||
else {
|
||
rowsWithoutContract += 1;
|
||
}
|
||
}
|
||
if (rowsWithAmount <= 0) {
|
||
return null;
|
||
}
|
||
const topCounterparties = Array.from(counterpartyBuckets.entries())
|
||
.map(([axisValue, bucket]) => ({
|
||
axis_value: axisValue,
|
||
rows_with_amount: bucket.rows_with_amount,
|
||
total_amount: bucket.total_amount,
|
||
total_amount_human_ru: formatAmountHumanRu(bucket.total_amount)
|
||
}))
|
||
.sort((left, right) => {
|
||
const amountDelta = right.total_amount - left.total_amount;
|
||
return amountDelta !== 0 ? amountDelta : left.axis_value.localeCompare(right.axis_value, "ru");
|
||
})
|
||
.slice(0, 5);
|
||
const topContracts = Array.from(contractBuckets.entries())
|
||
.map(([contract, bucket]) => ({
|
||
contract,
|
||
counterparty: bucket.counterparty,
|
||
contract_start_date: bucket.contract_start_date,
|
||
rows_with_amount: bucket.rows_with_amount,
|
||
total_amount: bucket.total_amount,
|
||
total_amount_human_ru: formatAmountHumanRu(bucket.total_amount),
|
||
share_of_gross_open_amount_pct: percentageOfTotal(bucket.total_amount, grossOpenAmount)
|
||
}))
|
||
.sort((left, right) => {
|
||
const amountDelta = right.total_amount - left.total_amount;
|
||
return amountDelta !== 0 ? amountDelta : left.contract.localeCompare(right.contract, "ru");
|
||
})
|
||
.slice(0, 5);
|
||
const agedContractBuckets = Array.from(contractBuckets.entries())
|
||
.map(([contract, bucket]) => {
|
||
if (!bucket.contract_start_date) {
|
||
return null;
|
||
}
|
||
return {
|
||
contract,
|
||
counterparty: bucket.counterparty,
|
||
start_date: bucket.contract_start_date,
|
||
age_days: daysBetweenIsoDates(bucket.contract_start_date, debtAsOfDate),
|
||
total_amount: bucket.total_amount,
|
||
total_amount_human_ru: formatAmountHumanRu(bucket.total_amount),
|
||
share_of_gross_open_amount_pct: percentageOfTotal(bucket.total_amount, grossOpenAmount)
|
||
};
|
||
})
|
||
.filter((item) => Boolean(item))
|
||
.sort((left, right) => {
|
||
const leftAge = left.age_days ?? -1;
|
||
const rightAge = right.age_days ?? -1;
|
||
const ageDelta = rightAge - leftAge;
|
||
if (ageDelta !== 0) {
|
||
return ageDelta;
|
||
}
|
||
const amountDelta = right.total_amount - left.total_amount;
|
||
return amountDelta !== 0 ? amountDelta : left.contract.localeCompare(right.contract, "ru");
|
||
});
|
||
const debtAgeDates = agedContractBuckets.map((bucket) => bucket.start_date).sort();
|
||
const maxAgeDays = agedContractBuckets.reduce((max, bucket) => {
|
||
if (bucket.age_days === null) {
|
||
return max;
|
||
}
|
||
return max === null ? bucket.age_days : Math.max(max, bucket.age_days);
|
||
}, null);
|
||
const ageSignal = agedContractBuckets.length > 0
|
||
? {
|
||
contracts_with_start_date: agedContractBuckets.length,
|
||
oldest_start_date: debtAgeDates[0] ?? null,
|
||
latest_start_date: debtAgeDates[debtAgeDates.length - 1] ?? null,
|
||
max_age_days: maxAgeDays,
|
||
top_aged_contracts: agedContractBuckets.slice(0, 5),
|
||
inference_basis: "contract_dates_from_open_settlement_rows"
|
||
}
|
||
: null;
|
||
return {
|
||
as_of_date: debtAsOfDate,
|
||
rows_matched: input.openContractsResult.matched_rows,
|
||
rows_with_amount: rowsWithAmount,
|
||
gross_open_amount: grossOpenAmount,
|
||
gross_open_amount_human_ru: formatAmountHumanRu(grossOpenAmount),
|
||
unique_counterparties: counterparties.size,
|
||
unique_contracts: contracts.size,
|
||
rows_without_counterparty: rowsWithoutCounterparty,
|
||
rows_without_contract: rowsWithoutContract,
|
||
top_counterparties: topCounterparties,
|
||
top_contracts: topContracts,
|
||
concentration_top_counterparty_pct: percentageOfTotal(topCounterparties[0]?.total_amount ?? 0, grossOpenAmount),
|
||
concentration_top_contract_pct: percentageOfTotal(topContracts[0]?.total_amount ?? 0, grossOpenAmount),
|
||
age_signal: ageSignal,
|
||
inference_basis: "open_contracts_confirmed_1c_balance_rows"
|
||
};
|
||
}
|
||
function debtStalenessRiskBand(input) {
|
||
if (input.maxContractAgeDays >= 365 && input.topContractSharePct >= 50) {
|
||
return "high";
|
||
}
|
||
if (input.maxContractAgeDays >= 365 || input.topContractSharePct >= 50) {
|
||
return "elevated";
|
||
}
|
||
if (input.maxContractAgeDays >= 180 || input.topContractSharePct >= 35) {
|
||
return "watch";
|
||
}
|
||
return "lower_visible_risk";
|
||
}
|
||
function deriveBusinessOverviewDebtStalenessRiskProxy(quality) {
|
||
const ageSignal = quality?.age_signal;
|
||
const topAgedContract = ageSignal?.top_aged_contracts[0];
|
||
const topContractSharePct = topAgedContract?.share_of_gross_open_amount_pct;
|
||
if (!quality ||
|
||
!ageSignal?.oldest_start_date ||
|
||
ageSignal.max_age_days === null ||
|
||
ageSignal.max_age_days === undefined ||
|
||
!topAgedContract ||
|
||
topContractSharePct === null ||
|
||
topContractSharePct === undefined) {
|
||
return null;
|
||
}
|
||
return {
|
||
as_of_date: quality.as_of_date,
|
||
gross_open_amount: quality.gross_open_amount,
|
||
gross_open_amount_human_ru: quality.gross_open_amount_human_ru,
|
||
oldest_contract_start_date: ageSignal.oldest_start_date,
|
||
max_contract_age_days: ageSignal.max_age_days,
|
||
top_contract: topAgedContract.contract,
|
||
top_contract_counterparty: topAgedContract.counterparty,
|
||
top_contract_amount: topAgedContract.total_amount,
|
||
top_contract_amount_human_ru: topAgedContract.total_amount_human_ru,
|
||
top_contract_share_pct: topContractSharePct,
|
||
risk_band: debtStalenessRiskBand({
|
||
maxContractAgeDays: ageSignal.max_age_days,
|
||
topContractSharePct
|
||
}),
|
||
inference_basis: "contract_date_age_and_open_balance_concentration_confirmed_1c_rows"
|
||
};
|
||
}
|
||
function deriveBusinessOverviewDebtDueDateAging(input) {
|
||
if (!input.debtAsOfDate || !input.dueDateResult || input.dueDateResult.error || input.dueDateResult.matched_rows <= 0) {
|
||
return null;
|
||
}
|
||
const overdueItems = [];
|
||
let rowsWithAmount = 0;
|
||
let grossOpenAmount = 0;
|
||
let rowsWithPaymentTerms = 0;
|
||
let rowsWithoutPaymentTerms = 0;
|
||
let rowsWithoutDocumentDate = 0;
|
||
let overdueAmount = 0;
|
||
let notYetDueAmount = 0;
|
||
let notYetDueRows = 0;
|
||
for (const row of input.dueDateResult.rows) {
|
||
const amount = rowAmountValue(row);
|
||
if (amount === null) {
|
||
continue;
|
||
}
|
||
const absAmount = Math.abs(amount);
|
||
if (absAmount <= 0) {
|
||
continue;
|
||
}
|
||
rowsWithAmount += 1;
|
||
grossOpenAmount += absAmount;
|
||
const paymentTermIsSet = rowPaymentTermIsSetValue(row);
|
||
const paymentTermDays = rowPaymentTermDaysValue(row);
|
||
if (!paymentTermIsSet || paymentTermDays === null) {
|
||
rowsWithoutPaymentTerms += 1;
|
||
continue;
|
||
}
|
||
rowsWithPaymentTerms += 1;
|
||
const documentDate = rowSettlementDocumentDateValue(row) ?? rowContractDateValue(row);
|
||
if (!documentDate) {
|
||
rowsWithoutDocumentDate += 1;
|
||
continue;
|
||
}
|
||
const dueDate = addDaysToIsoDate(documentDate, paymentTermDays);
|
||
if (!dueDate) {
|
||
rowsWithoutDocumentDate += 1;
|
||
continue;
|
||
}
|
||
const overdueDays = dueDate < input.debtAsOfDate ? daysBetweenIsoDates(dueDate, input.debtAsOfDate) : null;
|
||
if (overdueDays !== null && overdueDays > 0) {
|
||
overdueAmount += absAmount;
|
||
overdueItems.push({
|
||
counterparty: rowCounterpartyValue(row),
|
||
contract: rowContractValue(row),
|
||
settlement_document: rowTextValue(row, [
|
||
"ДокументРасчетов",
|
||
"SettlementDocument",
|
||
"settlement_document"
|
||
]) ?? rowDocumentValue(row),
|
||
document_date: documentDate,
|
||
due_date: dueDate,
|
||
payment_term_days: paymentTermDays,
|
||
overdue_days: overdueDays,
|
||
amount: absAmount,
|
||
amount_human_ru: formatAmountHumanRu(absAmount)
|
||
});
|
||
}
|
||
else {
|
||
notYetDueRows += 1;
|
||
notYetDueAmount += absAmount;
|
||
}
|
||
}
|
||
if (rowsWithAmount <= 0) {
|
||
return null;
|
||
}
|
||
const topOverdueItems = overdueItems
|
||
.sort((left, right) => {
|
||
const daysDelta = right.overdue_days - left.overdue_days;
|
||
if (daysDelta !== 0) {
|
||
return daysDelta;
|
||
}
|
||
const amountDelta = right.amount - left.amount;
|
||
return amountDelta !== 0 ? amountDelta : String(left.contract ?? "").localeCompare(String(right.contract ?? ""), "ru");
|
||
})
|
||
.slice(0, 5)
|
||
.map((item) => ({
|
||
...item,
|
||
share_of_overdue_amount_pct: percentageOfTotal(item.amount, overdueAmount)
|
||
}));
|
||
const oldestDueDate = overdueItems
|
||
.map((item) => item.due_date)
|
||
.sort()[0] ?? null;
|
||
const maxOverdueDays = overdueItems.reduce((max, item) => max === null ? item.overdue_days : Math.max(max, item.overdue_days), null);
|
||
const evidenceStatus = overdueItems.length > 0
|
||
? "confirmed_overdue"
|
||
: rowsWithPaymentTerms <= 0
|
||
? "no_payment_terms_configured"
|
||
: rowsWithoutDocumentDate >= rowsWithPaymentTerms
|
||
? "insufficient_due_date_basis"
|
||
: "no_overdue_found";
|
||
return {
|
||
as_of_date: input.debtAsOfDate,
|
||
rows_matched: input.dueDateResult.matched_rows,
|
||
rows_with_amount: rowsWithAmount,
|
||
gross_open_amount: grossOpenAmount,
|
||
gross_open_amount_human_ru: formatAmountHumanRu(grossOpenAmount),
|
||
rows_with_payment_terms: rowsWithPaymentTerms,
|
||
rows_without_payment_terms: rowsWithoutPaymentTerms,
|
||
rows_without_document_date: rowsWithoutDocumentDate,
|
||
overdue_rows: overdueItems.length,
|
||
overdue_amount: overdueAmount,
|
||
overdue_amount_human_ru: formatAmountHumanRu(overdueAmount),
|
||
not_yet_due_rows: notYetDueRows,
|
||
not_yet_due_amount: notYetDueAmount,
|
||
not_yet_due_amount_human_ru: formatAmountHumanRu(notYetDueAmount),
|
||
oldest_due_date: oldestDueDate,
|
||
max_overdue_days: maxOverdueDays,
|
||
top_overdue_items: topOverdueItems,
|
||
evidence_status: evidenceStatus,
|
||
inference_basis: "contract_payment_terms_and_settlement_document_dates_from_open_balance_rows"
|
||
};
|
||
}
|
||
function debtStalenessRiskBandRu(riskBand) {
|
||
if (riskBand === "high") {
|
||
return "высокая зона внимания";
|
||
}
|
||
if (riskBand === "elevated") {
|
||
return "повышенная зона внимания";
|
||
}
|
||
if (riskBand === "watch") {
|
||
return "зона наблюдения";
|
||
}
|
||
return "низкий видимый риск";
|
||
}
|
||
function daysBetweenIsoDates(leftIsoDate, rightIsoDate) {
|
||
const leftMatch = leftIsoDate.match(/^(\d{4})-(\d{2})-(\d{2})$/);
|
||
const rightMatch = rightIsoDate.match(/^(\d{4})-(\d{2})-(\d{2})$/);
|
||
if (!leftMatch || !rightMatch) {
|
||
return null;
|
||
}
|
||
const left = Date.UTC(Number(leftMatch[1]), Number(leftMatch[2]) - 1, Number(leftMatch[3]));
|
||
const right = Date.UTC(Number(rightMatch[1]), Number(rightMatch[2]) - 1, Number(rightMatch[3]));
|
||
if (!Number.isFinite(left) || !Number.isFinite(right)) {
|
||
return null;
|
||
}
|
||
return Math.max(0, Math.floor((right - left) / 86_400_000));
|
||
}
|
||
function deriveBusinessOverviewInventoryAgingSignal(result, inventoryAsOfDate) {
|
||
if (!result || result.error || result.matched_rows <= 0) {
|
||
return null;
|
||
}
|
||
const dates = result.rows
|
||
.map((row) => rowDateValue(row))
|
||
.filter((value) => Boolean(value))
|
||
.sort((left, right) => left.localeCompare(right));
|
||
if (dates.length <= 0) {
|
||
return null;
|
||
}
|
||
const oldestPurchaseDate = dates[0] ?? null;
|
||
const latestPurchaseDate = dates[dates.length - 1] ?? null;
|
||
return {
|
||
rows_matched: result.matched_rows,
|
||
rows_with_purchase_date: dates.length,
|
||
oldest_purchase_date: oldestPurchaseDate,
|
||
latest_purchase_date: latestPurchaseDate,
|
||
max_age_days: oldestPurchaseDate ? daysBetweenIsoDates(oldestPurchaseDate, inventoryAsOfDate) : null,
|
||
inference_basis: "inventory_purchase_dates_from_confirmed_1c_rows"
|
||
};
|
||
}
|
||
function deriveBusinessOverviewInventoryPosition(input) {
|
||
const { inventoryAsOfDate, inventoryOnHandResult } = input;
|
||
if (!inventoryAsOfDate || !inventoryOnHandResult || inventoryOnHandResult.error || inventoryOnHandResult.matched_rows <= 0) {
|
||
return null;
|
||
}
|
||
const buckets = new Map();
|
||
let rowsWithAmount = 0;
|
||
let rowsWithQuantity = 0;
|
||
let totalAmount = 0;
|
||
let totalQuantity = 0;
|
||
for (const row of inventoryOnHandResult.rows) {
|
||
const amount = rowAmountValue(row);
|
||
const quantity = rowQuantityValue(row);
|
||
if (amount === null && quantity === null) {
|
||
continue;
|
||
}
|
||
const item = rowInventoryItemValue(row) ?? "unknown_item";
|
||
const current = buckets.get(item) ?? {
|
||
rows_with_amount: 0,
|
||
rows_with_quantity: 0,
|
||
total_amount: 0,
|
||
total_quantity: 0
|
||
};
|
||
if (amount !== null) {
|
||
rowsWithAmount += 1;
|
||
totalAmount += amount;
|
||
current.rows_with_amount += 1;
|
||
current.total_amount += amount;
|
||
}
|
||
if (quantity !== null) {
|
||
rowsWithQuantity += 1;
|
||
totalQuantity += quantity;
|
||
current.rows_with_quantity += 1;
|
||
current.total_quantity += quantity;
|
||
}
|
||
buckets.set(item, current);
|
||
}
|
||
if (rowsWithAmount <= 0 && rowsWithQuantity <= 0) {
|
||
return null;
|
||
}
|
||
const topItems = Array.from(buckets.entries())
|
||
.map(([item, bucket]) => ({
|
||
item,
|
||
rows_with_amount: bucket.rows_with_amount,
|
||
rows_with_quantity: bucket.rows_with_quantity,
|
||
total_amount: bucket.total_amount,
|
||
total_amount_human_ru: formatAmountHumanRu(bucket.total_amount),
|
||
total_quantity: bucket.total_quantity
|
||
}))
|
||
.sort((left, right) => {
|
||
const amountDelta = right.total_amount - left.total_amount;
|
||
if (amountDelta !== 0) {
|
||
return amountDelta;
|
||
}
|
||
const quantityDelta = right.total_quantity - left.total_quantity;
|
||
return quantityDelta !== 0 ? quantityDelta : left.item.localeCompare(right.item, "ru");
|
||
})
|
||
.slice(0, 5);
|
||
return {
|
||
as_of_date: inventoryAsOfDate,
|
||
rows_matched: inventoryOnHandResult.matched_rows,
|
||
rows_with_amount: rowsWithAmount,
|
||
rows_with_quantity: rowsWithQuantity,
|
||
total_amount: totalAmount,
|
||
total_amount_human_ru: formatAmountHumanRu(totalAmount),
|
||
total_quantity: totalQuantity,
|
||
top_items: topItems,
|
||
aging_signal: deriveBusinessOverviewInventoryAgingSignal(input.inventoryAgingResult, inventoryAsOfDate),
|
||
inference_basis: "inventory_on_hand_confirmed_1c_balance_rows"
|
||
};
|
||
}
|
||
function deriveBusinessOverviewInventoryTurnoverProxy(input) {
|
||
const { inventoryPosition, tradingMarginProxy } = input;
|
||
if (!inventoryPosition || !tradingMarginProxy) {
|
||
return null;
|
||
}
|
||
if (inventoryPosition.total_amount <= 0 || tradingMarginProxy.sales_revenue <= 0) {
|
||
return null;
|
||
}
|
||
return {
|
||
period_scope: tradingMarginProxy.period_scope,
|
||
as_of_date: inventoryPosition.as_of_date,
|
||
sales_revenue: tradingMarginProxy.sales_revenue,
|
||
sales_revenue_human_ru: tradingMarginProxy.sales_revenue_human_ru,
|
||
inventory_amount: inventoryPosition.total_amount,
|
||
inventory_amount_human_ru: inventoryPosition.total_amount_human_ru,
|
||
sales_to_stock_amount_ratio: ratioOfTotal(tradingMarginProxy.sales_revenue, inventoryPosition.total_amount),
|
||
stock_to_sales_revenue_pct: percentageOfTotal(inventoryPosition.total_amount, tradingMarginProxy.sales_revenue),
|
||
inference_basis: "sales_document_revenue_vs_inventory_balance_confirmed_1c_rows"
|
||
};
|
||
}
|
||
function inventoryStalenessRiskBand(input) {
|
||
if (input.maxPurchaseAgeDays >= 365 && input.salesToStockAmountRatio < 1) {
|
||
return "high";
|
||
}
|
||
if (input.maxPurchaseAgeDays >= 365 || input.salesToStockAmountRatio < 1) {
|
||
return "elevated";
|
||
}
|
||
if (input.maxPurchaseAgeDays >= 180 || input.salesToStockAmountRatio < 2) {
|
||
return "watch";
|
||
}
|
||
return "lower_visible_risk";
|
||
}
|
||
function deriveBusinessOverviewInventoryStalenessRiskProxy(input) {
|
||
const { inventoryPosition, inventoryTurnoverProxy } = input;
|
||
const maxPurchaseAgeDays = inventoryPosition?.aging_signal?.max_age_days;
|
||
const oldestPurchaseDate = inventoryPosition?.aging_signal?.oldest_purchase_date;
|
||
const salesToStockAmountRatio = inventoryTurnoverProxy?.sales_to_stock_amount_ratio;
|
||
if (!inventoryPosition ||
|
||
!inventoryTurnoverProxy ||
|
||
!oldestPurchaseDate ||
|
||
maxPurchaseAgeDays === null ||
|
||
maxPurchaseAgeDays === undefined ||
|
||
salesToStockAmountRatio === null ||
|
||
salesToStockAmountRatio === undefined) {
|
||
return null;
|
||
}
|
||
return {
|
||
as_of_date: inventoryPosition.as_of_date,
|
||
period_scope: inventoryTurnoverProxy.period_scope,
|
||
oldest_purchase_date: oldestPurchaseDate,
|
||
max_purchase_age_days: maxPurchaseAgeDays,
|
||
sales_to_stock_amount_ratio: salesToStockAmountRatio,
|
||
risk_band: inventoryStalenessRiskBand({ maxPurchaseAgeDays, salesToStockAmountRatio }),
|
||
inference_basis: "purchase_date_age_and_sales_to_stock_proxy_confirmed_1c_rows"
|
||
};
|
||
}
|
||
function rowInventoryQualityEventType(row) {
|
||
return rowTextValue(row, ["ТипСобытия", "EventType", "event_type", "Регистратор", "Registrator", "registrator"]) ?? "";
|
||
}
|
||
function deriveBusinessOverviewInventoryQualityEvents(input) {
|
||
const result = input.inventoryQualityEventsResult;
|
||
if (!result || result.error) {
|
||
return null;
|
||
}
|
||
let writeoffRows = 0;
|
||
let writeoffAmount = 0;
|
||
let receiptAdjustmentRows = 0;
|
||
let receiptAdjustmentAmount = 0;
|
||
let inventoryCountRows = 0;
|
||
let revaluationRows = 0;
|
||
const eventDates = [];
|
||
for (const row of result.rows) {
|
||
const eventType = rowInventoryQualityEventType(row);
|
||
const amount = rowAmountValue(row) ?? 0;
|
||
const date = rowDateValue(row);
|
||
if (date) {
|
||
eventDates.push(date);
|
||
}
|
||
if (/списан|write[-_ ]?off/iu.test(eventType)) {
|
||
writeoffRows += 1;
|
||
writeoffAmount += amount;
|
||
continue;
|
||
}
|
||
if (/оприход|receipt|positive/i.test(eventType)) {
|
||
receiptAdjustmentRows += 1;
|
||
receiptAdjustmentAmount += amount;
|
||
continue;
|
||
}
|
||
if (/инвентаризац|stocktaking|inventory count/i.test(eventType)) {
|
||
inventoryCountRows += 1;
|
||
continue;
|
||
}
|
||
if (/переоцен|revaluation/i.test(eventType)) {
|
||
revaluationRows += 1;
|
||
}
|
||
}
|
||
const sortedDates = eventDates.sort((left, right) => left.localeCompare(right));
|
||
const evidenceStatus = writeoffRows > 0 || receiptAdjustmentRows > 0
|
||
? "reviewed_writeoff_or_adjustment_events_found"
|
||
: inventoryCountRows > 0 || revaluationRows > 0
|
||
? "reviewed_inventory_control_events_only"
|
||
: "reviewed_no_quality_events_found";
|
||
return {
|
||
period_scope: input.periodScope,
|
||
rows_matched: result.matched_rows,
|
||
writeoff_rows: writeoffRows,
|
||
writeoff_amount: writeoffAmount,
|
||
writeoff_amount_human_ru: formatAmountHumanRu(writeoffAmount),
|
||
receipt_adjustment_rows: receiptAdjustmentRows,
|
||
receipt_adjustment_amount: receiptAdjustmentAmount,
|
||
receipt_adjustment_amount_human_ru: formatAmountHumanRu(receiptAdjustmentAmount),
|
||
inventory_count_rows: inventoryCountRows,
|
||
revaluation_rows: revaluationRows,
|
||
first_event_date: sortedDates[0] ?? null,
|
||
latest_event_date: sortedDates[sortedDates.length - 1] ?? null,
|
||
evidence_status: evidenceStatus,
|
||
inference_basis: "inventory_quality_documents_confirmed_1c_rows"
|
||
};
|
||
}
|
||
function deriveBusinessOverviewVendorProcurementQuality(input) {
|
||
if (!input.rankedOutgoing ||
|
||
input.rankedOutgoing.ranked_values.length <= 0 ||
|
||
input.outgoing.rows_with_amount <= 0 ||
|
||
input.outgoing.total_amount <= 0) {
|
||
return null;
|
||
}
|
||
const topOutgoingCounterparty = input.rankedOutgoing.ranked_values[0] ?? null;
|
||
const topNonFinancialSupplier = input.rankedOutgoing.ranked_values.find((item) => !(0, counterpartyRoleHeuristics_1.isLikelyFinancialInstitutionCounterparty)(item.axis_value)) ?? null;
|
||
const financialInstitutionLeadsOutgoingCash = topOutgoingCounterparty
|
||
? (0, counterpartyRoleHeuristics_1.isLikelyFinancialInstitutionCounterparty)(topOutgoingCounterparty.axis_value)
|
||
: false;
|
||
const evidenceStatus = !topNonFinancialSupplier
|
||
? "insufficient_supplier_concentration_basis"
|
||
: financialInstitutionLeadsOutgoingCash
|
||
? "financial_institution_leads_outgoing_cash"
|
||
: "reviewed_procurement_concentration";
|
||
return {
|
||
period_scope: input.periodScope,
|
||
rows_with_amount: input.outgoing.rows_with_amount,
|
||
total_outgoing_amount: input.outgoing.total_amount,
|
||
total_outgoing_amount_human_ru: input.outgoing.total_amount_human_ru,
|
||
top_outgoing_counterparty: topOutgoingCounterparty,
|
||
top_outgoing_share_pct: topOutgoingCounterparty
|
||
? percentageOfTotal(topOutgoingCounterparty.total_amount, input.outgoing.total_amount)
|
||
: null,
|
||
top_non_financial_supplier: topNonFinancialSupplier,
|
||
top_non_financial_supplier_share_pct: topNonFinancialSupplier
|
||
? percentageOfTotal(topNonFinancialSupplier.total_amount, input.outgoing.total_amount)
|
||
: null,
|
||
financial_institution_leads_outgoing_cash: financialInstitutionLeadsOutgoingCash,
|
||
supplier_only_count: input.counterpartyProfile?.supplier_only_count ?? null,
|
||
mixed_role_count: input.counterpartyProfile?.mixed_role_count ?? null,
|
||
used_contracts: input.contractUsageProfile?.used_contracts ?? null,
|
||
total_contracts: input.contractUsageProfile?.total_contracts ?? null,
|
||
used_contract_share_pct: input.contractUsageProfile?.used_contract_share_pct ?? null,
|
||
evidence_status: evidenceStatus,
|
||
inference_basis: "supplier_payout_concentration_counterparty_contract_profile_confirmed_1c_rows"
|
||
};
|
||
}
|
||
function inventoryStalenessRiskBandRu(riskBand) {
|
||
if (riskBand === "high") {
|
||
return "высокая зона внимания";
|
||
}
|
||
if (riskBand === "elevated") {
|
||
return "повышенная зона внимания";
|
||
}
|
||
if (riskBand === "watch") {
|
||
return "зона наблюдения";
|
||
}
|
||
return "низкий видимый риск";
|
||
}
|
||
function buildBusinessOverviewMissingProofFamilies(input) {
|
||
const missing = new Set(input.missingSignalFamilies);
|
||
const items = [];
|
||
const pushUnique = (item) => {
|
||
if (!items.some((existing) => existing.family === item.family)) {
|
||
items.push(item);
|
||
}
|
||
};
|
||
if ((missing.has("profit_margin") || missing.has("accounting_profit_margin")) && !input.accountingFinancialResult) {
|
||
pushUnique({
|
||
family: "accounting_profit_margin",
|
||
current_status: input.tradingMarginProxy ? "proxy_only_currently" : "reviewed_route_not_wired",
|
||
current_supported_evidence: input.tradingMarginProxy
|
||
? "trading_margin_proxy_from_sales_and_purchase_document_rows"
|
||
: null,
|
||
next_required_evidence: "reviewed_pnl_route_with_cost_of_sales_expenses_period_close_and_financial_result",
|
||
must_not_claim: "clean_profit_accounting_margin_or_full_pnl"
|
||
});
|
||
}
|
||
if ((missing.has("debt_due_date_aging_quality") || missing.has("debt_open_settlement_quality")) && !input.debtDueDateAging) {
|
||
pushUnique({
|
||
family: "debt_due_date_aging_quality",
|
||
current_status: input.debtStalenessRiskProxy
|
||
? "proxy_only_currently"
|
||
: input.debtOpenSettlementQuality
|
||
? "proxy_only_currently"
|
||
: "not_checked_in_current_turn",
|
||
current_supported_evidence: input.debtStalenessRiskProxy
|
||
? "debt_staleness_risk_proxy_from_contract_dates_and_open_balance_concentration"
|
||
: input.debtOpenSettlementQuality
|
||
? "open_settlement_quality_from_60_62_76_balances_without_payment_terms"
|
||
: null,
|
||
next_required_evidence: "reviewed_payment_term_or_due_date_route_with_contractual_due_dates_and_settlement_status",
|
||
must_not_claim: "confirmed_overdue_debt_credit_risk_or_due_date_aging"
|
||
});
|
||
}
|
||
if ((missing.has("inventory_position") ||
|
||
missing.has("inventory_turnover_quality") ||
|
||
missing.has("inventory_liquidity_quality") ||
|
||
missing.has("inventory_reserve_liquidation_quality")) && !input.inventoryQualityEvents) {
|
||
pushUnique({
|
||
family: "inventory_reserve_liquidation_quality",
|
||
current_status: input.inventoryStalenessRiskProxy
|
||
? "proxy_only_currently"
|
||
: input.inventoryTurnoverProxy || input.inventoryPosition
|
||
? "proxy_only_currently"
|
||
: "not_checked_in_current_turn",
|
||
current_supported_evidence: input.inventoryStalenessRiskProxy
|
||
? "inventory_staleness_risk_proxy_from_purchase_age_and_sales_to_stock"
|
||
: input.inventoryTurnoverProxy
|
||
? "inventory_turnover_proxy_from_sales_documents_and_stock_balance"
|
||
: input.inventoryPosition
|
||
? "inventory_on_hand_snapshot_without_reserve_writeoff_or_liquidation_evidence"
|
||
: null,
|
||
next_required_evidence: "reviewed_inventory_quality_route_with_reserves_writeoffs_obsolescence_and_liquidation_value",
|
||
must_not_claim: "confirmed_obsolete_stock_reserve_writeoff_or_liquidation_value"
|
||
});
|
||
}
|
||
if (input.hasSupplierConcentrationSignal && !input.vendorProcurementQuality) {
|
||
pushUnique({
|
||
family: "vendor_risk_procurement_quality",
|
||
current_status: "proxy_only_currently",
|
||
current_supported_evidence: "supplier_concentration_proxy_from_confirmed_outgoing_payment_rows",
|
||
next_required_evidence: "reviewed_vendor_risk_route_with_supplier_reliability_terms_quality_and_full_expense_structure",
|
||
must_not_claim: "vendor_risk_procurement_quality_supplier_reliability_or_full_expense_structure"
|
||
});
|
||
}
|
||
return items;
|
||
}
|
||
function deriveBusinessOverview(input) {
|
||
const incoming = deriveValueFlowSideSummary(input.incomingResult);
|
||
const outgoing = deriveValueFlowSideSummary(input.outgoingResult);
|
||
const rankedIncoming = deriveRankedValueFlow(input.incomingResult, {
|
||
organizationScope: input.organizationScope,
|
||
periodScope: input.periodScope,
|
||
direction: "incoming_customer_revenue",
|
||
rankingNeed: "top_desc"
|
||
});
|
||
const rankedOutgoing = deriveRankedValueFlow(input.outgoingResult, {
|
||
organizationScope: input.organizationScope,
|
||
periodScope: input.periodScope,
|
||
direction: "outgoing_supplier_payout",
|
||
rankingNeed: "top_desc"
|
||
});
|
||
const yearlyBreakdown = deriveBusinessOverviewYearlyBreakdown({
|
||
incomingResult: input.incomingResult,
|
||
outgoingResult: input.outgoingResult
|
||
});
|
||
const activityPeriod = deriveActivityPeriod(input.lifecycleResult);
|
||
const taxPosition = deriveBusinessOverviewTaxPosition(input.taxResult, input.periodScope);
|
||
const accountingFinancialResult = deriveBusinessOverviewAccountingFinancialResult(input.accountingFinancialResultResult, input.periodScope);
|
||
const tradingMarginProxy = deriveBusinessOverviewTradingMarginProxy(input.tradingMarginResult, input.periodScope);
|
||
const debtPosition = deriveBusinessOverviewDebtPosition({
|
||
receivablesResult: input.receivablesResult,
|
||
payablesResult: input.payablesResult,
|
||
debtAsOfDate: input.debtAsOfDate
|
||
});
|
||
const debtOpenSettlementQuality = deriveBusinessOverviewDebtOpenSettlementQuality({
|
||
openContractsResult: input.openContractsResult,
|
||
debtAsOfDate: input.debtAsOfDate
|
||
});
|
||
const documentActivityProfile = deriveBusinessOverviewDocumentActivityProfile(input.documentActivityProfileResult, input.periodScope);
|
||
const counterpartyProfile = deriveBusinessOverviewCounterpartyProfile(input.counterpartyProfileResult, input.periodScope);
|
||
const contractUsageProfile = deriveBusinessOverviewContractUsageProfile(input.contractUsageProfileResult, input.periodScope);
|
||
const debtStalenessRiskProxy = deriveBusinessOverviewDebtStalenessRiskProxy(debtOpenSettlementQuality);
|
||
const debtDueDateAging = deriveBusinessOverviewDebtDueDateAging({
|
||
dueDateResult: input.dueDateAgingResult,
|
||
debtAsOfDate: input.debtAsOfDate
|
||
});
|
||
const inventoryPosition = deriveBusinessOverviewInventoryPosition({
|
||
inventoryOnHandResult: input.inventoryOnHandResult,
|
||
inventoryAgingResult: input.inventoryAgingResult,
|
||
inventoryAsOfDate: input.inventoryAsOfDate
|
||
});
|
||
const inventoryTurnoverProxy = deriveBusinessOverviewInventoryTurnoverProxy({
|
||
inventoryPosition,
|
||
tradingMarginProxy
|
||
});
|
||
const inventoryStalenessRiskProxy = deriveBusinessOverviewInventoryStalenessRiskProxy({
|
||
inventoryPosition,
|
||
inventoryTurnoverProxy
|
||
});
|
||
const inventoryQualityEvents = deriveBusinessOverviewInventoryQualityEvents({
|
||
inventoryQualityEventsResult: input.inventoryQualityEventsResult,
|
||
periodScope: input.periodScope
|
||
});
|
||
const vendorProcurementQuality = deriveBusinessOverviewVendorProcurementQuality({
|
||
rankedOutgoing,
|
||
outgoing,
|
||
counterpartyProfile,
|
||
contractUsageProfile,
|
||
periodScope: input.periodScope
|
||
});
|
||
const checkedSignalCount = [
|
||
incoming.rows_with_amount > 0,
|
||
outgoing.rows_with_amount > 0,
|
||
Boolean(activityPeriod),
|
||
Boolean(taxPosition),
|
||
Boolean(accountingFinancialResult),
|
||
Boolean(tradingMarginProxy),
|
||
Boolean(debtPosition),
|
||
Boolean(debtOpenSettlementQuality),
|
||
Boolean(debtStalenessRiskProxy),
|
||
Boolean(debtDueDateAging),
|
||
Boolean(documentActivityProfile),
|
||
Boolean(counterpartyProfile),
|
||
Boolean(contractUsageProfile),
|
||
Boolean(inventoryPosition),
|
||
Boolean(inventoryTurnoverProxy),
|
||
Boolean(inventoryStalenessRiskProxy),
|
||
Boolean(inventoryQualityEvents),
|
||
Boolean(vendorProcurementQuality)
|
||
].filter(Boolean).length;
|
||
if (checkedSignalCount <= 0) {
|
||
return null;
|
||
}
|
||
const netAmount = incoming.total_amount - outgoing.total_amount;
|
||
const hasBusinessOverviewProfileSignal = Boolean(documentActivityProfile || counterpartyProfile || contractUsageProfile);
|
||
const missingSignalFamilies = [
|
||
accountingFinancialResult ? null : tradingMarginProxy ? "accounting_profit_margin" : "profit_margin",
|
||
debtPosition ? null : "debt_position",
|
||
debtDueDateAging ? null : debtOpenSettlementQuality ? "debt_due_date_aging_quality" : "debt_open_settlement_quality",
|
||
taxPosition ? null : "tax_position",
|
||
inventoryPosition
|
||
? inventoryQualityEvents
|
||
? null
|
||
: inventoryStalenessRiskProxy
|
||
? "inventory_reserve_liquidation_quality"
|
||
: inventoryTurnoverProxy
|
||
? "inventory_liquidity_quality"
|
||
: "inventory_turnover_quality"
|
||
: "inventory_position",
|
||
inventoryPosition?.aging_signal ? null : "inventory_aging_quality"
|
||
].filter((item) => Boolean(item));
|
||
const missingProofFamilies = buildBusinessOverviewMissingProofFamilies({
|
||
missingSignalFamilies,
|
||
accountingFinancialResult,
|
||
tradingMarginProxy,
|
||
debtOpenSettlementQuality,
|
||
debtStalenessRiskProxy,
|
||
debtDueDateAging,
|
||
inventoryPosition,
|
||
inventoryTurnoverProxy,
|
||
inventoryStalenessRiskProxy,
|
||
inventoryQualityEvents,
|
||
vendorProcurementQuality,
|
||
hasSupplierConcentrationSignal: (rankedOutgoing?.ranked_values.length ?? 0) > 0
|
||
});
|
||
return {
|
||
organization_scope: input.organizationScope,
|
||
period_scope: input.periodScope,
|
||
incoming_customer_revenue: incoming,
|
||
outgoing_supplier_payout: outgoing,
|
||
net_amount: netAmount,
|
||
net_amount_human_ru: formatAmountHumanRu(Math.abs(netAmount)),
|
||
net_direction: netDirectionFromAmount(netAmount),
|
||
top_customers: rankedIncoming?.ranked_values ?? [],
|
||
top_suppliers: rankedOutgoing?.ranked_values ?? [],
|
||
yearly_breakdown: yearlyBreakdown,
|
||
activity_period: activityPeriod,
|
||
tax_position: taxPosition,
|
||
accounting_financial_result: accountingFinancialResult,
|
||
trading_margin_proxy: tradingMarginProxy,
|
||
debt_position: debtPosition,
|
||
debt_open_settlement_quality: debtOpenSettlementQuality,
|
||
debt_staleness_risk_proxy: debtStalenessRiskProxy,
|
||
debt_due_date_aging: debtDueDateAging,
|
||
inventory_position: inventoryPosition,
|
||
inventory_turnover_proxy: inventoryTurnoverProxy,
|
||
inventory_staleness_risk_proxy: inventoryStalenessRiskProxy,
|
||
inventory_quality_events: inventoryQualityEvents,
|
||
document_activity_profile: documentActivityProfile,
|
||
counterparty_profile: counterpartyProfile,
|
||
contract_usage_profile: contractUsageProfile,
|
||
vendor_procurement_quality: vendorProcurementQuality,
|
||
coverage_limited_by_probe_limit: incoming.coverage_limited_by_probe_limit || outgoing.coverage_limited_by_probe_limit,
|
||
checked_signal_count: checkedSignalCount,
|
||
missing_signal_families: missingSignalFamilies,
|
||
missing_proof_families: missingProofFamilies,
|
||
inference_basis: hasBusinessOverviewProfileSignal || inventoryPosition || inventoryQualityEvents || accountingFinancialResult
|
||
? "business_overview_from_confirmed_1c_multi_family_rows"
|
||
: debtOpenSettlementQuality || debtDueDateAging
|
||
? "business_overview_from_confirmed_1c_multi_family_rows"
|
||
: taxPosition && debtPosition
|
||
? "business_overview_from_confirmed_1c_money_activity_tax_and_debt_rows"
|
||
: taxPosition
|
||
? "business_overview_from_confirmed_1c_money_activity_and_tax_rows"
|
||
: debtPosition
|
||
? "business_overview_from_confirmed_1c_money_activity_and_debt_rows"
|
||
: "business_overview_from_confirmed_1c_money_and_activity_rows"
|
||
};
|
||
}
|
||
function summarizeBusinessOverviewRows(input) {
|
||
const parts = [];
|
||
if (input.incomingResult && !input.incomingResult.error) {
|
||
parts.push(`${input.incomingResult.fetched_rows} incoming rows fetched, ${input.incomingResult.matched_rows} matched`);
|
||
}
|
||
if (input.outgoingResult && !input.outgoingResult.error) {
|
||
parts.push(`${input.outgoingResult.fetched_rows} outgoing rows fetched, ${input.outgoingResult.matched_rows} matched`);
|
||
}
|
||
if (input.lifecycleResult && !input.lifecycleResult.error) {
|
||
parts.push(`${input.lifecycleResult.fetched_rows} activity/document rows fetched, ${input.lifecycleResult.matched_rows} matched`);
|
||
}
|
||
if (input.taxResult && !input.taxResult.error) {
|
||
parts.push(`${input.taxResult.fetched_rows} VAT/tax rows fetched, ${input.taxResult.matched_rows} matched`);
|
||
}
|
||
if (input.accountingFinancialResultResult && !input.accountingFinancialResultResult.error) {
|
||
parts.push(`${input.accountingFinancialResultResult.fetched_rows} accounting financial-result aggregate rows fetched, ${input.accountingFinancialResultResult.matched_rows} matched`);
|
||
}
|
||
if (input.tradingMarginResult && !input.tradingMarginResult.error) {
|
||
parts.push(`${input.tradingMarginResult.fetched_rows} trading-margin document rows fetched, ${input.tradingMarginResult.matched_rows} matched`);
|
||
}
|
||
if (input.receivablesResult && !input.receivablesResult.error) {
|
||
parts.push(`${input.receivablesResult.fetched_rows} receivables rows fetched, ${input.receivablesResult.matched_rows} matched`);
|
||
}
|
||
if (input.payablesResult && !input.payablesResult.error) {
|
||
parts.push(`${input.payablesResult.fetched_rows} payables rows fetched, ${input.payablesResult.matched_rows} matched`);
|
||
}
|
||
if (input.openContractsResult && !input.openContractsResult.error) {
|
||
parts.push(`${input.openContractsResult.fetched_rows} open-contract rows fetched, ${input.openContractsResult.matched_rows} matched`);
|
||
}
|
||
if (input.dueDateAgingResult && !input.dueDateAgingResult.error) {
|
||
parts.push(`${input.dueDateAgingResult.fetched_rows} due-date aging rows fetched, ${input.dueDateAgingResult.matched_rows} matched`);
|
||
}
|
||
if (input.documentActivityProfileResult && !input.documentActivityProfileResult.error) {
|
||
parts.push(`${input.documentActivityProfileResult.fetched_rows} document/account-section profile rows fetched, ${input.documentActivityProfileResult.matched_rows} matched`);
|
||
}
|
||
if (input.counterpartyProfileResult && !input.counterpartyProfileResult.error) {
|
||
parts.push(`${input.counterpartyProfileResult.fetched_rows} counterparty role-profile rows fetched, ${input.counterpartyProfileResult.matched_rows} matched`);
|
||
}
|
||
if (input.contractUsageProfileResult && !input.contractUsageProfileResult.error) {
|
||
parts.push(`${input.contractUsageProfileResult.fetched_rows} contract-usage profile rows fetched, ${input.contractUsageProfileResult.matched_rows} matched`);
|
||
}
|
||
if (input.inventoryOnHandResult && !input.inventoryOnHandResult.error) {
|
||
parts.push(`${input.inventoryOnHandResult.fetched_rows} inventory on-hand rows fetched, ${input.inventoryOnHandResult.matched_rows} matched`);
|
||
}
|
||
if (input.inventoryAgingResult && !input.inventoryAgingResult.error) {
|
||
parts.push(`${input.inventoryAgingResult.fetched_rows} inventory aging rows fetched, ${input.inventoryAgingResult.matched_rows} matched`);
|
||
}
|
||
if (input.inventoryQualityEventsResult && !input.inventoryQualityEventsResult.error) {
|
||
parts.push(`${input.inventoryQualityEventsResult.fetched_rows} inventory quality-event rows fetched, ${input.inventoryQualityEventsResult.matched_rows} matched`);
|
||
}
|
||
return parts.length > 0 ? parts.join("; ") : null;
|
||
}
|
||
function financialFlowHintTextRu(bucket) {
|
||
const rows = bucket?.financial_flow_hint_rows ?? 0;
|
||
const rowsText = rows > 0 ? ` (${rows} строк)` : "";
|
||
if (bucket?.financial_flow_hint === "loan_or_credit") {
|
||
return ` По полям банковского документа доминирует кредитный/заемный признак${rowsText}.`;
|
||
}
|
||
if (bucket?.financial_flow_hint === "bank_fee_or_service") {
|
||
return ` По полям банковского документа доминирует признак банковской комиссии/услуг банка${rowsText}.`;
|
||
}
|
||
if (bucket?.financial_flow_hint === "tax_or_budget") {
|
||
return ` По полям банковского документа доминирует налоговый/бюджетный признак${rowsText}.`;
|
||
}
|
||
if (bucket?.financial_flow_hint === "payroll_or_social") {
|
||
return ` По полям банковского документа доминирует зарплатный/социальный признак${rowsText}.`;
|
||
}
|
||
if (bucket?.financial_flow_hint === "supplier_payment") {
|
||
return ` По полям банковского документа доминирует признак оплаты поставщику${rowsText}; все равно нужна осторожность, если контрагент по названию является банком.`;
|
||
}
|
||
return "";
|
||
}
|
||
function buildBusinessOverviewConfirmedFacts(derived) {
|
||
if (!derived) {
|
||
return [];
|
||
}
|
||
const facts = [];
|
||
const organization = derived.organization_scope ? ` по организации ${derived.organization_scope}` : "";
|
||
const period = derived.period_scope ? ` за ${derived.period_scope}` : " за все доступное проверенное окно";
|
||
if (derived.incoming_customer_revenue.rows_with_amount > 0) {
|
||
facts.push(`В 1С подтверждены входящие поступления${organization}${period}: ${derived.incoming_customer_revenue.total_amount_human_ru} по ${derived.incoming_customer_revenue.rows_with_amount} строкам с суммой.`);
|
||
}
|
||
if (derived.outgoing_supplier_payout.rows_with_amount > 0) {
|
||
facts.push(`В 1С подтверждены исходящие платежи/списания${organization}${period}: ${derived.outgoing_supplier_payout.total_amount_human_ru} по ${derived.outgoing_supplier_payout.rows_with_amount} строкам с суммой.`);
|
||
}
|
||
if (derived.top_customers.length > 0) {
|
||
const leader = derived.top_customers[0];
|
||
if ((0, counterpartyRoleHeuristics_1.isLikelyFinancialInstitutionCounterparty)(leader.axis_value)) {
|
||
facts.push(`Крупнейший входящий денежный источник в проверенном срезе: ${leader.axis_value} — ${leader.total_amount_human_ru}. По названию это банк/финансовая организация, поэтому без назначения платежа это не доказанный клиент или бизнес-выручка.`);
|
||
const financialHintText = financialFlowHintTextRu(leader);
|
||
if (financialHintText) {
|
||
facts.push(financialHintText.trim());
|
||
}
|
||
const nonFinancialLeader = derived.top_customers.slice(1).find((item) => !(0, counterpartyRoleHeuristics_1.isLikelyFinancialInstitutionCounterparty)(item.axis_value));
|
||
if (nonFinancialLeader) {
|
||
facts.push(`Крупнейший небанковский входящий контрагент в проверенном срезе: ${nonFinancialLeader.axis_value} — ${nonFinancialLeader.total_amount_human_ru}.`);
|
||
}
|
||
}
|
||
else {
|
||
facts.push(`Самый крупный подтвержденный клиент в проверенном срезе: ${leader.axis_value} — ${leader.total_amount_human_ru}.`);
|
||
}
|
||
}
|
||
if (derived.top_suppliers.length > 0) {
|
||
const leader = derived.top_suppliers[0];
|
||
if ((0, counterpartyRoleHeuristics_1.isLikelyFinancialInstitutionCounterparty)(leader.axis_value)) {
|
||
facts.push(`Крупнейший получатель исходящих денег в проверенном срезе: ${leader.axis_value} — ${leader.total_amount_human_ru}. По названию это банк/финансовая организация, поэтому без назначения платежа/договора это не доказанный обычный поставщик.`);
|
||
const financialHintText = financialFlowHintTextRu(leader);
|
||
if (financialHintText) {
|
||
facts.push(financialHintText.trim());
|
||
}
|
||
const nonFinancialLeader = derived.top_suppliers.slice(1).find((item) => !(0, counterpartyRoleHeuristics_1.isLikelyFinancialInstitutionCounterparty)(item.axis_value));
|
||
if (nonFinancialLeader) {
|
||
facts.push(`Крупнейший небанковский получатель исходящих денег в проверенном срезе: ${nonFinancialLeader.axis_value} — ${nonFinancialLeader.total_amount_human_ru}.`);
|
||
}
|
||
}
|
||
else {
|
||
facts.push(`Самый крупный подтвержденный поставщик/получатель исходящих платежей в проверенном срезе: ${leader.axis_value} — ${leader.total_amount_human_ru}.`);
|
||
}
|
||
}
|
||
if (derived.yearly_breakdown.length > 0) {
|
||
facts.push(`Годовая раскладка операционного денежного потока построена по подтвержденным строкам 1С за ${yearCountHumanRu(derived.yearly_breakdown.length)}.`);
|
||
}
|
||
if (derived.activity_period) {
|
||
facts.push(`Подтвержденное окно активности в 1С: ${derived.activity_period.first_activity_date} — ${derived.activity_period.latest_activity_date}.`);
|
||
}
|
||
if (derived.document_activity_profile) {
|
||
const profile = derived.document_activity_profile;
|
||
const topDocument = profile.top_document_types[0];
|
||
const topSection = profile.top_account_sections[0];
|
||
const parts = [];
|
||
if (topDocument) {
|
||
const shareText = topDocument.share_pct === null ? "" : ` (${topDocument.share_pct}%)`;
|
||
parts.push(`ведущий тип документов ${topDocument.document_type} — ${topDocument.count} документов${shareText}`);
|
||
}
|
||
if (topSection) {
|
||
const shareText = topSection.share_pct === null ? "" : ` (${topSection.share_pct}%)`;
|
||
parts.push(`ведущий раздел учета ${topSection.account_section} — ${topSection.operation_count} операций${shareText}`);
|
||
}
|
||
if (parts.length > 0) {
|
||
facts.push(`Профиль операционной активности${organization}${period} подтвержден по типам документов и разделам учета 1С: ${parts.join("; ")}. Это activity mix, а не аудит качества учета или полноты бизнес-процессов.`);
|
||
}
|
||
}
|
||
if (derived.counterparty_profile) {
|
||
const profile = derived.counterparty_profile;
|
||
const totalText = profile.total_counterparties === null
|
||
? `${profile.active_counterparties} активных контрагентов`
|
||
: `${profile.total_counterparties} контрагентов в базе, ${profile.active_counterparties} активных по документальной активности`;
|
||
facts.push(`Профиль контрагентской базы${organization}${period} подтвержден по 1С: ${totalText}; заказчики ${profile.customer_only_count}, поставщики ${profile.supplier_only_count}, смешанная роль ${profile.mixed_role_count}. Это не CRM-аудит, не юридическая проверка контрагентов и не оценка качества клиентской базы.`);
|
||
}
|
||
if (derived.contract_usage_profile) {
|
||
const profile = derived.contract_usage_profile;
|
||
const totalText = profile.total_contracts === null
|
||
? `${profile.used_contracts} договоров с подтвержденной связью с операциями`
|
||
: `${profile.used_contracts} из ${profile.total_contracts} договоров используются${profile.used_contract_share_pct === null ? "" : ` (${profile.used_contract_share_pct}%)`}`;
|
||
const unusedText = profile.unused_contracts === null ? "" : `, неиспользуемых ${profile.unused_contracts}`;
|
||
facts.push(`Договорной профиль${organization}${period} подтвержден по 1С: ${totalText}${unusedText}. Это не contract-risk аудит, не проверка актуальности условий и не доказательство качества договорной базы.`);
|
||
}
|
||
if (derived.tax_position) {
|
||
const taxDirection = derived.tax_position.net_vat_direction === "vat_to_pay"
|
||
? "к уплате"
|
||
: derived.tax_position.net_vat_direction === "vat_to_recover_or_offset"
|
||
? "к вычету/зачету"
|
||
: "сбалансирован";
|
||
facts.push(`НДС-позиция за ${derived.tax_position.period_scope} подтверждена по книгам продаж/покупок: продажи ${derived.tax_position.sales_vat_amount_human_ru}, покупки/вычеты ${derived.tax_position.purchase_vat_amount_human_ru}, нетто ${taxDirection} ${derived.tax_position.net_vat_amount_human_ru}.`);
|
||
}
|
||
if (derived.trading_margin_proxy) {
|
||
const proxy = derived.trading_margin_proxy;
|
||
const marginText = proxy.margin_to_revenue_pct === null ? "не рассчитана" : `${proxy.margin_to_revenue_pct}%`;
|
||
facts.push(`Торговый margin proxy за ${proxy.period_scope} подтвержден по товарным документам продаж/поступлений: выручка продаж ${proxy.sales_revenue_human_ru}, закупочный документный след ${proxy.purchase_cost_proxy_human_ru}, валовый спред proxy ${proxy.gross_spread_proxy_human_ru}, маржинальность к выручке ${marginText}. Это не чистая прибыль и не бухгалтерский финрезультат.`);
|
||
}
|
||
if (derived.debt_position) {
|
||
const debtDirection = derived.debt_position.net_debt_position_direction === "net_receivable"
|
||
? "в пользу дебиторки"
|
||
: derived.debt_position.net_debt_position_direction === "net_payable"
|
||
? "в сторону кредиторки"
|
||
: "сбалансировано";
|
||
facts.push(`Долговая позиция на ${derived.debt_position.as_of_date} подтверждена по срезам дебиторки/кредиторки 1С: дебиторка ${derived.debt_position.receivables.total_amount_human_ru}, кредиторка ${derived.debt_position.payables.total_amount_human_ru}, нетто ${debtDirection} ${derived.debt_position.net_debt_position_amount_human_ru}.`);
|
||
}
|
||
if (derived.debt_open_settlement_quality) {
|
||
const quality = derived.debt_open_settlement_quality;
|
||
const leader = quality.top_contracts[0];
|
||
const leaderShareText = leader?.share_of_gross_open_amount_pct === null || leader?.share_of_gross_open_amount_pct === undefined
|
||
? ""
|
||
: ` (${leader.share_of_gross_open_amount_pct}%)`;
|
||
const leaderText = leader
|
||
? ` Крупнейший открытый договор: ${leader.contract}${leader.counterparty ? ` / ${leader.counterparty}` : ""} — ${leader.total_amount_human_ru}${leaderShareText}.`
|
||
: "";
|
||
facts.push(`Качество открытых расчетов на ${quality.as_of_date} проверено по договорным остаткам 60/62/76: брутто ${quality.gross_open_amount_human_ru}, договоров ${quality.unique_contracts}, контрагентов ${quality.unique_counterparties}.${leaderText}`);
|
||
if (quality.age_signal?.oldest_start_date) {
|
||
const ageText = quality.age_signal.max_age_days === null
|
||
? ""
|
||
: `, максимальный возраст сигнала ${quality.age_signal.max_age_days} дн.`;
|
||
facts.push(`Возрастной сигнал открытых расчетов подтвержден по датам договоров: самая ранняя дата договора ${quality.age_signal.oldest_start_date}${ageText}. Это не договорная просрочка и не due-date анализ.`);
|
||
}
|
||
}
|
||
if (derived.debt_staleness_risk_proxy) {
|
||
const proxy = derived.debt_staleness_risk_proxy;
|
||
const counterpartyText = proxy.top_contract_counterparty ? ` / ${proxy.top_contract_counterparty}` : "";
|
||
facts.push(`Staleness risk proxy открытых расчетов на ${proxy.as_of_date}: самый старый договорный сигнал ${proxy.oldest_contract_start_date}, возраст ${proxy.max_contract_age_days} дн.; старейший крупный договор ${proxy.top_contract}${counterpartyText} держит ${proxy.top_contract_amount_human_ru} (${proxy.top_contract_share_pct}% брутто открытых остатков); оценка ${debtStalenessRiskBandRu(proxy.risk_band)}. Это не подтвержденная просрочка, не кредитный риск и не due-date aging.`);
|
||
}
|
||
if (derived.debt_due_date_aging) {
|
||
const aging = derived.debt_due_date_aging;
|
||
if (aging.evidence_status === "confirmed_overdue") {
|
||
const top = aging.top_overdue_items[0];
|
||
const topText = top
|
||
? ` Самая старая просрочка: ${top.due_date}, ${top.overdue_days} дн., ${top.amount_human_ru}${top.contract ? ` по договору ${top.contract}` : ""}.`
|
||
: "";
|
||
facts.push(`Due-date aging открытых расчетов на ${aging.as_of_date} проверен по срокам оплаты договоров и датам расчетных документов: подтверждено просроченных строк ${aging.overdue_rows}, сумма ${aging.overdue_amount_human_ru}.${topText}`);
|
||
}
|
||
else if (aging.evidence_status === "no_payment_terms_configured") {
|
||
facts.push(`Due-date aging открытых расчетов на ${aging.as_of_date} проверен по ${aging.rows_with_amount} строкам с суммой: брутто открытых остатков ${aging.gross_open_amount_human_ru}, но в проверенных договорах срок оплаты не установлен. Подтвержденной просрочки по договорным срокам оплаты нет.`);
|
||
}
|
||
else if (aging.evidence_status === "insufficient_due_date_basis") {
|
||
facts.push(`Due-date aging открытых расчетов на ${aging.as_of_date} запускался по ${aging.rows_with_payment_terms} строкам с установленным сроком оплаты, но в найденных строках не хватило даты расчетного документа для честного расчета due date. Просрочка не подтверждена.`);
|
||
}
|
||
else {
|
||
facts.push(`Due-date aging открытых расчетов на ${aging.as_of_date} проверен: строк с установленным сроком оплаты ${aging.rows_with_payment_terms}, подтвержденной просрочки не найдено; не просрочено по расчету ${aging.not_yet_due_amount_human_ru}.`);
|
||
}
|
||
}
|
||
if (derived.inventory_position) {
|
||
const leader = derived.inventory_position.top_items[0];
|
||
const leaderText = leader
|
||
? ` Крупнейшая подтвержденная позиция: ${leader.item} — ${leader.total_amount_human_ru}.`
|
||
: "";
|
||
facts.push(`Складской срез на ${derived.inventory_position.as_of_date} подтвержден по 1С: остаток ${derived.inventory_position.total_amount_human_ru} по ${derived.inventory_position.rows_with_amount} строкам с суммой и ${derived.inventory_position.rows_with_quantity} строкам с количеством.${leaderText}`);
|
||
if (derived.inventory_position.aging_signal?.oldest_purchase_date) {
|
||
const ageText = derived.inventory_position.aging_signal.max_age_days === null
|
||
? ""
|
||
: `, максимальный возраст сигнала ${derived.inventory_position.aging_signal.max_age_days} дн.`;
|
||
facts.push(`Возрастной сигнал склада подтвержден по найденным строкам закупок: самая ранняя дата ${derived.inventory_position.aging_signal.oldest_purchase_date}${ageText}.`);
|
||
}
|
||
}
|
||
if (derived.inventory_turnover_proxy) {
|
||
const proxy = derived.inventory_turnover_proxy;
|
||
const ratioText = proxy.sales_to_stock_amount_ratio === null
|
||
? "не рассчитано"
|
||
: `${proxy.sales_to_stock_amount_ratio}x`;
|
||
const stockShareText = proxy.stock_to_sales_revenue_pct === null
|
||
? "не рассчитана"
|
||
: `${proxy.stock_to_sales_revenue_pct}%`;
|
||
facts.push(`Оборотный proxy склада за ${proxy.period_scope} подтвержден по продажным документам и складскому остатку: продажи ${proxy.sales_revenue_human_ru}, остаток на ${proxy.as_of_date} ${proxy.inventory_amount_human_ru}, sales-to-stock ratio ${ratioText}, остаток к продажам ${stockShareText}. Это не полноценная складская ликвидность, не FIFO-оборачиваемость и не анализ устаревания.`);
|
||
}
|
||
if (derived.inventory_staleness_risk_proxy) {
|
||
const proxy = derived.inventory_staleness_risk_proxy;
|
||
facts.push(`Staleness risk proxy склада на ${proxy.as_of_date}: самая ранняя дата закупочного сигнала ${proxy.oldest_purchase_date}, возраст ${proxy.max_purchase_age_days} дн., sales-to-stock ${proxy.sales_to_stock_amount_ratio}x, оценка ${inventoryStalenessRiskBandRu(proxy.risk_band)}. Это не подтвержденная неликвидность, не резерв и не ликвидационная стоимость.`);
|
||
}
|
||
if (derived.inventory_quality_events) {
|
||
const quality = derived.inventory_quality_events;
|
||
const eventWindow = quality.first_event_date && quality.latest_event_date
|
||
? ` Окно найденных событий: ${quality.first_event_date} — ${quality.latest_event_date}.`
|
||
: "";
|
||
if (quality.evidence_status === "reviewed_no_quality_events_found") {
|
||
facts.push(`Reviewed inventory quality route проверил складские документы списания, оприходования, инвентаризации и переоценки${period}: подтвержденных событий не найдено. Это проверенный отрицательный результат по доступным документам, но не рыночная ликвидационная оценка и не управленческий резерв.`);
|
||
}
|
||
else {
|
||
facts.push(`Reviewed inventory quality route проверил складские документы${period}: списаний ${quality.writeoff_rows} на ${quality.writeoff_amount_human_ru}, оприходований/корректировок ${quality.receipt_adjustment_rows} на ${quality.receipt_adjustment_amount_human_ru}, инвентаризаций ${quality.inventory_count_rows}, переоценок ${quality.revaluation_rows}.${eventWindow} Это подтвержденные документы 1С, но не самостоятельная рыночная ликвидационная стоимость.`);
|
||
}
|
||
}
|
||
return facts;
|
||
}
|
||
function buildBusinessOverviewInferredFacts(derived) {
|
||
if (!derived) {
|
||
return [];
|
||
}
|
||
if (derived.incoming_customer_revenue.rows_with_amount <= 0 &&
|
||
derived.outgoing_supplier_payout.rows_with_amount <= 0) {
|
||
return [];
|
||
}
|
||
const direction = derived.net_direction === "net_incoming"
|
||
? "денежный поток в проверенном срезе больше входящий, чем исходящий"
|
||
: derived.net_direction === "net_outgoing"
|
||
? "денежный поток в проверенном срезе больше исходящий, чем входящий"
|
||
: "входящий и исходящий денежный поток в проверенном срезе примерно сбалансированы";
|
||
const supplierLeader = derived.top_suppliers[0];
|
||
const supplierSharePct = supplierLeader
|
||
? percentageOfTotal(supplierLeader.total_amount, derived.outgoing_supplier_payout.total_amount)
|
||
: null;
|
||
const supplierLeaderIsFinancial = supplierLeader
|
||
? (0, counterpartyRoleHeuristics_1.isLikelyFinancialInstitutionCounterparty)(supplierLeader.axis_value)
|
||
: false;
|
||
const strongestIncomingYear = [...derived.yearly_breakdown]
|
||
.filter((bucket) => bucket.incoming_total_amount > 0)
|
||
.sort((left, right) => right.incoming_total_amount - left.incoming_total_amount || left.year_bucket.localeCompare(right.year_bucket))[0];
|
||
const strongestNetYear = [...derived.yearly_breakdown]
|
||
.filter((bucket) => bucket.net_amount !== 0)
|
||
.sort((left, right) => right.net_amount - left.net_amount || left.year_bucket.localeCompare(right.year_bucket))[0];
|
||
return [
|
||
`Расчетное нетто по найденным строкам: ${derived.net_amount_human_ru}; ${direction}.`,
|
||
supplierLeader
|
||
? supplierLeaderIsFinancial
|
||
? supplierSharePct !== null
|
||
? `Крупнейший получатель исходящих денег ${supplierLeader.axis_value} держит около ${supplierSharePct}% проверенного исходящего потока (${supplierLeader.total_amount_human_ru}). По названию это банк/финансовая организация, поэтому это outgoing cash concentration proxy, а не доказанный vendor-risk по обычному поставщику.`
|
||
: `Крупнейший получатель исходящих денег в проверенном срезе: ${supplierLeader.axis_value} — ${supplierLeader.total_amount_human_ru}. По названию это банк/финансовая организация, поэтому это не доказанный обычный поставщик.`
|
||
: supplierSharePct !== null
|
||
? `Крупнейший подтвержденный поставщик/получатель исходящих платежей ${supplierLeader.axis_value} держит около ${supplierSharePct}% проверенного исходящего потока (${supplierLeader.total_amount_human_ru}). Это procurement concentration proxy по найденным строкам, а не полный vendor-risk аудит.`
|
||
: `Крупнейший подтвержденный поставщик/получатель исходящих платежей в проверенном срезе: ${supplierLeader.axis_value} — ${supplierLeader.total_amount_human_ru}.`
|
||
: null,
|
||
strongestIncomingYear
|
||
? `Самый сильный год по подтвержденным входящим поступлениям: ${strongestIncomingYear.year_bucket} (${strongestIncomingYear.incoming_total_amount_human_ru}).`
|
||
: null,
|
||
strongestNetYear
|
||
? `Лучший год по расчетному операционному нетто найденных строк: ${strongestNetYear.year_bucket} (${netDirectionFromAmount(strongestNetYear.net_amount) === "net_outgoing" ? "нетто исходящее" : "нетто в плюс"} ${strongestNetYear.net_amount_human_ru}). Это не бухгалтерская прибыль.`
|
||
: null,
|
||
"Это операционный денежный сигнал по найденным строкам 1С, а не прибыль, маржа или бухгалтерское заключение о здоровье бизнеса."
|
||
].filter((fact) => Boolean(fact));
|
||
}
|
||
function buildBusinessOverviewUnknownFacts(derived) {
|
||
const missing = new Set(derived?.missing_signal_families ?? [
|
||
"profit_margin",
|
||
"debt_position",
|
||
"tax_position",
|
||
"inventory_position"
|
||
]);
|
||
const unknowns = [
|
||
missing.has("profit_margin")
|
||
? "Прибыль и маржа этим бизнес-обзором не подтверждены: нужны себестоимость, расходы и закрывающие документы."
|
||
: null,
|
||
missing.has("accounting_profit_margin")
|
||
? "Чистая прибыль, бухгалтерская маржа и финрезультат этим бизнес-обзором не подтверждены: торговый proxy показывает только документную разницу продаж и поступлений без расходов, закрытия периода и точной себестоимости продаж."
|
||
: null,
|
||
missing.has("debt_quality")
|
||
? "Качество дебиторки/кредиторки этим бизнес-обзором не подтверждено: нужен отдельный долговой срез."
|
||
: null,
|
||
missing.has("debt_position")
|
||
? "Дебиторка/кредиторка этим бизнес-обзором не подтверждены: нужен отдельный долговой срез на явную дату."
|
||
: null,
|
||
missing.has("debt_aging_quality")
|
||
? "Качество долга и просрочка этим бизнес-обзором не подтверждены: текущий долговой срез показывает только суммы на дату, без aging/due-date анализа."
|
||
: null,
|
||
missing.has("debt_open_settlement_quality")
|
||
? "Качество открытых расчетов этим бизнес-обзором не подтверждено: нужен срез открытых договоров на явную дату."
|
||
: null,
|
||
missing.has("debt_due_date_aging_quality")
|
||
? "Просрочка и due-date aging этим бизнес-обзором не подтверждены: открытые договоры показывают концентрацию остатков, но не договорные сроки оплаты."
|
||
: null,
|
||
missing.has("tax_position")
|
||
? "Налоговая/VAT-позиция этим бизнес-обзором не подтверждена: нужен отдельный налоговый контур или явный проверяемый период."
|
||
: null,
|
||
missing.has("inventory_health")
|
||
? "Складская ликвидность и товарные остатки этим бизнес-обзором не подтверждены: нужен отдельный inventory-срез."
|
||
: null,
|
||
missing.has("inventory_position")
|
||
? "Складской остаток этим бизнес-обзором не подтвержден: нужен отдельный inventory-срез на явную дату."
|
||
: null,
|
||
missing.has("inventory_aging_quality")
|
||
? "Возраст, залежалость и ликвидность склада этим бизнес-обзором не подтверждены: текущий складской срез показывает только остаток на дату без полноценной оборачиваемости."
|
||
: null,
|
||
missing.has("inventory_turnover_quality")
|
||
? "Скорость продаж, оборачиваемость и ликвидность склада этим бизнес-обзором не подтверждены: нужен отдельный inventory/продажный анализ, а не только остаток на дату."
|
||
: null,
|
||
missing.has("inventory_liquidity_quality")
|
||
? "Полная складская ликвидность этим бизнес-обзором не подтверждена: sales-to-stock proxy показывает только соотношение продажных документов и остатка на дату, без FIFO-оборачиваемости, устаревания, резервов и ликвидационной стоимости."
|
||
: null,
|
||
missing.has("inventory_reserve_liquidation_quality")
|
||
? "Резервы, списания, подтвержденная неликвидность и ликвидационная стоимость склада этим бизнес-обзором не подтверждены: staleness proxy показывает только возраст закупочного сигнала и sales-to-stock, без управленческого решения о запасах."
|
||
: null
|
||
].filter((item) => Boolean(item));
|
||
if (derived?.coverage_limited_by_probe_limit) {
|
||
unknowns.unshift("Полное покрытие бизнес-обзора не подтверждено: хотя бы один денежный probe достиг лимита строк.");
|
||
}
|
||
return unknowns;
|
||
}
|
||
function buildLifecycleConfirmedFacts(result, counterparty) {
|
||
if (result.error || result.matched_rows <= 0) {
|
||
return [];
|
||
}
|
||
return [
|
||
counterparty
|
||
? `1C activity rows were found for counterparty ${counterparty}; matched_rows=${result.matched_rows}`
|
||
: `1C activity rows were found for the requested counterparty scope; matched_rows=${result.matched_rows}`
|
||
];
|
||
}
|
||
function checkedCounterpartySuffixRu(counterparty) {
|
||
return counterparty ? ` по контрагенту ${counterparty}` : "";
|
||
}
|
||
function checkedPeriodSuffixRu(periodScope) {
|
||
return periodScope ? ` за ${periodScope}` : " в проверенном окне";
|
||
}
|
||
function uncheckedPeriodBoundaryRu(periodScope) {
|
||
return periodScope ? ` вне периода ${periodScope}` : " без явно проверенного периода";
|
||
}
|
||
function buildDocumentConfirmedFacts(result, counterparty, periodScope) {
|
||
if (result.error || result.matched_rows <= 0) {
|
||
return [];
|
||
}
|
||
return [`В 1С найдены строки документов${checkedCounterpartySuffixRu(counterparty)}${checkedPeriodSuffixRu(periodScope)}.`];
|
||
}
|
||
function buildMovementConfirmedFacts(result, counterparty, periodScope) {
|
||
if (result.error || result.matched_rows <= 0) {
|
||
return [];
|
||
}
|
||
return [`В 1С найдены строки движений${checkedCounterpartySuffixRu(counterparty)}${checkedPeriodSuffixRu(periodScope)}.`];
|
||
}
|
||
function buildValueFlowConfirmedFacts(result, counterparty, direction) {
|
||
if (result.error || result.matched_rows <= 0) {
|
||
return [];
|
||
}
|
||
if (direction === "outgoing_supplier_payout") {
|
||
return [
|
||
counterparty
|
||
? `1C supplier-payout rows were found for counterparty ${counterparty}`
|
||
: "1C supplier-payout rows were found for the requested counterparty scope"
|
||
];
|
||
}
|
||
return [
|
||
counterparty
|
||
? `1C value-flow rows were found for counterparty ${counterparty}`
|
||
: "1C value-flow rows were found for the requested counterparty scope"
|
||
];
|
||
}
|
||
function buildRankedValueFlowConfirmedFacts(derived) {
|
||
if (!derived || derived.ranked_values.length <= 0) {
|
||
return [];
|
||
}
|
||
const leader = derived.ranked_values[0];
|
||
const directionLabel = derived.value_flow_direction === "outgoing_supplier_payout" ? "supplier-payout" : "incoming value-flow";
|
||
return [
|
||
`1C ${directionLabel} rows were ranked by counterparty for the checked scope; leader=${leader.axis_value}, rows_with_amount=${leader.rows_with_amount}`
|
||
];
|
||
}
|
||
function buildBidirectionalValueFlowConfirmedFacts(derived) {
|
||
if (!derived) {
|
||
return [];
|
||
}
|
||
const hasIncoming = derived.incoming_customer_revenue.rows_matched > 0;
|
||
const hasOutgoing = derived.outgoing_supplier_payout.rows_matched > 0;
|
||
if (derived.counterparty) {
|
||
return [
|
||
`1C bidirectional value-flow rows were checked for counterparty ${derived.counterparty}: incoming=${hasIncoming ? "found" : "not_found"}, outgoing=${hasOutgoing ? "found" : "not_found"}`
|
||
];
|
||
}
|
||
return [
|
||
`1C bidirectional value-flow rows were checked for the requested counterparty scope: incoming=${hasIncoming ? "found" : "not_found"}, outgoing=${hasOutgoing ? "found" : "not_found"}`
|
||
];
|
||
}
|
||
function inventoryLabelRu(intent) {
|
||
if (intent === "inventory_supplier_stock_overlap_as_of_date") {
|
||
return "связи поставщиков с товарным остатком";
|
||
}
|
||
if (intent === "inventory_purchase_provenance_for_item") {
|
||
return "закупочной истории позиции";
|
||
}
|
||
if (intent === "inventory_sale_trace_for_item") {
|
||
return "продаж по позиции";
|
||
}
|
||
return "складского среза";
|
||
}
|
||
function inventoryScopeSuffixRu(input) {
|
||
const parts = [];
|
||
if (input.organization) {
|
||
parts.push(`по организации ${input.organization}`);
|
||
}
|
||
if (input.item) {
|
||
parts.push(`по позиции ${input.item}`);
|
||
}
|
||
if (input.intent === "inventory_supplier_stock_overlap_as_of_date" && input.counterparty) {
|
||
parts.push(`по поставщику/контрагенту ${input.counterparty}`);
|
||
}
|
||
if (input.asOfDate) {
|
||
parts.push(`на ${input.asOfDate}`);
|
||
}
|
||
else if (input.dateScope) {
|
||
parts.push(`за ${input.dateScope}`);
|
||
}
|
||
return parts.length > 0 ? ` ${parts.join(", ")}` : "";
|
||
}
|
||
function inventoryRowSample(row) {
|
||
const item = rowInventoryItemValue(row);
|
||
const quantity = rowQuantityValue(row);
|
||
const warehouse = rowWarehouseValue(row);
|
||
const counterparty = rowCounterpartyValue(row);
|
||
const document = rowDocumentValue(row);
|
||
const parts = [];
|
||
if (item) {
|
||
parts.push(item);
|
||
}
|
||
if (quantity !== null) {
|
||
parts.push(`${quantity} шт.`);
|
||
}
|
||
if (warehouse) {
|
||
parts.push(`склад ${warehouse}`);
|
||
}
|
||
if (counterparty) {
|
||
parts.push(`контрагент ${counterparty}`);
|
||
}
|
||
if (document) {
|
||
parts.push(`документ ${document}`);
|
||
}
|
||
return parts.length > 0 ? parts.join(", ") : null;
|
||
}
|
||
function buildInventoryConfirmedFacts(result, planner, intent) {
|
||
if (result.error || result.matched_rows <= 0) {
|
||
return [];
|
||
}
|
||
const dateScope = toNonEmptyString(planner.discovery_plan.turn_meaning_ref?.explicit_date_scope);
|
||
const item = intent === "inventory_purchase_provenance_for_item" || intent === "inventory_sale_trace_for_item"
|
||
? firstEntityCandidate(planner)
|
||
: null;
|
||
const counterparty = intent === "inventory_supplier_stock_overlap_as_of_date" ? firstEntityCandidate(planner) : null;
|
||
const scope = inventoryScopeSuffixRu({
|
||
intent,
|
||
item,
|
||
counterparty,
|
||
organization: organizationScopeForPlanner(planner),
|
||
asOfDate: asOfDateFromDateScope(dateScope),
|
||
dateScope
|
||
});
|
||
const samples = result.rows
|
||
.slice(0, 3)
|
||
.map((row) => inventoryRowSample(row))
|
||
.filter((value) => Boolean(value));
|
||
const sampleSuffix = samples.length > 0 ? ` Примеры строк: ${samples.join("; ")}.` : "";
|
||
return [`В 1С найдены подтвержденные строки ${inventoryLabelRu(intent)}${scope}: ${result.matched_rows}.${sampleSuffix}`];
|
||
}
|
||
function buildInventoryInferredFacts(result, intent) {
|
||
if (result.error || result.fetched_rows <= 0) {
|
||
return [];
|
||
}
|
||
if (result.matched_rows <= 0) {
|
||
return [
|
||
`По ${inventoryLabelRu(intent)} удалось проверить только ограниченный срез 1С; подтвержденных строк этим поиском не найдено.`
|
||
];
|
||
}
|
||
return [
|
||
`Вывод по ${inventoryLabelRu(intent)} ограничен найденными строками 1С и указанными датой, организацией, позицией или поставщиком.`
|
||
];
|
||
}
|
||
function buildInventoryUnknownFacts(result, intent, dateScope) {
|
||
const facts = [
|
||
dateScope
|
||
? `Полный товарный контур вне проверенного среза ${dateScope} не подтвержден.`
|
||
: "Полный товарный контур без явного проверенного периода или даты не подтвержден."
|
||
];
|
||
if (!result || result.error || result.matched_rows <= 0) {
|
||
facts.unshift(`Подтвержденный факт по ${inventoryLabelRu(intent)} в проверенных строках 1С не найден.`);
|
||
}
|
||
return facts;
|
||
}
|
||
function buildLifecycleInferredFacts(result) {
|
||
if (result.error || result.fetched_rows <= 0) {
|
||
return [];
|
||
}
|
||
const period = deriveActivityPeriod(result);
|
||
if (!period) {
|
||
return ["Business activity duration may be inferred only when confirmed 1C activity row dates are available"];
|
||
}
|
||
return [
|
||
"Business activity duration may be inferred from first and latest confirmed 1C activity rows",
|
||
`Activity window is bounded by first=${period.first_activity_date}, latest=${period.latest_activity_date}, matched_rows=${period.matched_rows}`,
|
||
"Activity-window inference is not legal registration age"
|
||
];
|
||
}
|
||
function buildDocumentInferredFacts(result, counterparty, periodScope) {
|
||
if (result.error || result.fetched_rows <= 0) {
|
||
return [];
|
||
}
|
||
if (result.matched_rows <= 0) {
|
||
return [
|
||
`По документам${checkedCounterpartySuffixRu(counterparty)}${checkedPeriodSuffixRu(periodScope)} удалось проверить только ограниченный срез 1С; подтвержденных строк документов этим поиском не найдено.`
|
||
];
|
||
}
|
||
return [
|
||
`Срез документов${checkedCounterpartySuffixRu(counterparty)}${checkedPeriodSuffixRu(periodScope)} ограничен только подтвержденными строками документов, найденными этим поиском.`
|
||
];
|
||
}
|
||
function buildMovementInferredFacts(result, counterparty, periodScope) {
|
||
if (result.error || result.fetched_rows <= 0) {
|
||
return [];
|
||
}
|
||
if (result.matched_rows <= 0) {
|
||
return [
|
||
`По движениям${checkedCounterpartySuffixRu(counterparty)}${checkedPeriodSuffixRu(periodScope)} удалось проверить только ограниченный срез 1С; подтвержденных строк движений этим поиском не найдено.`
|
||
];
|
||
}
|
||
return [
|
||
`Срез движений${checkedCounterpartySuffixRu(counterparty)}${checkedPeriodSuffixRu(periodScope)} ограничен только подтвержденными строками движений, найденными этим поиском.`
|
||
];
|
||
}
|
||
function buildValueFlowInferredFacts(derived) {
|
||
if (!derived) {
|
||
return [];
|
||
}
|
||
const facts = [];
|
||
if (derived.value_flow_direction === "outgoing_supplier_payout") {
|
||
facts.push("Counterparty supplier-payout total was calculated from confirmed 1C outgoing payment rows");
|
||
}
|
||
else {
|
||
facts.push("Counterparty value-flow total was calculated from confirmed 1C movement rows");
|
||
}
|
||
if (derived.coverage_recovered_by_period_chunking && derived.period_chunking_granularity === "month") {
|
||
facts.push("Requested period coverage was recovered through monthly 1C value-flow probes");
|
||
}
|
||
if (derived.aggregation_axis === "month" && derived.monthly_breakdown.length > 0) {
|
||
facts.push("Counterparty monthly value-flow breakdown was grouped by month over confirmed 1C movement rows");
|
||
}
|
||
return facts;
|
||
}
|
||
function buildRankedValueFlowInferredFacts(derived) {
|
||
if (!derived) {
|
||
return [];
|
||
}
|
||
const facts = ["Counterparty ranking was calculated from confirmed 1C movement rows grouped by counterparty"];
|
||
if (derived.coverage_recovered_by_period_chunking && derived.period_chunking_granularity === "month") {
|
||
facts.push("Requested period coverage for counterparty ranking was recovered through monthly 1C probes");
|
||
}
|
||
return facts;
|
||
}
|
||
function buildBidirectionalValueFlowInferredFacts(derived) {
|
||
if (!derived) {
|
||
return [];
|
||
}
|
||
const facts = ["Counterparty net value-flow was calculated as incoming confirmed 1C rows minus outgoing confirmed 1C rows"];
|
||
if (derived.coverage_recovered_by_period_chunking && derived.period_chunking_granularity === "month") {
|
||
facts.push("Requested period coverage for bidirectional value-flow was recovered through monthly 1C side probes");
|
||
}
|
||
if (derived.aggregation_axis === "month" && derived.monthly_breakdown.length > 0) {
|
||
facts.push("Counterparty monthly net value-flow breakdown was grouped by month over confirmed incoming and outgoing 1C rows");
|
||
}
|
||
return facts;
|
||
}
|
||
function buildLifecycleUnknownFacts() {
|
||
return [
|
||
"Legal registration date is not proven by this MCP discovery pilot",
|
||
"Business activity before the first confirmed 1C activity row is not proven by this MCP discovery pilot"
|
||
];
|
||
}
|
||
function buildDocumentUnknownFacts(periodScope, counterparty) {
|
||
return [
|
||
`Полный исторический срез документов${checkedCounterpartySuffixRu(counterparty)}${uncheckedPeriodBoundaryRu(periodScope)} этим поиском не подтвержден.`
|
||
];
|
||
}
|
||
function buildMovementUnknownFacts(periodScope, counterparty) {
|
||
return [
|
||
`Полный исторический срез движений${checkedCounterpartySuffixRu(counterparty)}${uncheckedPeriodBoundaryRu(periodScope)} этим поиском не подтвержден.`
|
||
];
|
||
}
|
||
function buildValueFlowUnknownFacts(periodScope, direction, derived) {
|
||
const unknownFacts = [];
|
||
if (derived?.coverage_limited_by_probe_limit) {
|
||
unknownFacts.push("Complete requested-period coverage is not proven by the available checked rows");
|
||
}
|
||
if (direction === "outgoing_supplier_payout") {
|
||
unknownFacts.push(periodScope
|
||
? "Full supplier-payout amount outside the checked period is not proven by this MCP discovery pilot"
|
||
: "Full all-time supplier-payout amount is not proven without an explicit checked period");
|
||
return unknownFacts;
|
||
}
|
||
unknownFacts.push(periodScope
|
||
? "Full turnover outside the checked period is not proven by this MCP discovery pilot"
|
||
: "Full all-time turnover is not proven without an explicit checked period");
|
||
return unknownFacts;
|
||
}
|
||
function buildRankedValueFlowUnknownFacts(periodScope, derived) {
|
||
const unknownFacts = [];
|
||
if (derived?.coverage_limited_by_probe_limit) {
|
||
unknownFacts.push("Complete requested-period ranking coverage is not proven by the available checked rows");
|
||
}
|
||
unknownFacts.push(periodScope
|
||
? "Full ranking outside the checked period is not proven by this MCP discovery pilot"
|
||
: "Full all-time counterparty ranking is not proven without an explicit checked period");
|
||
return unknownFacts;
|
||
}
|
||
function buildBidirectionalValueFlowUnknownFacts(periodScope, derived) {
|
||
const unknownFacts = [];
|
||
if (derived?.coverage_limited_by_probe_limit) {
|
||
unknownFacts.push("Complete requested-period coverage for bidirectional value-flow is not proven by the available checked rows");
|
||
}
|
||
unknownFacts.push(periodScope
|
||
? "Full bidirectional value-flow outside the checked period is not proven by this MCP discovery pilot"
|
||
: "Full all-time bidirectional value-flow is not proven without an explicit checked period");
|
||
return unknownFacts;
|
||
}
|
||
function buildEmptyEvidence(planner, dryRun, probeResults, reason) {
|
||
return (0, assistantMcpDiscoveryPolicy_1.resolveAssistantMcpDiscoveryEvidence)({
|
||
plan: planner.discovery_plan,
|
||
probeResults,
|
||
unknownFacts: [reason],
|
||
queryLimitations: [reason],
|
||
recommendedNextProbe: dryRun.user_facing_fallback
|
||
});
|
||
}
|
||
function pilotScopeForPlanner(planner) {
|
||
switch (planner.selected_chain_id) {
|
||
case "catalog_drilldown":
|
||
case "metadata_lane_clarification":
|
||
case "metadata_inspection":
|
||
return "metadata_inspection_v1";
|
||
case "inventory_stock_snapshot":
|
||
case "inventory_supplier_overlap":
|
||
case "inventory_purchase_provenance":
|
||
case "inventory_sale_trace":
|
||
return "inventory_route_template_v1";
|
||
case "movement_evidence":
|
||
return "counterparty_movement_evidence_query_movements_v1";
|
||
case "value_flow_comparison":
|
||
case "value_flow_ranking":
|
||
case "value_flow":
|
||
return valueFlowPilotProfile(planner).scope;
|
||
case "business_overview":
|
||
return "business_overview_route_template_v1";
|
||
case "document_evidence":
|
||
return "counterparty_document_evidence_query_documents_v1";
|
||
case "lifecycle":
|
||
return "counterparty_lifecycle_query_documents_v1";
|
||
case "entity_resolution":
|
||
return "entity_resolution_search_v1";
|
||
}
|
||
}
|
||
async function executeAssistantMcpDiscoveryPilot(planner, deps = DEFAULT_DEPS) {
|
||
const runtimeDeps = {
|
||
...DEFAULT_DEPS,
|
||
...deps
|
||
};
|
||
const dryRun = (0, assistantMcpDiscoveryRuntimeAdapter_1.buildAssistantMcpDiscoveryRuntimeDryRun)(planner);
|
||
const reasonCodes = [...dryRun.reason_codes];
|
||
const executedPrimitives = [];
|
||
const skippedPrimitives = [];
|
||
const probeResults = [];
|
||
const queryLimitations = [];
|
||
const pilotScope = pilotScopeForPlanner(planner);
|
||
if (dryRun.adapter_status === "blocked") {
|
||
pushReason(reasonCodes, "pilot_blocked_before_mcp_execution");
|
||
const evidence = buildEmptyEvidence(planner, dryRun, probeResults, "MCP discovery pilot was blocked before execution");
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "blocked",
|
||
pilot_scope: pilotScope,
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: false,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: null,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: ["MCP discovery pilot was blocked before execution"],
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
if (dryRun.adapter_status !== "dry_run_ready") {
|
||
pushReason(reasonCodes, "pilot_needs_clarification_before_mcp_execution");
|
||
const evidence = buildEmptyEvidence(planner, dryRun, probeResults, "MCP discovery pilot needs more scope before execution");
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "skipped_needs_clarification",
|
||
pilot_scope: pilotScope,
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: false,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: null,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: ["MCP discovery pilot needs more scope before execution"],
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
const metadataPilotEligible = isMetadataPilotEligible(planner);
|
||
const documentPilotEligible = isDocumentEvidencePilotEligible(planner);
|
||
const movementPilotEligible = isMovementEvidencePilotEligible(planner);
|
||
const lifecyclePilotEligible = isLifecyclePilotEligible(planner);
|
||
const valueFlowPilotEligible = isValueFlowPilotEligible(planner);
|
||
const businessOverviewPilotEligible = isBusinessOverviewPilotEligible(planner);
|
||
const entityResolutionPilotEligible = isEntityResolutionPilotEligible(planner);
|
||
const inventoryPilotEligible = isInventoryPilotEligible(planner);
|
||
if (!metadataPilotEligible &&
|
||
!documentPilotEligible &&
|
||
!movementPilotEligible &&
|
||
!lifecyclePilotEligible &&
|
||
!valueFlowPilotEligible &&
|
||
!businessOverviewPilotEligible &&
|
||
!entityResolutionPilotEligible &&
|
||
!inventoryPilotEligible) {
|
||
pushReason(reasonCodes, "pilot_scope_unsupported_for_live_execution");
|
||
for (const step of dryRun.execution_steps) {
|
||
skippedPrimitives.push(step.primitive_id);
|
||
probeResults.push(skippedProbeResult(step, "pilot_scope_unsupported_for_live_execution"));
|
||
}
|
||
const evidence = buildEmptyEvidence(planner, dryRun, probeResults, "MCP discovery pilot scope is not implemented yet");
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "unsupported",
|
||
pilot_scope: pilotScope,
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: false,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: null,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: ["MCP discovery pilot scope is not implemented yet"],
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
const counterparty = firstEntityCandidate(planner);
|
||
const dateScope = toNonEmptyString(planner.discovery_plan.turn_meaning_ref?.explicit_date_scope);
|
||
const organizationScope = organizationScopeForPlanner(planner);
|
||
const aggregationAxis = aggregationAxisForPlanner(planner);
|
||
const rankingNeed = rankingNeedForPlanner(planner);
|
||
if (inventoryPilotEligible) {
|
||
let queryResult = null;
|
||
const inventoryIntent = inventoryIntentForPlanner(planner);
|
||
const executablePrimitive = inventoryExecutablePrimitiveForPlanner(planner);
|
||
if (!inventoryIntent || !executablePrimitive) {
|
||
pushReason(reasonCodes, "pilot_inventory_exact_recipe_not_mapped");
|
||
const evidence = buildEmptyEvidence(planner, dryRun, probeResults, "Inventory exact recipe is not mapped");
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "unsupported",
|
||
pilot_scope: "inventory_route_template_v1",
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: false,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: null,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: ["Inventory exact recipe is not mapped"],
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
const filters = buildInventoryExactFilters(planner);
|
||
const selection = (0, addressRecipeCatalog_1.selectAddressRecipe)(inventoryIntent, filters);
|
||
if (selection.missing_required_filters.length > 0) {
|
||
pushReason(reasonCodes, "pilot_inventory_exact_recipe_needs_required_filters");
|
||
const evidence = buildEmptyEvidence(planner, dryRun, probeResults, `Inventory exact recipe needs required filters: ${selection.missing_required_filters.join(", ")}`);
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "skipped_needs_clarification",
|
||
pilot_scope: "inventory_route_template_v1",
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: false,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: null,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: [`Inventory exact recipe needs required filters: ${selection.missing_required_filters.join(", ")}`],
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
if (!selection.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_inventory_exact_recipe_not_available");
|
||
const evidence = buildEmptyEvidence(planner, dryRun, probeResults, "Inventory exact recipe is not available");
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "unsupported",
|
||
pilot_scope: "inventory_route_template_v1",
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: false,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: null,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: ["Inventory exact recipe is not available"],
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
pushReason(reasonCodes, "pilot_inventory_exact_recipe_selected");
|
||
const recipePlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(selection.selected_recipe, filters);
|
||
for (const step of dryRun.execution_steps) {
|
||
if (step.primitive_id !== executablePrimitive) {
|
||
skippedPrimitives.push(step.primitive_id);
|
||
probeResults.push(skippedProbeResult(step, `pilot_inventory_exact_bridge_executes_${executablePrimitive}`));
|
||
continue;
|
||
}
|
||
queryResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: recipePlan.query,
|
||
limit: recipePlan.limit,
|
||
account_scope: recipePlan.account_scope
|
||
});
|
||
pushUnique(executedPrimitives, step.primitive_id);
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, queryResult));
|
||
if (queryResult.error) {
|
||
pushUnique(queryLimitations, queryResult.error);
|
||
pushReason(reasonCodes, "pilot_inventory_exact_mcp_error");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_inventory_exact_mcp_executed");
|
||
}
|
||
}
|
||
const sourceRowsSummary = queryResult ? summarizeInventoryRows(queryResult) : null;
|
||
const evidence = (0, assistantMcpDiscoveryPolicy_1.resolveAssistantMcpDiscoveryEvidence)({
|
||
plan: planner.discovery_plan,
|
||
probeResults,
|
||
confirmedFacts: queryResult ? buildInventoryConfirmedFacts(queryResult, planner, inventoryIntent) : [],
|
||
inferredFacts: queryResult ? buildInventoryInferredFacts(queryResult, inventoryIntent) : [],
|
||
unknownFacts: buildInventoryUnknownFacts(queryResult, inventoryIntent, toNonEmptyString(planner.discovery_plan.turn_meaning_ref?.explicit_date_scope)),
|
||
sourceRowsSummary,
|
||
queryLimitations,
|
||
recommendedNextProbe: "explain_evidence_basis"
|
||
});
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "executed",
|
||
pilot_scope: "inventory_route_template_v1",
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: executedPrimitives.length > 0,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: sourceRowsSummary,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: queryLimitations,
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
if (businessOverviewPilotEligible) {
|
||
let incomingResult = null;
|
||
let outgoingResult = null;
|
||
let lifecycleResult = null;
|
||
let taxResult = null;
|
||
let accountingFinancialResultResult = null;
|
||
let tradingMarginResult = null;
|
||
let receivablesResult = null;
|
||
let payablesResult = null;
|
||
let openContractsResult = null;
|
||
let dueDateAgingResult = null;
|
||
let documentActivityProfileResult = null;
|
||
let counterpartyProfileResult = null;
|
||
let contractUsageProfileResult = null;
|
||
let inventoryOnHandResult = null;
|
||
let inventoryAgingResult = null;
|
||
let inventoryQualityEventsResult = null;
|
||
const valueFilters = buildValueFlowFilters(planner);
|
||
const lifecycleFilters = buildLifecycleFilters(planner);
|
||
const profileFilters = buildBusinessOverviewProfileFilters(planner);
|
||
const taxFilters = buildBusinessOverviewTaxFilters(planner);
|
||
const accountingFinancialResultFilters = buildBusinessOverviewAccountingFinancialResultFilters(planner);
|
||
const tradingMarginFilters = buildBusinessOverviewTradingMarginFilters(planner);
|
||
const debtFilters = buildBusinessOverviewDebtFilters(planner);
|
||
const debtDueDateAgingProbeEnabled = shouldRunDebtDueDateAgingProbe(planner);
|
||
const inventoryFilters = buildBusinessOverviewInventoryFilters(planner);
|
||
const inventoryQualityEventsProbeEnabled = shouldRunInventoryQualityEventsProbe(planner);
|
||
const debtAsOfDate = toNonEmptyString(debtFilters?.as_of_date);
|
||
const inventoryAsOfDate = toNonEmptyString(inventoryFilters?.as_of_date);
|
||
const incomingSelection = (0, addressRecipeCatalog_1.selectAddressRecipe)("customer_revenue_and_payments", valueFilters);
|
||
const outgoingSelection = (0, addressRecipeCatalog_1.selectAddressRecipe)("supplier_payouts_profile", valueFilters);
|
||
const lifecycleSelection = (0, addressRecipeCatalog_1.selectAddressRecipe)("counterparty_activity_lifecycle", lifecycleFilters);
|
||
const documentActivitySelection = (0, addressRecipeCatalog_1.selectAddressRecipe)("document_type_and_account_section_profile", profileFilters);
|
||
const counterpartyProfileSelection = (0, addressRecipeCatalog_1.selectAddressRecipe)("counterparty_population_and_roles", profileFilters);
|
||
const contractUsageSelection = (0, addressRecipeCatalog_1.selectAddressRecipe)("contract_usage_overview", profileFilters);
|
||
const taxSelection = taxFilters
|
||
? (0, addressRecipeCatalog_1.selectAddressRecipe)("vat_liability_confirmed_for_tax_period", taxFilters)
|
||
: null;
|
||
const accountingFinancialResultSelection = accountingFinancialResultFilters
|
||
? (0, addressRecipeCatalog_1.selectAddressRecipe)("accounting_financial_result_for_organization", accountingFinancialResultFilters)
|
||
: null;
|
||
const tradingMarginSelection = tradingMarginFilters
|
||
? (0, addressRecipeCatalog_1.selectAddressRecipe)("inventory_trading_margin_proxy_for_organization", tradingMarginFilters)
|
||
: null;
|
||
const receivablesSelection = debtFilters
|
||
? (0, addressRecipeCatalog_1.selectAddressRecipe)("receivables_confirmed_as_of_date", debtFilters)
|
||
: null;
|
||
const payablesSelection = debtFilters
|
||
? (0, addressRecipeCatalog_1.selectAddressRecipe)("payables_confirmed_as_of_date", debtFilters)
|
||
: null;
|
||
const openContractsSelection = debtFilters
|
||
? (0, addressRecipeCatalog_1.selectAddressRecipe)("open_contracts_confirmed_as_of_date", debtFilters)
|
||
: null;
|
||
const dueDateAgingSelection = debtFilters && debtDueDateAgingProbeEnabled
|
||
? (0, addressRecipeCatalog_1.selectAddressRecipe)("debt_due_date_aging_for_organization", debtFilters)
|
||
: null;
|
||
const inventoryOnHandSelection = inventoryFilters
|
||
? (0, addressRecipeCatalog_1.selectAddressRecipe)("inventory_on_hand_as_of_date", inventoryFilters)
|
||
: null;
|
||
const inventoryAgingSelection = inventoryFilters
|
||
? (0, addressRecipeCatalog_1.selectAddressRecipe)("inventory_aging_by_purchase_date", inventoryFilters)
|
||
: null;
|
||
const inventoryQualityEventsSelection = inventoryQualityEventsProbeEnabled
|
||
? (0, addressRecipeCatalog_1.selectAddressRecipe)("inventory_quality_events_for_organization", inventoryFilters ?? buildBusinessOverviewProfileFilters(planner))
|
||
: null;
|
||
if (!incomingSelection.selected_recipe || !outgoingSelection.selected_recipe || !lifecycleSelection.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_business_overview_recipe_not_available");
|
||
const missing = [
|
||
incomingSelection.selected_recipe ? null : "customer_revenue_and_payments",
|
||
outgoingSelection.selected_recipe ? null : "supplier_payouts_profile",
|
||
lifecycleSelection.selected_recipe ? null : "counterparty_activity_lifecycle"
|
||
].filter((item) => Boolean(item));
|
||
const evidence = buildEmptyEvidence(planner, dryRun, probeResults, "Business overview recipe is not available");
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "unsupported",
|
||
pilot_scope: "business_overview_route_template_v1",
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: false,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: null,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: [`Business overview recipe is not available: ${missing.join(", ")}`],
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
pushReason(reasonCodes, "pilot_business_overview_recipes_selected");
|
||
if (documentActivitySelection.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_business_overview_document_activity_profile_recipe_selected");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_business_overview_document_activity_profile_recipe_not_available");
|
||
pushUnique(queryLimitations, "Business overview document/account-section profile requires an executable document-section profile recipe");
|
||
}
|
||
if (counterpartyProfileSelection.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_business_overview_counterparty_profile_recipe_selected");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_business_overview_counterparty_profile_recipe_not_available");
|
||
pushUnique(queryLimitations, "Business overview counterparty profile requires an executable counterparty population/roles recipe");
|
||
}
|
||
if (contractUsageSelection.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_business_overview_contract_usage_profile_recipe_selected");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_business_overview_contract_usage_profile_recipe_not_available");
|
||
pushUnique(queryLimitations, "Business overview contract usage profile requires an executable contract usage recipe");
|
||
}
|
||
if (taxSelection?.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_business_overview_tax_recipe_selected");
|
||
}
|
||
else if (!taxFilters) {
|
||
pushReason(reasonCodes, "pilot_business_overview_tax_probe_skipped_without_explicit_period");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_business_overview_tax_recipe_not_available");
|
||
pushUnique(queryLimitations, "Business overview VAT/tax probe requires an executable tax-period recipe");
|
||
}
|
||
if (accountingFinancialResultSelection?.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_business_overview_accounting_financial_result_recipe_selected");
|
||
}
|
||
else if (!accountingFinancialResultFilters) {
|
||
pushReason(reasonCodes, "pilot_business_overview_accounting_financial_result_probe_skipped_without_explicit_period");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_business_overview_accounting_financial_result_recipe_not_available");
|
||
pushUnique(queryLimitations, "Business overview accounting financial-result probe requires an executable 90/91/99 period-close recipe");
|
||
}
|
||
if (tradingMarginSelection?.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_business_overview_trading_margin_recipe_selected");
|
||
}
|
||
else if (!tradingMarginFilters) {
|
||
pushReason(reasonCodes, "pilot_business_overview_trading_margin_probe_skipped_without_explicit_period");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_business_overview_trading_margin_recipe_not_available");
|
||
pushUnique(queryLimitations, "Business overview trading-margin proxy requires an executable explicit-period purchase/sale document recipe");
|
||
}
|
||
if (receivablesSelection?.selected_recipe && payablesSelection?.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_business_overview_debt_recipes_selected");
|
||
}
|
||
else if (!debtFilters) {
|
||
pushReason(reasonCodes, "pilot_business_overview_debt_probe_skipped_without_explicit_as_of_date");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_business_overview_debt_recipe_not_available");
|
||
pushUnique(queryLimitations, "Business overview debt-position probe requires executable receivables/payables as-of-date recipes");
|
||
}
|
||
if (openContractsSelection?.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_business_overview_open_contracts_recipe_selected");
|
||
}
|
||
else if (!debtFilters) {
|
||
pushReason(reasonCodes, "pilot_business_overview_open_contracts_probe_skipped_without_explicit_as_of_date");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_business_overview_open_contracts_recipe_not_available");
|
||
pushUnique(queryLimitations, "Business overview open-settlement quality probe requires executable open-contracts as-of-date recipe");
|
||
}
|
||
if (dueDateAgingSelection?.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_business_overview_debt_due_date_aging_recipe_selected");
|
||
}
|
||
else if (!debtFilters) {
|
||
pushReason(reasonCodes, "pilot_business_overview_debt_due_date_aging_probe_skipped_without_explicit_as_of_date");
|
||
}
|
||
else if (!debtDueDateAgingProbeEnabled) {
|
||
pushReason(reasonCodes, "pilot_business_overview_debt_due_date_aging_probe_skipped_without_boundary_need");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_business_overview_debt_due_date_aging_recipe_not_available");
|
||
pushUnique(queryLimitations, "Business overview due-date aging probe requires executable contract payment-term/open-balance recipe");
|
||
}
|
||
if (inventoryOnHandSelection?.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_business_overview_inventory_on_hand_recipe_selected");
|
||
if (inventoryAgingSelection?.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_business_overview_inventory_aging_recipe_selected");
|
||
}
|
||
}
|
||
else if (!inventoryFilters) {
|
||
pushReason(reasonCodes, "pilot_business_overview_inventory_probe_skipped_without_explicit_as_of_date");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_business_overview_inventory_recipe_not_available");
|
||
pushUnique(queryLimitations, "Business overview inventory-position probe requires an executable inventory on-hand as-of-date recipe");
|
||
}
|
||
if (inventoryQualityEventsSelection?.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_business_overview_inventory_quality_events_recipe_selected");
|
||
}
|
||
else if (!inventoryQualityEventsProbeEnabled) {
|
||
pushReason(reasonCodes, "pilot_business_overview_inventory_quality_events_probe_skipped_without_boundary_need");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_business_overview_inventory_quality_events_recipe_not_available");
|
||
pushUnique(queryLimitations, "Business overview inventory quality probe requires an executable inventory quality-events recipe");
|
||
}
|
||
for (const step of dryRun.execution_steps) {
|
||
if (step.primitive_id === "query_movements") {
|
||
const incomingExecution = await executeCoverageAwareValueFlowQuery({
|
||
primitiveId: step.primitive_id,
|
||
recipePlanBuilder: (scopedFilters) => (0, addressRecipeCatalog_1.buildAddressRecipePlan)(incomingSelection.selected_recipe, scopedFilters),
|
||
baseFilters: valueFilters,
|
||
dateScope,
|
||
maxProbeCount: planner.discovery_plan.execution_budget.max_probe_count,
|
||
maxRowsPerProbe: planner.discovery_plan.execution_budget.max_rows_per_probe,
|
||
deps: runtimeDeps
|
||
});
|
||
const outgoingExecution = await executeCoverageAwareValueFlowQuery({
|
||
primitiveId: step.primitive_id,
|
||
recipePlanBuilder: (scopedFilters) => (0, addressRecipeCatalog_1.buildAddressRecipePlan)(outgoingSelection.selected_recipe, scopedFilters),
|
||
baseFilters: valueFilters,
|
||
dateScope,
|
||
maxProbeCount: planner.discovery_plan.execution_budget.max_probe_count,
|
||
maxRowsPerProbe: planner.discovery_plan.execution_budget.max_rows_per_probe,
|
||
deps: runtimeDeps
|
||
});
|
||
incomingResult = incomingExecution.result;
|
||
outgoingResult = outgoingExecution.result;
|
||
if (taxSelection?.selected_recipe) {
|
||
const taxPlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(taxSelection.selected_recipe, taxFilters);
|
||
taxResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: taxPlan.query,
|
||
limit: taxPlan.limit,
|
||
account_scope: taxPlan.account_scope
|
||
});
|
||
}
|
||
if (accountingFinancialResultSelection?.selected_recipe) {
|
||
const accountingFinancialResultPlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(accountingFinancialResultSelection.selected_recipe, accountingFinancialResultFilters);
|
||
accountingFinancialResultResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: accountingFinancialResultPlan.query,
|
||
limit: accountingFinancialResultPlan.limit,
|
||
account_scope: accountingFinancialResultPlan.account_scope
|
||
});
|
||
}
|
||
if (receivablesSelection?.selected_recipe && payablesSelection?.selected_recipe) {
|
||
const receivablesPlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(receivablesSelection.selected_recipe, debtFilters);
|
||
receivablesResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: receivablesPlan.query,
|
||
limit: receivablesPlan.limit,
|
||
account_scope: receivablesPlan.account_scope
|
||
});
|
||
const payablesPlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(payablesSelection.selected_recipe, debtFilters);
|
||
payablesResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: payablesPlan.query,
|
||
limit: payablesPlan.limit,
|
||
account_scope: payablesPlan.account_scope
|
||
});
|
||
}
|
||
if (openContractsSelection?.selected_recipe) {
|
||
const openContractsPlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(openContractsSelection.selected_recipe, debtFilters);
|
||
openContractsResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: openContractsPlan.query,
|
||
limit: openContractsPlan.limit,
|
||
account_scope: openContractsPlan.account_scope
|
||
});
|
||
}
|
||
if (dueDateAgingSelection?.selected_recipe) {
|
||
const dueDateAgingPlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(dueDateAgingSelection.selected_recipe, debtFilters);
|
||
dueDateAgingResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: dueDateAgingPlan.query,
|
||
limit: dueDateAgingPlan.limit,
|
||
account_scope: dueDateAgingPlan.account_scope
|
||
});
|
||
}
|
||
if (inventoryOnHandSelection?.selected_recipe) {
|
||
const inventoryOnHandPlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(inventoryOnHandSelection.selected_recipe, inventoryFilters);
|
||
inventoryOnHandResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: inventoryOnHandPlan.query,
|
||
limit: inventoryOnHandPlan.limit,
|
||
account_scope: inventoryOnHandPlan.account_scope
|
||
});
|
||
if (inventoryAgingSelection?.selected_recipe) {
|
||
const inventoryAgingPlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(inventoryAgingSelection.selected_recipe, inventoryFilters);
|
||
inventoryAgingResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: inventoryAgingPlan.query,
|
||
limit: inventoryAgingPlan.limit,
|
||
account_scope: inventoryAgingPlan.account_scope
|
||
});
|
||
}
|
||
}
|
||
pushUnique(executedPrimitives, step.primitive_id);
|
||
probeResults.push(...incomingExecution.probe_results, ...outgoingExecution.probe_results);
|
||
if (taxResult) {
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, taxResult));
|
||
}
|
||
if (accountingFinancialResultResult) {
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, accountingFinancialResultResult));
|
||
}
|
||
if (receivablesResult) {
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, receivablesResult));
|
||
}
|
||
if (payablesResult) {
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, payablesResult));
|
||
}
|
||
if (openContractsResult) {
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, openContractsResult));
|
||
}
|
||
if (dueDateAgingResult) {
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, dueDateAgingResult));
|
||
}
|
||
if (inventoryOnHandResult) {
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, inventoryOnHandResult));
|
||
}
|
||
if (inventoryAgingResult) {
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, inventoryAgingResult));
|
||
}
|
||
for (const limitation of [...incomingExecution.query_limitations, ...outgoingExecution.query_limitations]) {
|
||
pushUnique(queryLimitations, limitation);
|
||
}
|
||
if (incomingResult?.error) {
|
||
pushReason(reasonCodes, "pilot_business_overview_incoming_query_mcp_error");
|
||
}
|
||
if (outgoingResult?.error) {
|
||
pushReason(reasonCodes, "pilot_business_overview_outgoing_query_mcp_error");
|
||
}
|
||
if (!incomingResult?.error || !outgoingResult?.error) {
|
||
pushReason(reasonCodes, "pilot_business_overview_query_movements_mcp_executed");
|
||
}
|
||
if (taxResult?.error) {
|
||
pushUnique(queryLimitations, taxResult.error);
|
||
pushReason(reasonCodes, "pilot_business_overview_tax_query_mcp_error");
|
||
}
|
||
else if (taxResult) {
|
||
pushReason(reasonCodes, "pilot_business_overview_tax_query_mcp_executed");
|
||
}
|
||
if (accountingFinancialResultResult?.error) {
|
||
pushUnique(queryLimitations, accountingFinancialResultResult.error);
|
||
pushReason(reasonCodes, "pilot_business_overview_accounting_financial_result_query_mcp_error");
|
||
}
|
||
else if (accountingFinancialResultResult) {
|
||
pushReason(reasonCodes, "pilot_business_overview_accounting_financial_result_query_mcp_executed");
|
||
}
|
||
if (receivablesResult?.error) {
|
||
pushUnique(queryLimitations, receivablesResult.error);
|
||
pushReason(reasonCodes, "pilot_business_overview_receivables_query_mcp_error");
|
||
}
|
||
else if (receivablesResult) {
|
||
pushReason(reasonCodes, "pilot_business_overview_receivables_query_mcp_executed");
|
||
}
|
||
if (payablesResult?.error) {
|
||
pushUnique(queryLimitations, payablesResult.error);
|
||
pushReason(reasonCodes, "pilot_business_overview_payables_query_mcp_error");
|
||
}
|
||
else if (payablesResult) {
|
||
pushReason(reasonCodes, "pilot_business_overview_payables_query_mcp_executed");
|
||
}
|
||
if ((receivablesResult && !receivablesResult.error) ||
|
||
(payablesResult && !payablesResult.error)) {
|
||
pushReason(reasonCodes, "pilot_business_overview_debt_query_mcp_executed");
|
||
}
|
||
if (openContractsResult?.error) {
|
||
pushUnique(queryLimitations, openContractsResult.error);
|
||
pushReason(reasonCodes, "pilot_business_overview_open_contracts_query_mcp_error");
|
||
}
|
||
else if (openContractsResult) {
|
||
pushReason(reasonCodes, "pilot_business_overview_open_contracts_query_mcp_executed");
|
||
}
|
||
if (dueDateAgingResult?.error) {
|
||
pushUnique(queryLimitations, dueDateAgingResult.error);
|
||
pushReason(reasonCodes, "pilot_business_overview_debt_due_date_aging_query_mcp_error");
|
||
}
|
||
else if (dueDateAgingResult) {
|
||
pushReason(reasonCodes, "pilot_business_overview_debt_due_date_aging_query_mcp_executed");
|
||
}
|
||
if (inventoryOnHandResult?.error) {
|
||
pushUnique(queryLimitations, inventoryOnHandResult.error);
|
||
pushReason(reasonCodes, "pilot_business_overview_inventory_on_hand_query_mcp_error");
|
||
}
|
||
else if (inventoryOnHandResult) {
|
||
pushReason(reasonCodes, "pilot_business_overview_inventory_on_hand_query_mcp_executed");
|
||
}
|
||
if (inventoryAgingResult?.error) {
|
||
pushUnique(queryLimitations, inventoryAgingResult.error);
|
||
pushReason(reasonCodes, "pilot_business_overview_inventory_aging_query_mcp_error");
|
||
}
|
||
else if (inventoryAgingResult) {
|
||
pushReason(reasonCodes, "pilot_business_overview_inventory_aging_query_mcp_executed");
|
||
}
|
||
if ((inventoryOnHandResult && !inventoryOnHandResult.error) ||
|
||
(inventoryAgingResult && !inventoryAgingResult.error)) {
|
||
pushReason(reasonCodes, "pilot_business_overview_inventory_query_mcp_executed");
|
||
}
|
||
continue;
|
||
}
|
||
if (step.primitive_id === "query_documents") {
|
||
const lifecyclePlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(lifecycleSelection.selected_recipe, lifecycleFilters);
|
||
lifecycleResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: lifecyclePlan.query,
|
||
limit: lifecyclePlan.limit,
|
||
account_scope: lifecyclePlan.account_scope
|
||
});
|
||
pushUnique(executedPrimitives, step.primitive_id);
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, lifecycleResult));
|
||
if (tradingMarginSelection?.selected_recipe) {
|
||
const tradingMarginPlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(tradingMarginSelection.selected_recipe, tradingMarginFilters);
|
||
tradingMarginResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: tradingMarginPlan.query,
|
||
limit: tradingMarginPlan.limit,
|
||
account_scope: tradingMarginPlan.account_scope
|
||
});
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, tradingMarginResult));
|
||
}
|
||
if (documentActivitySelection.selected_recipe) {
|
||
const documentActivityPlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(documentActivitySelection.selected_recipe, profileFilters);
|
||
documentActivityProfileResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: documentActivityPlan.query,
|
||
limit: documentActivityPlan.limit,
|
||
account_scope: documentActivityPlan.account_scope
|
||
});
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, documentActivityProfileResult));
|
||
}
|
||
if (counterpartyProfileSelection.selected_recipe) {
|
||
const counterpartyProfilePlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(counterpartyProfileSelection.selected_recipe, profileFilters);
|
||
counterpartyProfileResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: counterpartyProfilePlan.query,
|
||
limit: counterpartyProfilePlan.limit,
|
||
account_scope: counterpartyProfilePlan.account_scope
|
||
});
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, counterpartyProfileResult));
|
||
}
|
||
if (contractUsageSelection.selected_recipe) {
|
||
const contractUsagePlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(contractUsageSelection.selected_recipe, profileFilters);
|
||
contractUsageProfileResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: contractUsagePlan.query,
|
||
limit: contractUsagePlan.limit,
|
||
account_scope: contractUsagePlan.account_scope
|
||
});
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, contractUsageProfileResult));
|
||
}
|
||
if (inventoryQualityEventsSelection?.selected_recipe) {
|
||
const inventoryQualityEventsFilters = inventoryFilters ?? buildBusinessOverviewProfileFilters(planner);
|
||
const inventoryQualityEventsPlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(inventoryQualityEventsSelection.selected_recipe, inventoryQualityEventsFilters);
|
||
inventoryQualityEventsResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: inventoryQualityEventsPlan.query,
|
||
limit: inventoryQualityEventsPlan.limit,
|
||
account_scope: inventoryQualityEventsPlan.account_scope
|
||
});
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, inventoryQualityEventsResult));
|
||
}
|
||
if (lifecycleResult.error) {
|
||
pushUnique(queryLimitations, lifecycleResult.error);
|
||
pushReason(reasonCodes, "pilot_business_overview_query_documents_mcp_error");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_business_overview_query_documents_mcp_executed");
|
||
}
|
||
if (tradingMarginResult?.error) {
|
||
pushUnique(queryLimitations, tradingMarginResult.error);
|
||
pushReason(reasonCodes, "pilot_business_overview_trading_margin_query_mcp_error");
|
||
}
|
||
else if (tradingMarginResult) {
|
||
pushReason(reasonCodes, "pilot_business_overview_trading_margin_query_mcp_executed");
|
||
}
|
||
if (documentActivityProfileResult?.error) {
|
||
pushUnique(queryLimitations, documentActivityProfileResult.error);
|
||
pushReason(reasonCodes, "pilot_business_overview_document_activity_profile_query_mcp_error");
|
||
}
|
||
else if (documentActivityProfileResult) {
|
||
pushReason(reasonCodes, "pilot_business_overview_document_activity_profile_query_mcp_executed");
|
||
}
|
||
if (counterpartyProfileResult?.error) {
|
||
pushUnique(queryLimitations, counterpartyProfileResult.error);
|
||
pushReason(reasonCodes, "pilot_business_overview_counterparty_profile_query_mcp_error");
|
||
}
|
||
else if (counterpartyProfileResult) {
|
||
pushReason(reasonCodes, "pilot_business_overview_counterparty_profile_query_mcp_executed");
|
||
}
|
||
if (contractUsageProfileResult?.error) {
|
||
pushUnique(queryLimitations, contractUsageProfileResult.error);
|
||
pushReason(reasonCodes, "pilot_business_overview_contract_usage_profile_query_mcp_error");
|
||
}
|
||
else if (contractUsageProfileResult) {
|
||
pushReason(reasonCodes, "pilot_business_overview_contract_usage_profile_query_mcp_executed");
|
||
}
|
||
if (inventoryQualityEventsResult?.error) {
|
||
pushUnique(queryLimitations, inventoryQualityEventsResult.error);
|
||
pushReason(reasonCodes, "pilot_business_overview_inventory_quality_events_query_mcp_error");
|
||
}
|
||
else if (inventoryQualityEventsResult) {
|
||
pushReason(reasonCodes, "pilot_business_overview_inventory_quality_events_query_mcp_executed");
|
||
}
|
||
continue;
|
||
}
|
||
skippedPrimitives.push(step.primitive_id);
|
||
probeResults.push(skippedProbeResult(step, "pilot_business_overview_derives_aggregate_coverage_and_explanation"));
|
||
}
|
||
const derivedBusinessOverview = deriveBusinessOverview({
|
||
incomingResult,
|
||
outgoingResult,
|
||
lifecycleResult,
|
||
taxResult,
|
||
accountingFinancialResultResult,
|
||
tradingMarginResult,
|
||
receivablesResult,
|
||
payablesResult,
|
||
openContractsResult,
|
||
dueDateAgingResult,
|
||
documentActivityProfileResult,
|
||
counterpartyProfileResult,
|
||
contractUsageProfileResult,
|
||
debtAsOfDate,
|
||
inventoryOnHandResult,
|
||
inventoryAgingResult,
|
||
inventoryQualityEventsResult,
|
||
inventoryAsOfDate,
|
||
organizationScope,
|
||
periodScope: dateScope
|
||
});
|
||
if (derivedBusinessOverview) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_from_confirmed_rows");
|
||
if (derivedBusinessOverview.top_customers.length > 0) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_top_customers_from_confirmed_rows");
|
||
}
|
||
if (derivedBusinessOverview.top_suppliers.length > 0) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_top_suppliers_from_confirmed_rows");
|
||
}
|
||
if (derivedBusinessOverview.vendor_procurement_quality) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_vendor_procurement_quality_from_confirmed_rows");
|
||
pushReason(reasonCodes, `pilot_derived_business_overview_vendor_procurement_quality_${derivedBusinessOverview.vendor_procurement_quality.evidence_status}`);
|
||
}
|
||
if (derivedBusinessOverview.yearly_breakdown.length > 0) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_yearly_operating_breakdown_from_confirmed_rows");
|
||
}
|
||
if (derivedBusinessOverview.activity_period) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_activity_window_from_confirmed_rows");
|
||
}
|
||
if (derivedBusinessOverview.document_activity_profile) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_document_activity_profile_from_confirmed_rows");
|
||
}
|
||
if (derivedBusinessOverview.counterparty_profile) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_counterparty_profile_from_confirmed_rows");
|
||
}
|
||
if (derivedBusinessOverview.contract_usage_profile) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_contract_usage_profile_from_confirmed_rows");
|
||
}
|
||
if (derivedBusinessOverview.tax_position) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_tax_position_from_confirmed_rows");
|
||
}
|
||
if (derivedBusinessOverview.accounting_financial_result) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_accounting_financial_result_from_confirmed_rows");
|
||
}
|
||
if (derivedBusinessOverview.trading_margin_proxy) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_trading_margin_proxy_from_confirmed_rows");
|
||
}
|
||
if (derivedBusinessOverview.debt_position) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_debt_position_from_confirmed_rows");
|
||
}
|
||
if (derivedBusinessOverview.debt_open_settlement_quality) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_open_settlement_quality_from_confirmed_rows");
|
||
if (derivedBusinessOverview.debt_open_settlement_quality.age_signal) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_debt_age_signal_from_contract_dates");
|
||
}
|
||
}
|
||
if (derivedBusinessOverview.debt_staleness_risk_proxy) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_debt_staleness_risk_proxy_from_confirmed_rows");
|
||
}
|
||
if (derivedBusinessOverview.debt_due_date_aging) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_debt_due_date_aging_from_confirmed_rows");
|
||
pushReason(reasonCodes, `pilot_derived_business_overview_debt_due_date_aging_${derivedBusinessOverview.debt_due_date_aging.evidence_status}`);
|
||
}
|
||
if (derivedBusinessOverview.inventory_position) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_inventory_position_from_confirmed_rows");
|
||
}
|
||
if (derivedBusinessOverview.inventory_turnover_proxy) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_inventory_turnover_proxy_from_confirmed_rows");
|
||
}
|
||
if (derivedBusinessOverview.inventory_staleness_risk_proxy) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_inventory_staleness_risk_proxy_from_confirmed_rows");
|
||
}
|
||
if (derivedBusinessOverview.inventory_quality_events) {
|
||
pushReason(reasonCodes, "pilot_derived_business_overview_inventory_quality_events_from_reviewed_rows");
|
||
pushReason(reasonCodes, `pilot_derived_business_overview_inventory_quality_events_${derivedBusinessOverview.inventory_quality_events.evidence_status}`);
|
||
}
|
||
if (derivedBusinessOverview.missing_proof_families.length > 0) {
|
||
pushReason(reasonCodes, "pilot_business_overview_missing_proof_families_recorded");
|
||
}
|
||
}
|
||
const sourceRowsSummary = summarizeBusinessOverviewRows({
|
||
incomingResult,
|
||
outgoingResult,
|
||
lifecycleResult,
|
||
taxResult,
|
||
accountingFinancialResultResult,
|
||
tradingMarginResult,
|
||
receivablesResult,
|
||
payablesResult,
|
||
openContractsResult,
|
||
dueDateAgingResult,
|
||
documentActivityProfileResult,
|
||
counterpartyProfileResult,
|
||
contractUsageProfileResult,
|
||
inventoryOnHandResult,
|
||
inventoryAgingResult,
|
||
inventoryQualityEventsResult
|
||
});
|
||
const evidence = (0, assistantMcpDiscoveryPolicy_1.resolveAssistantMcpDiscoveryEvidence)({
|
||
plan: planner.discovery_plan,
|
||
probeResults,
|
||
confirmedFacts: buildBusinessOverviewConfirmedFacts(derivedBusinessOverview),
|
||
inferredFacts: buildBusinessOverviewInferredFacts(derivedBusinessOverview),
|
||
unknownFacts: buildBusinessOverviewUnknownFacts(derivedBusinessOverview),
|
||
sourceRowsSummary,
|
||
queryLimitations,
|
||
recommendedNextProbe: "explain_evidence_basis"
|
||
});
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "executed",
|
||
pilot_scope: "business_overview_route_template_v1",
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: executedPrimitives.length > 0,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: sourceRowsSummary,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
derived_business_overview: derivedBusinessOverview,
|
||
query_limitations: queryLimitations,
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
if (metadataPilotEligible) {
|
||
let metadataResult = null;
|
||
const metadataScope = metadataScopeForPlanner(planner);
|
||
const requestedMetaTypes = metadataTypesForPlanner(planner);
|
||
if (planner.selected_chain_id === "catalog_drilldown" && metadataScope) {
|
||
pushReason(reasonCodes, "pilot_catalog_drilldown_metadata_scope_seeded_from_surface_ref");
|
||
}
|
||
for (const step of dryRun.execution_steps) {
|
||
if (step.primitive_id !== "inspect_1c_metadata") {
|
||
skippedPrimitives.push(step.primitive_id);
|
||
probeResults.push(skippedProbeResult(step, "pilot_metadata_uses_only_inspect_1c_metadata"));
|
||
continue;
|
||
}
|
||
metadataResult = await runtimeDeps.executeAddressMcpMetadata({
|
||
meta_type: requestedMetaTypes,
|
||
name_mask: metadataScope ?? undefined,
|
||
limit: planner.discovery_plan.execution_budget.max_rows_per_probe
|
||
});
|
||
pushUnique(executedPrimitives, step.primitive_id);
|
||
probeResults.push(metadataResultToProbeResult(step.primitive_id, metadataResult));
|
||
if (metadataResult.error) {
|
||
pushUnique(queryLimitations, metadataResult.error);
|
||
pushReason(reasonCodes, "pilot_inspect_1c_metadata_mcp_error");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_inspect_1c_metadata_mcp_executed");
|
||
}
|
||
}
|
||
const sourceRowsSummary = metadataResult ? summarizeMetadataRows(metadataResult) : null;
|
||
const derivedMetadataSurface = deriveMetadataSurface(metadataResult, metadataScope, requestedMetaTypes, metadataScopeRankingAllowedForPlanner(planner));
|
||
if (derivedMetadataSurface) {
|
||
pushReason(reasonCodes, "pilot_derived_metadata_surface_from_confirmed_rows");
|
||
if (derivedMetadataSurface.route_family_selection_basis === "dominant_surface_objects") {
|
||
pushReason(reasonCodes, "pilot_selected_metadata_route_family_from_dominant_surface_objects");
|
||
}
|
||
if (derivedMetadataSurface.surface_object_ranking_applied) {
|
||
pushReason(reasonCodes, "pilot_selected_metadata_route_family_from_surface_object_ranking");
|
||
}
|
||
}
|
||
const evidence = (0, assistantMcpDiscoveryPolicy_1.resolveAssistantMcpDiscoveryEvidence)({
|
||
plan: planner.discovery_plan,
|
||
probeResults,
|
||
confirmedFacts: buildMetadataConfirmedFacts(derivedMetadataSurface),
|
||
inferredFacts: buildMetadataInferredFacts(derivedMetadataSurface),
|
||
unknownFacts: buildMetadataUnknownFacts(derivedMetadataSurface, metadataScope),
|
||
sourceRowsSummary,
|
||
queryLimitations,
|
||
recommendedNextProbe: "inspect_1c_metadata"
|
||
});
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "executed",
|
||
pilot_scope: "metadata_inspection_v1",
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: executedPrimitives.length > 0,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: sourceRowsSummary,
|
||
derived_metadata_surface: derivedMetadataSurface,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: queryLimitations,
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
if (entityResolutionPilotEligible) {
|
||
let queryResult = null;
|
||
const requestedEntity = counterparty;
|
||
if (isLowQualityEntityResolutionAnchor(requestedEntity)) {
|
||
pushReason(reasonCodes, "pilot_entity_resolution_anchor_missing_or_low_quality");
|
||
const evidence = buildEmptyEvidence(planner, dryRun, probeResults, "Entity-resolution needs a clearer counterparty name");
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "skipped_needs_clarification",
|
||
pilot_scope: "entity_resolution_search_v1",
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: false,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: null,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: ["Entity-resolution needs a clearer counterparty name"],
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
let derivedEntityResolution = null;
|
||
for (const step of dryRun.execution_steps) {
|
||
if (step.primitive_id === "search_business_entity") {
|
||
queryResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: ENTITY_RESOLUTION_COUNTERPARTY_QUERY_TEMPLATE.replaceAll("__LIMIT__", String(ENTITY_RESOLUTION_COUNTERPARTY_LOOKUP_LIMIT)),
|
||
limit: ENTITY_RESOLUTION_COUNTERPARTY_LOOKUP_LIMIT
|
||
});
|
||
pushUnique(executedPrimitives, step.primitive_id);
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, queryResult));
|
||
if (queryResult.error) {
|
||
pushUnique(queryLimitations, queryResult.error);
|
||
pushReason(reasonCodes, "pilot_search_business_entity_mcp_error");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_search_business_entity_mcp_executed");
|
||
derivedEntityResolution = deriveEntityResolution(queryResult, requestedEntity);
|
||
}
|
||
continue;
|
||
}
|
||
if (step.primitive_id === "resolve_entity_reference") {
|
||
if (!queryResult || queryResult.error) {
|
||
skippedPrimitives.push(step.primitive_id);
|
||
probeResults.push(skippedProbeResult(step, entityResolutionFollowupStepLimitation()));
|
||
continue;
|
||
}
|
||
if (!derivedEntityResolution) {
|
||
derivedEntityResolution = deriveEntityResolution(queryResult, requestedEntity);
|
||
}
|
||
pushUnique(executedPrimitives, step.primitive_id);
|
||
probeResults.push(buildEntityResolutionResolveProbeResult({
|
||
queryResult,
|
||
resolution: derivedEntityResolution
|
||
}));
|
||
if (derivedEntityResolution?.resolution_status === "resolved") {
|
||
pushReason(reasonCodes, "pilot_resolve_entity_reference_from_catalog_rows");
|
||
}
|
||
else if (derivedEntityResolution?.resolution_status === "ambiguous") {
|
||
pushReason(reasonCodes, "pilot_resolve_entity_reference_requires_clarification");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_resolve_entity_reference_not_confirmed");
|
||
}
|
||
continue;
|
||
}
|
||
if (step.primitive_id === "probe_coverage") {
|
||
if (!queryResult || queryResult.error) {
|
||
skippedPrimitives.push(step.primitive_id);
|
||
probeResults.push(skippedProbeResult(step, entityResolutionFollowupStepLimitation()));
|
||
continue;
|
||
}
|
||
if (!derivedEntityResolution) {
|
||
derivedEntityResolution = deriveEntityResolution(queryResult, requestedEntity);
|
||
}
|
||
pushUnique(executedPrimitives, step.primitive_id);
|
||
probeResults.push(buildEntityResolutionCoverageProbeResult({
|
||
resolution: derivedEntityResolution
|
||
}));
|
||
pushReason(reasonCodes, "pilot_probe_coverage_executed_for_entity_resolution");
|
||
if (derivedEntityResolution?.resolution_status === "resolved") {
|
||
pushReason(reasonCodes, "pilot_entity_resolution_grounding_stable_for_downstream_probe");
|
||
}
|
||
else if (derivedEntityResolution?.resolution_status === "ambiguous") {
|
||
pushReason(reasonCodes, "pilot_entity_resolution_coverage_requires_clarification");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_entity_resolution_coverage_not_confirmed");
|
||
}
|
||
continue;
|
||
}
|
||
skippedPrimitives.push(step.primitive_id);
|
||
probeResults.push(skippedProbeResult(step, "pilot_entity_resolution_step_not_implemented"));
|
||
}
|
||
const sourceRowsSummary = queryResult ? summarizeEntityResolutionRows(queryResult) : null;
|
||
if (!derivedEntityResolution && queryResult && !queryResult.error) {
|
||
derivedEntityResolution = deriveEntityResolution(queryResult, requestedEntity);
|
||
}
|
||
if (derivedEntityResolution?.resolution_status === "resolved") {
|
||
pushReason(reasonCodes, "pilot_derived_entity_resolution_from_catalog_rows");
|
||
}
|
||
if (derivedEntityResolution?.resolution_status === "ambiguous") {
|
||
pushReason(reasonCodes, "pilot_entity_resolution_ambiguity_requires_clarification");
|
||
}
|
||
if (derivedEntityResolution?.resolution_status === "not_found") {
|
||
pushReason(reasonCodes, "pilot_entity_resolution_not_found_in_checked_catalog");
|
||
}
|
||
const evidence = (0, assistantMcpDiscoveryPolicy_1.resolveAssistantMcpDiscoveryEvidence)({
|
||
plan: planner.discovery_plan,
|
||
probeResults,
|
||
confirmedFacts: buildEntityResolutionConfirmedFacts(derivedEntityResolution),
|
||
inferredFacts: buildEntityResolutionInferredFacts(derivedEntityResolution),
|
||
unknownFacts: buildEntityResolutionUnknownFacts(derivedEntityResolution, requestedEntity),
|
||
sourceRowsSummary,
|
||
queryLimitations,
|
||
recommendedNextProbe: null
|
||
});
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "executed",
|
||
pilot_scope: "entity_resolution_search_v1",
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: executedPrimitives.length > 0,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: sourceRowsSummary,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: derivedEntityResolution,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: queryLimitations,
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
if (documentPilotEligible) {
|
||
let queryResult = null;
|
||
const filters = buildLifecycleFilters(planner);
|
||
const selection = (0, addressRecipeCatalog_1.selectAddressRecipe)("list_documents_by_counterparty", filters);
|
||
if (!selection.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_document_recipe_not_available");
|
||
const evidence = buildEmptyEvidence(planner, dryRun, probeResults, "Document-evidence recipe is not available");
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "unsupported",
|
||
pilot_scope: "counterparty_document_evidence_query_documents_v1",
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: false,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: null,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: ["Document-evidence recipe is not available"],
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
const recipePlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(selection.selected_recipe, filters);
|
||
for (const step of dryRun.execution_steps) {
|
||
if (step.primitive_id !== "query_documents") {
|
||
skippedPrimitives.push(step.primitive_id);
|
||
probeResults.push(skippedProbeResult(step, "pilot_only_executes_query_documents"));
|
||
continue;
|
||
}
|
||
queryResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: recipePlan.query,
|
||
limit: recipePlan.limit,
|
||
account_scope: recipePlan.account_scope
|
||
});
|
||
executedPrimitives.push(step.primitive_id);
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, queryResult));
|
||
if (queryResult.error) {
|
||
pushUnique(queryLimitations, queryResult.error);
|
||
pushReason(reasonCodes, "pilot_query_documents_mcp_error");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_query_documents_mcp_executed");
|
||
}
|
||
}
|
||
const sourceRowsSummary = queryResult ? summarizeDocumentRows(queryResult) : null;
|
||
const evidence = (0, assistantMcpDiscoveryPolicy_1.resolveAssistantMcpDiscoveryEvidence)({
|
||
plan: planner.discovery_plan,
|
||
probeResults,
|
||
confirmedFacts: queryResult ? buildDocumentConfirmedFacts(queryResult, counterparty, dateScope) : [],
|
||
inferredFacts: queryResult ? buildDocumentInferredFacts(queryResult, counterparty, dateScope) : [],
|
||
unknownFacts: buildDocumentUnknownFacts(dateScope, counterparty),
|
||
sourceRowsSummary,
|
||
queryLimitations,
|
||
recommendedNextProbe: "explain_evidence_basis"
|
||
});
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "executed",
|
||
pilot_scope: "counterparty_document_evidence_query_documents_v1",
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: executedPrimitives.length > 0,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: sourceRowsSummary,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: queryLimitations,
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
if (movementPilotEligible) {
|
||
let queryResult = null;
|
||
const filters = buildValueFlowFilters(planner);
|
||
const selection = (0, addressRecipeCatalog_1.selectAddressRecipe)("bank_operations_by_counterparty", filters);
|
||
if (!selection.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_movement_recipe_not_available");
|
||
const evidence = buildEmptyEvidence(planner, dryRun, probeResults, "Movement-evidence recipe is not available");
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "unsupported",
|
||
pilot_scope: "counterparty_movement_evidence_query_movements_v1",
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: false,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: null,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: ["Movement-evidence recipe is not available"],
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
const recipePlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(selection.selected_recipe, filters);
|
||
for (const step of dryRun.execution_steps) {
|
||
if (step.primitive_id !== "query_movements") {
|
||
skippedPrimitives.push(step.primitive_id);
|
||
probeResults.push(skippedProbeResult(step, "pilot_only_executes_query_movements"));
|
||
continue;
|
||
}
|
||
queryResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: recipePlan.query,
|
||
limit: recipePlan.limit,
|
||
account_scope: recipePlan.account_scope
|
||
});
|
||
executedPrimitives.push(step.primitive_id);
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, queryResult));
|
||
if (queryResult.error) {
|
||
pushUnique(queryLimitations, queryResult.error);
|
||
pushReason(reasonCodes, "pilot_query_movements_mcp_error");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_query_movements_mcp_executed");
|
||
}
|
||
}
|
||
const sourceRowsSummary = queryResult ? summarizeMovementRows(queryResult) : null;
|
||
const evidence = (0, assistantMcpDiscoveryPolicy_1.resolveAssistantMcpDiscoveryEvidence)({
|
||
plan: planner.discovery_plan,
|
||
probeResults,
|
||
confirmedFacts: queryResult ? buildMovementConfirmedFacts(queryResult, counterparty, dateScope) : [],
|
||
inferredFacts: queryResult ? buildMovementInferredFacts(queryResult, counterparty, dateScope) : [],
|
||
unknownFacts: buildMovementUnknownFacts(dateScope, counterparty),
|
||
sourceRowsSummary,
|
||
queryLimitations,
|
||
recommendedNextProbe: "explain_evidence_basis"
|
||
});
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "executed",
|
||
pilot_scope: "counterparty_movement_evidence_query_movements_v1",
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: executedPrimitives.length > 0,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: sourceRowsSummary,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: queryLimitations,
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
if (valueFlowPilotEligible) {
|
||
let queryResult = null;
|
||
const filters = buildValueFlowFilters(planner);
|
||
const valueFlowProfile = valueFlowPilotProfile(planner);
|
||
if (valueFlowProfile.direction === "bidirectional_net_value_flow") {
|
||
let incomingResult = null;
|
||
let outgoingResult = null;
|
||
const incomingSelection = (0, addressRecipeCatalog_1.selectAddressRecipe)("customer_revenue_and_payments", filters);
|
||
const outgoingSelection = (0, addressRecipeCatalog_1.selectAddressRecipe)("supplier_payouts_profile", filters);
|
||
if (!incomingSelection.selected_recipe || !outgoingSelection.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_bidirectional_value_flow_recipe_not_available");
|
||
const evidence = buildEmptyEvidence(planner, dryRun, probeResults, "Bidirectional value-flow recipes are not available");
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "unsupported",
|
||
pilot_scope: valueFlowProfile.scope,
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: false,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: null,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: ["Bidirectional value-flow recipes are not available"],
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
pushReason(reasonCodes, "pilot_bidirectional_value_flow_recipes_selected");
|
||
for (const step of dryRun.execution_steps) {
|
||
if (step.primitive_id !== "query_movements") {
|
||
skippedPrimitives.push(step.primitive_id);
|
||
probeResults.push(skippedProbeResult(step, "pilot_bidirectional_value_flow_uses_two_query_movements_and_derives_net"));
|
||
continue;
|
||
}
|
||
const incomingExecution = await executeCoverageAwareValueFlowQuery({
|
||
primitiveId: step.primitive_id,
|
||
recipePlanBuilder: (scopedFilters) => (0, addressRecipeCatalog_1.buildAddressRecipePlan)(incomingSelection.selected_recipe, scopedFilters),
|
||
baseFilters: filters,
|
||
dateScope,
|
||
maxProbeCount: planner.discovery_plan.execution_budget.max_probe_count,
|
||
maxRowsPerProbe: planner.discovery_plan.execution_budget.max_rows_per_probe,
|
||
deps: runtimeDeps
|
||
});
|
||
const outgoingExecution = await executeCoverageAwareValueFlowQuery({
|
||
primitiveId: step.primitive_id,
|
||
recipePlanBuilder: (scopedFilters) => (0, addressRecipeCatalog_1.buildAddressRecipePlan)(outgoingSelection.selected_recipe, scopedFilters),
|
||
baseFilters: filters,
|
||
dateScope,
|
||
maxProbeCount: planner.discovery_plan.execution_budget.max_probe_count,
|
||
maxRowsPerProbe: planner.discovery_plan.execution_budget.max_rows_per_probe,
|
||
deps: runtimeDeps
|
||
});
|
||
incomingResult = incomingExecution.result;
|
||
outgoingResult = outgoingExecution.result;
|
||
pushUnique(executedPrimitives, step.primitive_id);
|
||
probeResults.push(...incomingExecution.probe_results, ...outgoingExecution.probe_results);
|
||
for (const limitation of [...incomingExecution.query_limitations, ...outgoingExecution.query_limitations]) {
|
||
pushUnique(queryLimitations, limitation);
|
||
}
|
||
if (incomingResult?.error) {
|
||
pushReason(reasonCodes, "pilot_bidirectional_incoming_query_movements_mcp_error");
|
||
}
|
||
if (outgoingResult?.error) {
|
||
pushReason(reasonCodes, "pilot_bidirectional_outgoing_query_movements_mcp_error");
|
||
}
|
||
if (incomingResult?.coverage_recovered_by_period_chunking) {
|
||
pushReason(reasonCodes, "pilot_bidirectional_incoming_monthly_period_chunking_recovered_coverage");
|
||
}
|
||
if (outgoingResult?.coverage_recovered_by_period_chunking) {
|
||
pushReason(reasonCodes, "pilot_bidirectional_outgoing_monthly_period_chunking_recovered_coverage");
|
||
}
|
||
if (!incomingResult?.error || !outgoingResult?.error) {
|
||
pushReason(reasonCodes, "pilot_bidirectional_query_movements_mcp_executed");
|
||
}
|
||
}
|
||
const sourceRowsSummary = summarizeBidirectionalValueFlowRows({ incomingResult, outgoingResult });
|
||
const derivedBidirectionalValueFlow = deriveBidirectionalValueFlow({
|
||
incomingResult,
|
||
outgoingResult,
|
||
counterparty,
|
||
periodScope: dateScope,
|
||
aggregationAxis
|
||
});
|
||
if (derivedBidirectionalValueFlow) {
|
||
pushReason(reasonCodes, "pilot_derived_bidirectional_value_flow_from_confirmed_rows");
|
||
if (aggregationAxis === "month" && derivedBidirectionalValueFlow.monthly_breakdown.length > 0) {
|
||
pushReason(reasonCodes, "pilot_derived_bidirectional_monthly_breakdown_from_confirmed_rows");
|
||
}
|
||
}
|
||
const evidence = (0, assistantMcpDiscoveryPolicy_1.resolveAssistantMcpDiscoveryEvidence)({
|
||
plan: planner.discovery_plan,
|
||
probeResults,
|
||
confirmedFacts: buildBidirectionalValueFlowConfirmedFacts(derivedBidirectionalValueFlow),
|
||
inferredFacts: buildBidirectionalValueFlowInferredFacts(derivedBidirectionalValueFlow),
|
||
unknownFacts: buildBidirectionalValueFlowUnknownFacts(dateScope, derivedBidirectionalValueFlow),
|
||
sourceRowsSummary,
|
||
queryLimitations,
|
||
recommendedNextProbe: "explain_evidence_basis"
|
||
});
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "executed",
|
||
pilot_scope: valueFlowProfile.scope,
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: executedPrimitives.length > 0,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: sourceRowsSummary,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: derivedBidirectionalValueFlow,
|
||
query_limitations: queryLimitations,
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
const recipeIntent = valueFlowProfile.recipe_intent;
|
||
const selection = recipeIntent ? (0, addressRecipeCatalog_1.selectAddressRecipe)(recipeIntent, filters) : { selected_recipe: null };
|
||
if (!selection.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_value_flow_recipe_not_available");
|
||
const evidence = buildEmptyEvidence(planner, dryRun, probeResults, "Value-flow recipe is not available");
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "unsupported",
|
||
pilot_scope: valueFlowProfile.scope,
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: false,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: null,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: ["Value-flow recipe is not available"],
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
pushReason(reasonCodes, valueFlowProfile.direction === "outgoing_supplier_payout"
|
||
? "pilot_supplier_payout_recipe_selected"
|
||
: "pilot_customer_revenue_recipe_selected");
|
||
for (const step of dryRun.execution_steps) {
|
||
if (step.primitive_id !== "query_movements") {
|
||
skippedPrimitives.push(step.primitive_id);
|
||
probeResults.push(skippedProbeResult(step, "pilot_value_flow_uses_query_movements_and_derives_aggregate"));
|
||
continue;
|
||
}
|
||
const execution = await executeCoverageAwareValueFlowQuery({
|
||
primitiveId: step.primitive_id,
|
||
recipePlanBuilder: (scopedFilters) => (0, addressRecipeCatalog_1.buildAddressRecipePlan)(selection.selected_recipe, scopedFilters),
|
||
baseFilters: filters,
|
||
dateScope,
|
||
maxProbeCount: planner.discovery_plan.execution_budget.max_probe_count,
|
||
maxRowsPerProbe: planner.discovery_plan.execution_budget.max_rows_per_probe,
|
||
deps: runtimeDeps
|
||
});
|
||
queryResult = execution.result;
|
||
pushUnique(executedPrimitives, step.primitive_id);
|
||
probeResults.push(...execution.probe_results);
|
||
for (const limitation of execution.query_limitations) {
|
||
pushUnique(queryLimitations, limitation);
|
||
}
|
||
if (queryResult?.error) {
|
||
pushReason(reasonCodes, "pilot_query_movements_mcp_error");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_query_movements_mcp_executed");
|
||
}
|
||
if (queryResult?.coverage_recovered_by_period_chunking) {
|
||
pushReason(reasonCodes, "pilot_monthly_period_chunking_recovered_coverage");
|
||
}
|
||
}
|
||
const sourceRowsSummary = queryResult ? summarizeValueFlowRows(queryResult) : null;
|
||
if (planner.selected_chain_id === "value_flow_ranking" && rankingNeed) {
|
||
const derivedRankedValueFlow = deriveRankedValueFlow(queryResult, {
|
||
organizationScope,
|
||
periodScope: dateScope,
|
||
direction: valueFlowProfile.direction,
|
||
rankingNeed
|
||
});
|
||
if (derivedRankedValueFlow) {
|
||
pushReason(reasonCodes, "pilot_derived_ranked_value_flow_from_confirmed_rows");
|
||
}
|
||
const evidence = (0, assistantMcpDiscoveryPolicy_1.resolveAssistantMcpDiscoveryEvidence)({
|
||
plan: planner.discovery_plan,
|
||
probeResults,
|
||
confirmedFacts: buildRankedValueFlowConfirmedFacts(derivedRankedValueFlow),
|
||
inferredFacts: buildRankedValueFlowInferredFacts(derivedRankedValueFlow),
|
||
unknownFacts: buildRankedValueFlowUnknownFacts(dateScope, derivedRankedValueFlow),
|
||
sourceRowsSummary,
|
||
queryLimitations,
|
||
recommendedNextProbe: "explain_evidence_basis"
|
||
});
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "executed",
|
||
pilot_scope: valueFlowProfile.scope,
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: executedPrimitives.length > 0,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: sourceRowsSummary,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_ranked_value_flow: derivedRankedValueFlow,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: queryLimitations,
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
const derivedValueFlow = deriveValueFlow(queryResult, counterparty, dateScope, valueFlowProfile.direction, aggregationAxis);
|
||
if (derivedValueFlow) {
|
||
pushReason(reasonCodes, "pilot_derived_value_flow_from_confirmed_rows");
|
||
if (aggregationAxis === "month" && derivedValueFlow.monthly_breakdown.length > 0) {
|
||
pushReason(reasonCodes, "pilot_derived_value_flow_monthly_breakdown_from_confirmed_rows");
|
||
}
|
||
}
|
||
const evidence = (0, assistantMcpDiscoveryPolicy_1.resolveAssistantMcpDiscoveryEvidence)({
|
||
plan: planner.discovery_plan,
|
||
probeResults,
|
||
confirmedFacts: queryResult ? buildValueFlowConfirmedFacts(queryResult, counterparty, valueFlowProfile.direction) : [],
|
||
inferredFacts: buildValueFlowInferredFacts(derivedValueFlow),
|
||
unknownFacts: buildValueFlowUnknownFacts(dateScope, valueFlowProfile.direction, derivedValueFlow),
|
||
sourceRowsSummary,
|
||
queryLimitations,
|
||
recommendedNextProbe: "explain_evidence_basis"
|
||
});
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "executed",
|
||
pilot_scope: valueFlowProfile.scope,
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: executedPrimitives.length > 0,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: sourceRowsSummary,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_ranked_value_flow: null,
|
||
derived_value_flow: derivedValueFlow,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: queryLimitations,
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
let queryResult = null;
|
||
const filters = buildLifecycleFilters(planner);
|
||
const selection = (0, addressRecipeCatalog_1.selectAddressRecipe)("counterparty_activity_lifecycle", filters);
|
||
if (!selection.selected_recipe) {
|
||
pushReason(reasonCodes, "pilot_lifecycle_recipe_not_available");
|
||
const evidence = buildEmptyEvidence(planner, dryRun, probeResults, "Lifecycle recipe is not available");
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "unsupported",
|
||
pilot_scope: "counterparty_lifecycle_query_documents_v1",
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: false,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: null,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: ["Lifecycle recipe is not available"],
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
const recipePlan = (0, addressRecipeCatalog_1.buildAddressRecipePlan)(selection.selected_recipe, filters);
|
||
for (const step of dryRun.execution_steps) {
|
||
if (step.primitive_id !== "query_documents") {
|
||
skippedPrimitives.push(step.primitive_id);
|
||
probeResults.push(skippedProbeResult(step, "pilot_only_executes_query_documents"));
|
||
continue;
|
||
}
|
||
queryResult = await runtimeDeps.executeAddressMcpQuery({
|
||
query: recipePlan.query,
|
||
limit: recipePlan.limit,
|
||
account_scope: recipePlan.account_scope
|
||
});
|
||
executedPrimitives.push(step.primitive_id);
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, queryResult));
|
||
if (queryResult.error) {
|
||
pushUnique(queryLimitations, queryResult.error);
|
||
pushReason(reasonCodes, "pilot_query_documents_mcp_error");
|
||
}
|
||
else {
|
||
pushReason(reasonCodes, "pilot_query_documents_mcp_executed");
|
||
}
|
||
}
|
||
const sourceRowsSummary = queryResult ? summarizeLifecycleRows(queryResult) : null;
|
||
const derivedActivityPeriod = deriveActivityPeriod(queryResult);
|
||
if (derivedActivityPeriod) {
|
||
pushReason(reasonCodes, "pilot_derived_activity_period_from_confirmed_rows");
|
||
}
|
||
const evidence = (0, assistantMcpDiscoveryPolicy_1.resolveAssistantMcpDiscoveryEvidence)({
|
||
plan: planner.discovery_plan,
|
||
probeResults,
|
||
confirmedFacts: queryResult ? buildLifecycleConfirmedFacts(queryResult, counterparty) : [],
|
||
inferredFacts: queryResult ? buildLifecycleInferredFacts(queryResult) : [],
|
||
unknownFacts: buildLifecycleUnknownFacts(),
|
||
sourceRowsSummary,
|
||
queryLimitations,
|
||
recommendedNextProbe: "explain_evidence_basis"
|
||
});
|
||
return {
|
||
schema_version: exports.ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "executed",
|
||
pilot_scope: "counterparty_lifecycle_query_documents_v1",
|
||
dry_run: dryRun,
|
||
mcp_execution_performed: executedPrimitives.length > 0,
|
||
executed_primitives: executedPrimitives,
|
||
skipped_primitives: skippedPrimitives,
|
||
probe_results: probeResults,
|
||
evidence,
|
||
source_rows_summary: sourceRowsSummary,
|
||
derived_metadata_surface: null,
|
||
derived_entity_resolution: null,
|
||
derived_activity_period: derivedActivityPeriod,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: queryLimitations,
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|