1236 lines
46 KiB
TypeScript
1236 lines
46 KiB
TypeScript
import {
|
||
executeAddressMcpQuery,
|
||
type AddressMcpMetadataRowsResult
|
||
} from "./addressMcpClient";
|
||
import {
|
||
buildAssistantMcpDiscoveryRuntimeDryRun,
|
||
type AssistantMcpDiscoveryRuntimeDryRunContract,
|
||
type AssistantMcpDiscoveryRuntimeStepContract
|
||
} from "./assistantMcpDiscoveryRuntimeAdapter";
|
||
import type { AssistantMcpDiscoveryPlannerContract } from "./assistantMcpDiscoveryPlanner";
|
||
import {
|
||
resolveAssistantMcpDiscoveryEvidence,
|
||
type AssistantMcpDiscoveryEvidenceContract,
|
||
type AssistantMcpDiscoveryProbeResult
|
||
} from "./assistantMcpDiscoveryPolicy";
|
||
import { buildAddressRecipePlan, selectAddressRecipe } from "./addressRecipeCatalog";
|
||
import type { AddressFilterSet, AddressIntent } from "../types/addressQuery";
|
||
|
||
export const ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION =
|
||
"assistant_mcp_discovery_pilot_executor_v1" as const;
|
||
|
||
export type AssistantMcpDiscoveryPilotStatus =
|
||
| "executed"
|
||
| "skipped_needs_clarification"
|
||
| "blocked"
|
||
| "unsupported";
|
||
|
||
export interface AssistantMcpDiscoveryPilotExecutorDeps {
|
||
executeAddressMcpQuery: typeof executeAddressMcpQuery;
|
||
}
|
||
|
||
export interface AssistantMcpDiscoveryDerivedActivityPeriod {
|
||
first_activity_date: string;
|
||
latest_activity_date: string;
|
||
matched_rows: number;
|
||
duration_total_months: number;
|
||
duration_years: number;
|
||
duration_months_remainder: number;
|
||
duration_human_ru: string;
|
||
inference_basis: "first_and_latest_confirmed_1c_activity_rows";
|
||
}
|
||
|
||
export type AssistantMcpDiscoveryAggregationAxis = "month";
|
||
export type AssistantMcpDiscoveryNetDirection = "net_incoming" | "net_outgoing" | "balanced";
|
||
|
||
export interface AssistantMcpDiscoveryValueFlowMonthBucket {
|
||
month_bucket: string;
|
||
rows_with_amount: number;
|
||
total_amount: number;
|
||
total_amount_human_ru: string;
|
||
}
|
||
|
||
export interface AssistantMcpDiscoveryDerivedValueFlow {
|
||
value_flow_direction: "incoming_customer_revenue" | "outgoing_supplier_payout";
|
||
counterparty: string | null;
|
||
period_scope: string | null;
|
||
aggregation_axis: AssistantMcpDiscoveryAggregationAxis | null;
|
||
rows_matched: number;
|
||
rows_with_amount: number;
|
||
total_amount: number;
|
||
total_amount_human_ru: string;
|
||
first_movement_date: string | null;
|
||
latest_movement_date: string | null;
|
||
coverage_limited_by_probe_limit: boolean;
|
||
monthly_breakdown: AssistantMcpDiscoveryValueFlowMonthBucket[];
|
||
inference_basis: "sum_of_confirmed_1c_value_flow_rows";
|
||
}
|
||
|
||
export interface AssistantMcpDiscoveryValueFlowSideSummary {
|
||
rows_matched: number;
|
||
rows_with_amount: number;
|
||
total_amount: number;
|
||
total_amount_human_ru: string;
|
||
first_movement_date: string | null;
|
||
latest_movement_date: string | null;
|
||
coverage_limited_by_probe_limit: boolean;
|
||
}
|
||
|
||
export interface AssistantMcpDiscoveryBidirectionalValueFlowMonthBucket {
|
||
month_bucket: string;
|
||
incoming_total_amount: number;
|
||
incoming_total_amount_human_ru: string;
|
||
incoming_rows_with_amount: number;
|
||
outgoing_total_amount: number;
|
||
outgoing_total_amount_human_ru: string;
|
||
outgoing_rows_with_amount: number;
|
||
net_amount: number;
|
||
net_amount_human_ru: string;
|
||
net_direction: AssistantMcpDiscoveryNetDirection;
|
||
}
|
||
|
||
export interface AssistantMcpDiscoveryDerivedBidirectionalValueFlow {
|
||
counterparty: string | null;
|
||
period_scope: string | null;
|
||
aggregation_axis: AssistantMcpDiscoveryAggregationAxis | null;
|
||
incoming_customer_revenue: AssistantMcpDiscoveryValueFlowSideSummary;
|
||
outgoing_supplier_payout: AssistantMcpDiscoveryValueFlowSideSummary;
|
||
net_amount: number;
|
||
net_amount_human_ru: string;
|
||
net_direction: AssistantMcpDiscoveryNetDirection;
|
||
coverage_limited_by_probe_limit: boolean;
|
||
monthly_breakdown: AssistantMcpDiscoveryBidirectionalValueFlowMonthBucket[];
|
||
inference_basis: "incoming_minus_outgoing_confirmed_1c_value_flow_rows";
|
||
}
|
||
|
||
export type AssistantMcpDiscoveryPilotScope =
|
||
| "counterparty_lifecycle_query_documents_v1"
|
||
| "counterparty_value_flow_query_movements_v1"
|
||
| "counterparty_supplier_payout_query_movements_v1"
|
||
| "counterparty_bidirectional_value_flow_query_movements_v1";
|
||
|
||
export interface AssistantMcpDiscoveryPilotExecutionContract {
|
||
schema_version: typeof ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION;
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor";
|
||
pilot_status: AssistantMcpDiscoveryPilotStatus;
|
||
pilot_scope: AssistantMcpDiscoveryPilotScope;
|
||
dry_run: AssistantMcpDiscoveryRuntimeDryRunContract;
|
||
mcp_execution_performed: boolean;
|
||
executed_primitives: string[];
|
||
skipped_primitives: string[];
|
||
probe_results: AssistantMcpDiscoveryProbeResult[];
|
||
evidence: AssistantMcpDiscoveryEvidenceContract;
|
||
source_rows_summary: string | null;
|
||
derived_activity_period: AssistantMcpDiscoveryDerivedActivityPeriod | null;
|
||
derived_value_flow: AssistantMcpDiscoveryDerivedValueFlow | null;
|
||
derived_bidirectional_value_flow: AssistantMcpDiscoveryDerivedBidirectionalValueFlow | null;
|
||
query_limitations: string[];
|
||
reason_codes: string[];
|
||
}
|
||
|
||
type AddressMcpQueryExecutorResult = Awaited<ReturnType<typeof executeAddressMcpQuery>>;
|
||
|
||
const DEFAULT_DEPS: AssistantMcpDiscoveryPilotExecutorDeps = {
|
||
executeAddressMcpQuery
|
||
};
|
||
|
||
function toNonEmptyString(value: unknown): string | null {
|
||
if (value === null || value === undefined) {
|
||
return null;
|
||
}
|
||
const text = String(value).trim();
|
||
return text.length > 0 ? text : null;
|
||
}
|
||
|
||
function normalizeReasonCode(value: string): string | null {
|
||
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: string[], value: string): void {
|
||
const normalized = normalizeReasonCode(value);
|
||
if (normalized && !target.includes(normalized)) {
|
||
target.push(normalized);
|
||
}
|
||
}
|
||
|
||
function pushUnique(target: string[], value: string): void {
|
||
const text = value.trim();
|
||
if (text && !target.includes(text)) {
|
||
target.push(text);
|
||
}
|
||
}
|
||
|
||
function aggregationAxisForPlanner(
|
||
planner: AssistantMcpDiscoveryPlannerContract
|
||
): AssistantMcpDiscoveryAggregationAxis | null {
|
||
const axis = toNonEmptyString(planner.discovery_plan.turn_meaning_ref?.asked_aggregation_axis)?.toLowerCase();
|
||
return axis === "month" ? "month" : null;
|
||
}
|
||
|
||
function firstEntityCandidate(planner: AssistantMcpDiscoveryPlannerContract): string | null {
|
||
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: string | null): Pick<AddressFilterSet, "period_from" | "period_to"> {
|
||
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 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 buildLifecycleFilters(planner: AssistantMcpDiscoveryPlannerContract): AddressFilterSet {
|
||
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: AssistantMcpDiscoveryPlannerContract): AddressFilterSet {
|
||
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 isLifecyclePilotEligible(planner: AssistantMcpDiscoveryPlannerContract): boolean {
|
||
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 isValueFlowPilotEligible(planner: AssistantMcpDiscoveryPlannerContract): boolean {
|
||
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"))
|
||
);
|
||
}
|
||
|
||
interface ValueFlowPilotProfile {
|
||
scope: Extract<
|
||
AssistantMcpDiscoveryPilotScope,
|
||
| "counterparty_value_flow_query_movements_v1"
|
||
| "counterparty_supplier_payout_query_movements_v1"
|
||
| "counterparty_bidirectional_value_flow_query_movements_v1"
|
||
>;
|
||
recipe_intent: Extract<AddressIntent, "customer_revenue_and_payments" | "supplier_payouts_profile"> | null;
|
||
direction: AssistantMcpDiscoveryDerivedValueFlow["value_flow_direction"] | "bidirectional_net_value_flow";
|
||
}
|
||
|
||
function valueFlowPilotProfile(planner: AssistantMcpDiscoveryPlannerContract): ValueFlowPilotProfile {
|
||
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 skippedProbeResult(step: AssistantMcpDiscoveryRuntimeStepContract, limitation: string): AssistantMcpDiscoveryProbeResult {
|
||
return {
|
||
primitive_id: step.primitive_id,
|
||
status: "skipped",
|
||
rows_received: 0,
|
||
rows_matched: 0,
|
||
limitation
|
||
};
|
||
}
|
||
|
||
function queryResultToProbeResult(
|
||
primitiveId: string,
|
||
result: AddressMcpQueryExecutorResult
|
||
): AssistantMcpDiscoveryProbeResult {
|
||
return {
|
||
primitive_id: primitiveId,
|
||
status: result.error ? "error" : "ok",
|
||
rows_received: result.fetched_rows,
|
||
rows_matched: result.matched_rows,
|
||
limitation: result.error
|
||
};
|
||
}
|
||
|
||
function summarizeLifecycleRows(result: AddressMcpQueryExecutorResult): string | null {
|
||
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 summarizeValueFlowRows(result: AddressMcpQueryExecutorResult): string | null {
|
||
if (result.error) {
|
||
return null;
|
||
}
|
||
if (result.fetched_rows <= 0) {
|
||
return "0 MCP value-flow rows fetched";
|
||
}
|
||
return `${result.fetched_rows} MCP value-flow rows fetched, ${result.matched_rows} matched value-flow scope`;
|
||
}
|
||
|
||
function rowDateValue(row: Record<string, unknown>): string | null {
|
||
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: Record<string, unknown>): number | null {
|
||
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 monthBucketFromIsoDate(isoDate: string | null): string | null {
|
||
const match = isoDate?.match(/^(\d{4})-(\d{2})-\d{2}$/);
|
||
return match ? `${match[1]}-${match[2]}` : null;
|
||
}
|
||
|
||
function netDirectionFromAmount(amount: number): AssistantMcpDiscoveryNetDirection {
|
||
if (amount > 0) {
|
||
return "net_incoming";
|
||
}
|
||
if (amount < 0) {
|
||
return "net_outgoing";
|
||
}
|
||
return "balanced";
|
||
}
|
||
|
||
function monthDiff(firstIsoDate: string, latestIsoDate: string): number {
|
||
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: number): string {
|
||
const years = Math.floor(totalMonths / 12);
|
||
const months = totalMonths % 12;
|
||
const parts: string[] = [];
|
||
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: AddressMcpQueryExecutorResult | null
|
||
): AssistantMcpDiscoveryDerivedActivityPeriod | null {
|
||
if (!result || result.error || result.matched_rows <= 0) {
|
||
return null;
|
||
}
|
||
const dates = result.rows
|
||
.map((row) => rowDateValue(row))
|
||
.filter((value): value is string => 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: number): string {
|
||
const formatted = new Intl.NumberFormat("ru-RU", {
|
||
maximumFractionDigits: 2,
|
||
minimumFractionDigits: Number.isInteger(amount) ? 0 : 2
|
||
})
|
||
.format(amount)
|
||
.replace(/\u00a0/g, " ");
|
||
return `${formatted} руб.`;
|
||
}
|
||
|
||
function deriveValueFlowMonthBreakdown(
|
||
result: AddressMcpQueryExecutorResult | null,
|
||
aggregationAxis: AssistantMcpDiscoveryAggregationAxis | null
|
||
): AssistantMcpDiscoveryValueFlowMonthBucket[] {
|
||
if (!result || result.error || aggregationAxis !== "month") {
|
||
return [];
|
||
}
|
||
const buckets = new Map<string, { rows_with_amount: number; total_amount: number }>();
|
||
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: {
|
||
incomingResult: AddressMcpQueryExecutorResult | null;
|
||
outgoingResult: AddressMcpQueryExecutorResult | null;
|
||
aggregationAxis: AssistantMcpDiscoveryAggregationAxis | null;
|
||
}): AssistantMcpDiscoveryBidirectionalValueFlowMonthBucket[] {
|
||
if (input.aggregationAxis !== "month") {
|
||
return [];
|
||
}
|
||
|
||
const incomingBuckets = deriveValueFlowMonthBreakdown(input.incomingResult, "month");
|
||
const outgoingBuckets = deriveValueFlowMonthBreakdown(input.outgoingResult, "month");
|
||
const allMonthBuckets = new Set<string>();
|
||
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 deriveValueFlow(
|
||
result: AddressMcpQueryExecutorResult | null,
|
||
counterparty: string | null,
|
||
periodScope: string | null,
|
||
direction: AssistantMcpDiscoveryDerivedValueFlow["value_flow_direction"],
|
||
probeLimit: number,
|
||
aggregationAxis: AssistantMcpDiscoveryAggregationAxis | null
|
||
): AssistantMcpDiscoveryDerivedValueFlow | null {
|
||
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): value is string => 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.matched_rows >= probeLimit,
|
||
monthly_breakdown: deriveValueFlowMonthBreakdown(result, aggregationAxis),
|
||
inference_basis: "sum_of_confirmed_1c_value_flow_rows"
|
||
};
|
||
}
|
||
|
||
function deriveValueFlowSideSummary(
|
||
result: AddressMcpQueryExecutorResult | null,
|
||
probeLimit: number
|
||
): AssistantMcpDiscoveryValueFlowSideSummary {
|
||
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
|
||
};
|
||
}
|
||
|
||
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): value is string => 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.matched_rows >= probeLimit
|
||
};
|
||
}
|
||
|
||
function deriveBidirectionalValueFlow(input: {
|
||
incomingResult: AddressMcpQueryExecutorResult | null;
|
||
outgoingResult: AddressMcpQueryExecutorResult | null;
|
||
counterparty: string | null;
|
||
periodScope: string | null;
|
||
probeLimit: number;
|
||
aggregationAxis: AssistantMcpDiscoveryAggregationAxis | null;
|
||
}): AssistantMcpDiscoveryDerivedBidirectionalValueFlow | null {
|
||
const incoming = deriveValueFlowSideSummary(input.incomingResult, input.probeLimit);
|
||
const outgoing = deriveValueFlowSideSummary(input.outgoingResult, input.probeLimit);
|
||
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,
|
||
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: {
|
||
incomingResult: AddressMcpQueryExecutorResult | null;
|
||
outgoingResult: AddressMcpQueryExecutorResult | null;
|
||
}): string | null {
|
||
const incoming = input.incomingResult;
|
||
const outgoing = input.outgoingResult;
|
||
if (!incoming && !outgoing) {
|
||
return null;
|
||
}
|
||
const incomingSummary = incoming?.error
|
||
? "incoming value-flow query failed"
|
||
: `${incoming?.fetched_rows ?? 0} incoming value-flow rows fetched, ${incoming?.matched_rows ?? 0} matched`;
|
||
const outgoingSummary = outgoing?.error
|
||
? "outgoing supplier-payout query failed"
|
||
: `${outgoing?.fetched_rows ?? 0} outgoing supplier-payout rows fetched, ${outgoing?.matched_rows ?? 0} matched`;
|
||
return `${incomingSummary}; ${outgoingSummary}`;
|
||
}
|
||
|
||
function buildLifecycleConfirmedFacts(result: AddressMcpQueryExecutorResult, counterparty: string | null): string[] {
|
||
if (result.error || result.matched_rows <= 0) {
|
||
return [];
|
||
}
|
||
return [
|
||
counterparty
|
||
? `1C activity rows were found for counterparty ${counterparty}`
|
||
: "1C activity rows were found for the requested counterparty scope"
|
||
];
|
||
}
|
||
|
||
function buildValueFlowConfirmedFacts(
|
||
result: AddressMcpQueryExecutorResult,
|
||
counterparty: string | null,
|
||
direction: AssistantMcpDiscoveryDerivedValueFlow["value_flow_direction"]
|
||
): string[] {
|
||
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 buildBidirectionalValueFlowConfirmedFacts(
|
||
derived: AssistantMcpDiscoveryDerivedBidirectionalValueFlow | null
|
||
): string[] {
|
||
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 buildLifecycleInferredFacts(result: AddressMcpQueryExecutorResult): string[] {
|
||
if (result.error || result.fetched_rows <= 0) {
|
||
return [];
|
||
}
|
||
return ["Business activity duration may be inferred from first and latest confirmed 1C activity rows"];
|
||
}
|
||
|
||
function buildValueFlowInferredFacts(derived: AssistantMcpDiscoveryDerivedValueFlow | null): string[] {
|
||
if (!derived) {
|
||
return [];
|
||
}
|
||
const facts: string[] = [];
|
||
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.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 buildBidirectionalValueFlowInferredFacts(
|
||
derived: AssistantMcpDiscoveryDerivedBidirectionalValueFlow | null
|
||
): string[] {
|
||
if (!derived) {
|
||
return [];
|
||
}
|
||
const facts = ["Counterparty net value-flow was calculated as incoming confirmed 1C rows minus outgoing confirmed 1C rows"];
|
||
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(): string[] {
|
||
return ["Legal registration date is not proven by this MCP discovery pilot"];
|
||
}
|
||
|
||
function buildValueFlowUnknownFacts(
|
||
periodScope: string | null,
|
||
direction: AssistantMcpDiscoveryDerivedValueFlow["value_flow_direction"],
|
||
derived: AssistantMcpDiscoveryDerivedValueFlow | null
|
||
): string[] {
|
||
const unknownFacts: string[] = [];
|
||
if (derived?.coverage_limited_by_probe_limit) {
|
||
unknownFacts.push("Complete requested-period coverage is not proven because the MCP discovery probe row limit was reached");
|
||
}
|
||
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 buildBidirectionalValueFlowUnknownFacts(
|
||
periodScope: string | null,
|
||
derived: AssistantMcpDiscoveryDerivedBidirectionalValueFlow | null
|
||
): string[] {
|
||
const unknownFacts: string[] = [];
|
||
if (derived?.coverage_limited_by_probe_limit) {
|
||
unknownFacts.push(
|
||
"Complete requested-period coverage for bidirectional value-flow is not proven because at least one MCP discovery probe row limit was reached"
|
||
);
|
||
}
|
||
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: AssistantMcpDiscoveryPlannerContract,
|
||
dryRun: AssistantMcpDiscoveryRuntimeDryRunContract,
|
||
probeResults: AssistantMcpDiscoveryProbeResult[],
|
||
reason: string
|
||
): AssistantMcpDiscoveryEvidenceContract {
|
||
return resolveAssistantMcpDiscoveryEvidence({
|
||
plan: planner.discovery_plan,
|
||
probeResults,
|
||
unknownFacts: [reason],
|
||
queryLimitations: [reason],
|
||
recommendedNextProbe: dryRun.user_facing_fallback
|
||
});
|
||
}
|
||
|
||
export async function executeAssistantMcpDiscoveryPilot(
|
||
planner: AssistantMcpDiscoveryPlannerContract,
|
||
deps: AssistantMcpDiscoveryPilotExecutorDeps = DEFAULT_DEPS
|
||
): Promise<AssistantMcpDiscoveryPilotExecutionContract> {
|
||
const dryRun = buildAssistantMcpDiscoveryRuntimeDryRun(planner);
|
||
const reasonCodes = [...dryRun.reason_codes];
|
||
const executedPrimitives: string[] = [];
|
||
const skippedPrimitives: string[] = [];
|
||
const probeResults: AssistantMcpDiscoveryProbeResult[] = [];
|
||
const queryLimitations: string[] = [];
|
||
|
||
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: ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "blocked",
|
||
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_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: ASSISTANT_MCP_DISCOVERY_PILOT_EXECUTOR_SCHEMA_VERSION,
|
||
policy_owner: "assistantMcpDiscoveryPilotExecutor",
|
||
pilot_status: "skipped_needs_clarification",
|
||
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_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 lifecyclePilotEligible = isLifecyclePilotEligible(planner);
|
||
const valueFlowPilotEligible = isValueFlowPilotEligible(planner);
|
||
|
||
if (!lifecyclePilotEligible && !valueFlowPilotEligible) {
|
||
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: 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_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 aggregationAxis = aggregationAxisForPlanner(planner);
|
||
|
||
if (valueFlowPilotEligible) {
|
||
let queryResult: AddressMcpQueryExecutorResult | null = null;
|
||
const filters = buildValueFlowFilters(planner);
|
||
const valueFlowProfile = valueFlowPilotProfile(planner);
|
||
if (valueFlowProfile.direction === "bidirectional_net_value_flow") {
|
||
let incomingResult: AddressMcpQueryExecutorResult | null = null;
|
||
let outgoingResult: AddressMcpQueryExecutorResult | null = null;
|
||
const incomingSelection = selectAddressRecipe("customer_revenue_and_payments", filters);
|
||
const outgoingSelection = 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: 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_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");
|
||
const incomingRecipePlan = buildAddressRecipePlan(incomingSelection.selected_recipe, filters);
|
||
const outgoingRecipePlan = buildAddressRecipePlan(outgoingSelection.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_bidirectional_value_flow_uses_two_query_movements_and_derives_net")
|
||
);
|
||
continue;
|
||
}
|
||
|
||
incomingResult = await deps.executeAddressMcpQuery({
|
||
query: incomingRecipePlan.query,
|
||
limit: incomingRecipePlan.limit,
|
||
account_scope: incomingRecipePlan.account_scope
|
||
});
|
||
outgoingResult = await deps.executeAddressMcpQuery({
|
||
query: outgoingRecipePlan.query,
|
||
limit: outgoingRecipePlan.limit,
|
||
account_scope: outgoingRecipePlan.account_scope
|
||
});
|
||
pushUnique(executedPrimitives, step.primitive_id);
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, incomingResult));
|
||
probeResults.push(queryResultToProbeResult(step.primitive_id, outgoingResult));
|
||
if (incomingResult.error) {
|
||
pushUnique(queryLimitations, incomingResult.error);
|
||
pushReason(reasonCodes, "pilot_bidirectional_incoming_query_movements_mcp_error");
|
||
}
|
||
if (outgoingResult.error) {
|
||
pushUnique(queryLimitations, outgoingResult.error);
|
||
pushReason(reasonCodes, "pilot_bidirectional_outgoing_query_movements_mcp_error");
|
||
}
|
||
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,
|
||
probeLimit: planner.discovery_plan.execution_budget.max_rows_per_probe,
|
||
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 = 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: 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_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 ? 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: 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_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"
|
||
);
|
||
|
||
const recipePlan = 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_value_flow_uses_query_movements_and_derives_aggregate"));
|
||
continue;
|
||
}
|
||
queryResult = await deps.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 ? summarizeValueFlowRows(queryResult) : null;
|
||
const derivedValueFlow = deriveValueFlow(
|
||
queryResult,
|
||
counterparty,
|
||
dateScope,
|
||
valueFlowProfile.direction,
|
||
planner.discovery_plan.execution_budget.max_rows_per_probe,
|
||
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 = 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: 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_activity_period: null,
|
||
derived_value_flow: derivedValueFlow,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: queryLimitations,
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
|
||
let queryResult: AddressMcpQueryExecutorResult | null = null;
|
||
const filters = buildLifecycleFilters(planner);
|
||
const selection = 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: 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_activity_period: null,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: ["Lifecycle recipe is not available"],
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
|
||
const recipePlan = 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 deps.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 = 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: 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_activity_period: derivedActivityPeriod,
|
||
derived_value_flow: null,
|
||
derived_bidirectional_value_flow: null,
|
||
query_limitations: queryLimitations,
|
||
reason_codes: reasonCodes
|
||
};
|
||
}
|
||
|
||
export type AssistantMcpDiscoveryPilotMetadataResult = AddressMcpMetadataRowsResult;
|