@taxdao/fintax-mcp 0.2.0

package/dist/tools/extended/configuration-tools.js

@@ -0,0 +1,871 @@
+import { accountingRuleQueryInputSchema, accountingRuleSaveInputSchema, allocationConfigSaveInputSchema, allocationQueryInputSchema, generatorConfigSaveInputSchema, mappingConfigQueryInputSchema, mappingConfigSaveInputSchema, pnlConfigSaveInputSchema, runGeneratorOperationInputSchema, } from '../../schemas/domains/configuration.js';
+import { executePlannedInputSchema, previewAllocationInputSchema, previewAllocationOutputSchema, runPnlCalculationInputSchema, } from '../../schemas/domains/extended-operations.js';
+import { operationResultSchemas } from '../../schemas/domains/extended-operation-results.js';
+import { queryAccountingRulesOutputSchema, queryAllocationOutputSchema, queryMappingConfigOutputSchema, } from '../../schemas/domains/extended-query-results.js';
+import { createPublicInputSchema } from '../../schemas/public-input.js';
+import { createPnlCalculationJobId } from '../../policies/job-reference.js';
+import { FinTaxError } from '../../errors/fintax-error.js';
+import { hashOperationValue } from '../../policies/operation-plan.js';
+import { executeIdempotentWrite } from '../core-edit/idempotent-write.js';
+import { asRecord, executePlannedOperation, issueOperationPlan, operationResult, querySummary, requiredUpstreamArray, resultSummary, } from './tool-support.js';
+import { accountingRulesQueryOutput, allocationQueryOutput, mappingConfigQueryOutput, } from './query-output.js';
+const readAnnotations = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+};
+const writeAnnotations = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+};
+const mappingCapabilities = {
+    attribute_definition: {
+        list: 'suite.config.map_attr_definition.list',
+        detail: 'suite.config.map_attr_definition.detail',
+        create: 'suite.config.map_attr_definition.create',
+        update: 'suite.config.map_attr_definition.update',
+    },
+    attribute_fill: {
+        list: 'suite.config.map_attribute_fill.list',
+        detail: 'suite.config.map_attribute_fill.detail',
+        create: 'suite.config.map_attribute_fill.create',
+        update: 'suite.config.map_attribute_fill.update',
+    },
+    source_handler: {
+        list: 'suite.config.map_source_handler.list',
+        detail: 'suite.config.map_source_handler.detail',
+    },
+};
+export const queryMappingConfigTool = {
+    name: 'query_mapping_config',
+    title: 'Query Mapping Configuration',
+    description: 'Query attribute-definition, attribute-fill, or source-handler lists and details with stable business fields and pagination. Do not use it to invoke callbacks or internal run entry points or to read connection credentials.',
+    risk: 'R0',
+    exposurePack: 'configuration',
+    capabilityIds: Object.values(mappingCapabilities).flatMap((value) => Object.values(value)),
+    fileAccess: 'none',
+    publicInputSchema: createPublicInputSchema(mappingConfigQueryInputSchema),
+    inputSchema: mappingConfigQueryInputSchema,
+    outputSchema: queryMappingConfigOutputSchema,
+    annotations: readAnnotations,
+    async execute(rawInput, context) {
+        const input = mappingConfigQueryInputSchema.parse(rawInput);
+        const capability = mappingCapabilities[input.object_type][input.view];
+        const raw = await context.callCapability(capability, input.view === 'detail'
+            ? { object_id: input.object_id }
+            : {
+                query: {
+                    search: input.search,
+                    status: input.status,
+                    source_key: input.source_key,
+                    biz_type_no: input.biz_type_no,
+                    source_category: input.source_category,
+                    source_code: input.source_code,
+                    line_type: input.line_type,
+                    system_type: input.system_type,
+                    target_field: input.target_field,
+                    page: input.page,
+                    page_size: input.page_size,
+                },
+            }, input.context.org_id);
+        return mappingConfigQueryOutput({
+            view: input.view,
+            objectType: input.object_type,
+            raw,
+            context,
+            capabilityId: capability,
+        });
+    },
+    summarize: querySummary,
+};
+function resultTargetId(raw, field) {
+    const id = asRecord(raw)[field];
+    if (typeof id === 'string')
+        return id;
+    throw new FinTaxError('UPSTREAM_UNAVAILABLE', 'The FinTax save result is missing a valid object ID');
+}
+function configurationIdentityResult(raw) {
+    const value = asRecord(raw);
+    return { id: value.id, version: value.version };
+}
+function accountingRuleResult(raw) {
+    const value = asRecord(raw);
+    return {
+        id: value.id,
+        ...(typeof value.version === 'number' ? { version: value.version } : {}),
+        ...(typeof value.ready_status === 'string'
+            ? { ready_status: value.ready_status }
+            : {}),
+    };
+}
+function allocationConfigResult(raw) {
+    const value = asRecord(raw);
+    if (typeof value.cfg_head_id === 'string') {
+        return {
+            cfg_head_id: value.cfg_head_id,
+            version: value.version,
+            ratio_total: value.ratio_total,
+            line_count: value.line_count,
+        };
+    }
+    return {
+        id: value.id,
+        ...(typeof value.version === 'number' ? { version: value.version } : {}),
+    };
+}
+function pnlConfigResult(raw) {
+    const value = asRecord(raw);
+    if (typeof value.bucket_id === 'string') {
+        return {
+            id: value.id,
+            bucket_id: value.bucket_id,
+            sub_account_id: value.sub_account_id,
+            joined_at: value.joined_at,
+            active: value.active,
+            lock_version: value.lock_version,
+        };
+    }
+    return {
+        id: value.id,
+        status: value.status,
+        lock_version: value.lock_version,
+    };
+}
+function allocationResult(raw) {
+    const value = asRecord(raw);
+    return {
+        hit: value.hit,
+        head_ids: value.head_ids,
+        already_exists_count: value.already_exists_count,
+        line_count: value.line_count,
+        total_base_amount: value.total_base_amount,
+    };
+}
+function pnlCalculationResult(raw) {
+    const value = asRecord(raw);
+    return {
+        id: value.id,
+        mode: value.mode,
+        status: value.status,
+        bucket_id: value.bucket_id,
+        symbol: value.symbol ?? null,
+        from_date: value.from_date,
+        to_date: value.to_date,
+        lines_processed: value.lines_processed,
+        ins_created: value.ins_created,
+        outs_created: value.outs_created,
+        transfers_created: value.transfers_created,
+        total_realized_gl: value.total_realized_gl ?? null,
+        started_at: value.started_at ?? null,
+        completed_at: value.completed_at ?? null,
+        created_at: value.created_at,
+    };
+}
+function generatorRunResult(raw) {
+    const value = asRecord(raw);
+    return {
+        success: value.success,
+        created_count: value.created_count,
+        status: value.status,
+    };
+}
+function allocationPreviewSnapshot(raw) {
+    const value = asRecord(raw);
+    const lines = requiredUpstreamArray(value.lines).map(asRecord);
+    return {
+        journal_number: value.journal_number,
+        hit: value.hit,
+        lines: lines.map((line) => {
+            const expanded = requiredUpstreamArray(line.expanded).map(asRecord);
+            return {
+                src_line_no: line.src_line_no,
+                coa_code: line.coa_code,
+                net_base: line.net_base,
+                expanded: expanded.map((item) => ({
+                    ratio: item.ratio,
+                    coa_code: item.coa_code,
+                    base_amount: item.base_amount,
+                })),
+            };
+        }),
+    };
+}
+function allocationPlanSummary(output) {
+    const parsed = previewAllocationOutputSchema.parse(output);
+    const targetLines = parsed.data.preview.lines.reduce((total, line) => total + line.expanded.length, 0);
+    const hit = parsed.data.preview.hit
+        ? 'matched a configuration'
+        : 'did not match a configuration';
+    return `The allocation preview ${hit}, with ${parsed.data.preview.lines.length} source lines and ${targetLines} target lines; user confirmation is required before execution.`;
+}
+async function saveConfig(options) {
+    const execute = () => executeIdempotentWrite({
+        toolName: options.toolName,
+        idempotencyKey: options.idempotencyKey,
+        orgId: options.orgId,
+        fingerprintValue: options.fingerprint,
+        capabilityId: options.capabilityId,
+        capabilityInput: options.capabilityInput,
+        context: options.context,
+        outputSchema: options.outputSchema,
+        ...(options.recovery === undefined ? {} : { recovery: options.recovery }),
+        ...(options.objectId === undefined
+            ? {}
+            : {
+                target: { field: 'object_id', id: options.objectId },
+            }),
+        buildOutput: (raw) => operationResult({
+            operation: options.toolName,
+            targetType: options.objectType,
+            targetIds: [resultTargetId(raw, options.targetIdField ?? 'id')],
+            result: options.projectResult(raw),
+            outputSchema: options.outputSchema,
+            context: options.context,
+            sourceOperation: options.capabilityId.replace(/^suite\./, ''),
+        }),
+    });
+    return options.objectId === undefined
+        ? execute()
+        : options.context.withResourceLock(`${options.objectType}:${options.objectId}`, execute);
+}
+export const saveMappingConfigTool = {
+    name: 'save_mapping_config',
+    title: 'Save Mapping Configuration',
+    description: 'Create or update attribute-definition and attribute-fill configuration. The configuration is saved immediately, but no callback is run. This Tool cannot write source handlers, stored procedures, internal jobs, or delete configuration.',
+    risk: 'R1',
+    exposurePack: 'configuration',
+    capabilityIds: [
+        'suite.config.map_attr_definition.create',
+        'suite.config.map_attr_definition.update',
+        'suite.config.map_attribute_fill.create',
+        'suite.config.map_attribute_fill.update',
+    ],
+    fileAccess: 'none',
+    publicInputSchema: createPublicInputSchema(mappingConfigSaveInputSchema),
+    inputSchema: mappingConfigSaveInputSchema,
+    outputSchema: operationResultSchemas.save_mapping_config,
+    annotations: writeAnnotations,
+    async execute(rawInput, context) {
+        const input = mappingConfigSaveInputSchema.parse(rawInput);
+        const capability = mappingCapabilities[input.object_type][input.operation];
+        const recovery = 'object_id' in input
+            ? {
+                tool: 'query_mapping_config',
+                input: {
+                    context: { org_id: input.context.org_id },
+                    view: 'detail',
+                    object_type: input.object_type,
+                    object_id: input.object_id,
+                },
+            }
+            : {
+                tool: 'query_mapping_config',
+                input: {
+                    context: { org_id: input.context.org_id },
+                    view: 'list',
+                    object_type: input.object_type,
+                    ...(input.object_type === 'attribute_definition'
+                        ? {
+                            source_key: input.values.source_key,
+                            biz_type_no: input.values.biz_type_no,
+                        }
+                        : {
+                            source_category: input.values.source_category,
+                            source_code: input.values.source_code,
+                            line_type: input.values.line_type,
+                            system_type: input.values.system_type,
+                            target_field: input.values.target_field,
+                        }),
+                    page: 1,
+                    page_size: 20,
+                },
+            };
+        return saveConfig({
+            toolName: 'save_mapping_config',
+            objectType: input.object_type,
+            ...('object_id' in input ? { objectId: input.object_id } : {}),
+            idempotencyKey: input.idempotency_key,
+            orgId: input.context.org_id,
+            capabilityId: capability,
+            capabilityInput: {
+                ...('object_id' in input ? { object_id: input.object_id } : {}),
+                ...('version' in input ? { version: input.version } : {}),
+                values: input.values,
+            },
+            fingerprint: input,
+            context,
+            outputSchema: operationResultSchemas.save_mapping_config,
+            projectResult: configurationIdentityResult,
+            recovery,
+        });
+    },
+    summarize: resultSummary,
+};
+const ruleCapabilities = {
+    rule_header: {
+        list: 'suite.config.accounting_rule.list',
+        detail: 'suite.config.accounting_rule.detail',
+        create: 'suite.config.accounting_rule.create',
+        update: 'suite.config.accounting_rule.update',
+    },
+    precheck: {
+        list: 'suite.config.precheck_rule.tree',
+        detail: 'suite.config.precheck_rule.detail',
+        create: 'suite.config.precheck_rule.create',
+        update: 'suite.config.precheck_rule.update',
+    },
+};
+export const queryAccountingRulesTool = {
+    name: 'query_accounting_rules',
+    title: 'Query Accounting Rules',
+    description: 'Query accounting-rule headers or precheck configuration lists and details, including status, scope, match conditions, and version. It does not return internal expression implementations or execute rules.',
+    risk: 'R0',
+    exposurePack: 'configuration',
+    capabilityIds: Object.values(ruleCapabilities).flatMap((value) => [
+        value.list,
+        value.detail,
+    ]),
+    fileAccess: 'none',
+    publicInputSchema: createPublicInputSchema(accountingRuleQueryInputSchema),
+    inputSchema: accountingRuleQueryInputSchema,
+    outputSchema: queryAccountingRulesOutputSchema,
+    annotations: readAnnotations,
+    async execute(rawInput, context) {
+        const input = accountingRuleQueryInputSchema.parse(rawInput);
+        const capability = ruleCapabilities[input.object_type][input.view];
+        const raw = await context.callCapability(capability, input.view === 'detail'
+            ? { object_id: input.object_id }
+            : {
+                query: {
+                    ledger_id: input.ledger_id,
+                    keyword: input.search,
+                    search: input.search,
+                    is_enabled: input.status,
+                    ready_status: input.object_type === 'precheck'
+                        ? input.ready_status
+                        : undefined,
+                    config_level: input.object_type === 'precheck'
+                        ? input.config_level
+                        : undefined,
+                    effective_at: input.object_type === 'precheck'
+                        ? input.effective_at
+                        : undefined,
+                    priority_min: input.object_type === 'rule_header'
+                        ? input.priority_min
+                        : undefined,
+                    priority_max: input.object_type === 'rule_header'
+                        ? input.priority_max
+                        : undefined,
+                    effective_from_start: input.object_type === 'rule_header'
+                        ? input.effective_from_start
+                        : undefined,
+                    effective_from_end: input.object_type === 'rule_header'
+                        ? input.effective_from_end
+                        : undefined,
+                    page: input.page,
+                    page_size: input.page_size,
+                },
+            }, input.context.org_id);
+        return accountingRulesQueryOutput({
+            view: input.view,
+            objectType: input.object_type,
+            raw,
+            context,
+            capabilityId: capability,
+        });
+    },
+    summarize: querySummary,
+};
+function expandAttributes(prefix, values) {
+    const key = `${prefix}_attributes`;
+    const attributes = values[key];
+    if (!Array.isArray(attributes))
+        return values;
+    const expanded = { ...values };
+    Reflect.deleteProperty(expanded, key);
+    for (let index = 0; index < 12; index += 1) {
+        expanded[`${prefix}_attribute${index + 1}`] = attributes[index] ?? null;
+    }
+    return expanded;
+}
+export const saveAccountingRuleTool = {
+    name: 'save_accounting_rule',
+    title: 'Save Accounting Rule',
+    description: 'Create or update an accounting-rule header or account precheck configuration, immediately changing subsequent accounting configuration. It cannot maintain rule-line expressions, delete configuration, or execute automatic accounting.',
+    risk: 'R2',
+    exposurePack: 'configuration',
+    capabilityIds: Object.values(ruleCapabilities).flatMap((value) => [
+        value.create,
+        value.update,
+    ]),
+    fileAccess: 'none',
+    publicInputSchema: createPublicInputSchema(accountingRuleSaveInputSchema),
+    inputSchema: accountingRuleSaveInputSchema,
+    outputSchema: operationResultSchemas.save_accounting_rule,
+    annotations: writeAnnotations,
+    async execute(rawInput, context) {
+        const input = accountingRuleSaveInputSchema.parse(rawInput);
+        const capability = ruleCapabilities[input.object_type][input.operation];
+        let values = input.values;
+        if (input.object_type === 'precheck') {
+            values = expandAttributes('counter', expandAttributes('main', values));
+        }
+        const recovery = 'object_id' in input
+            ? {
+                tool: 'query_accounting_rules',
+                input: {
+                    context: { org_id: input.context.org_id },
+                    view: 'detail',
+                    object_type: input.object_type,
+                    object_id: input.object_id,
+                },
+            }
+            : {
+                tool: 'query_accounting_rules',
+                input: {
+                    context: { org_id: input.context.org_id },
+                    view: 'list',
+                    object_type: input.object_type,
+                    ledger_id: input.values.ledger_id,
+                    ...(input.object_type === 'rule_header'
+                        ? { search: input.values.rule_code }
+                        : { config_level: input.values.config_level }),
+                    page: 1,
+                    page_size: 20,
+                },
+            };
+        return saveConfig({
+            toolName: 'save_accounting_rule',
+            objectType: input.object_type,
+            ...('object_id' in input ? { objectId: input.object_id } : {}),
+            idempotencyKey: input.idempotency_key,
+            orgId: input.context.org_id,
+            capabilityId: capability,
+            capabilityInput: {
+                ...('object_id' in input ? { object_id: input.object_id } : {}),
+                ...('version' in input ? { version: input.version } : {}),
+                values,
+            },
+            fingerprint: input,
+            context,
+            outputSchema: operationResultSchemas.save_accounting_rule,
+            projectResult: accountingRuleResult,
+            recovery,
+        });
+    },
+    summarize: resultSummary,
+};
+const allocationReadCapabilities = {
+    config_list: 'suite.config.allocation_config.list',
+    config_detail: 'suite.config.allocation_config.detail',
+    result_list: 'suite.aloc.detail.list',
+    result_detail: 'suite.aloc.detail.detail',
+    summary: 'suite.aloc.detail.summary',
+};
+export const queryAllocationTool = {
+    name: 'query_allocation',
+    title: 'Query Allocation Configuration and Results',
+    description: 'Query allocation headers, configuration details, generated allocation results, or summaries. It adapts existing results and does not recalculate allocations in MCP.',
+    risk: 'R0',
+    exposurePack: 'configuration',
+    capabilityIds: Object.values(allocationReadCapabilities),
+    fileAccess: 'none',
+    publicInputSchema: createPublicInputSchema(allocationQueryInputSchema),
+    inputSchema: allocationQueryInputSchema,
+    outputSchema: queryAllocationOutputSchema,
+    annotations: readAnnotations,
+    async execute(rawInput, context) {
+        const input = allocationQueryInputSchema.parse(rawInput);
+        const capability = allocationReadCapabilities[input.view];
+        const capabilityInput = input.view === 'config_detail'
+            ? { object_id: input.config_id }
+            : input.view === 'result_detail'
+                ? { object_id: input.result_id }
+                : {
+                    query: {
+                        ledger_id: input.ledger_id,
+                        period_name: 'period' in input ? input.period : undefined,
+                        status: 'status' in input ? input.status : undefined,
+                        gen_mode: 'gen_mode' in input ? input.gen_mode : undefined,
+                        coa_code: 'coa_code' in input ? input.coa_code : undefined,
+                        enabled: 'enabled' in input ? input.enabled : undefined,
+                        search: 'search' in input ? input.search : undefined,
+                        page: 'page' in input ? input.page : undefined,
+                        page_size: 'page_size' in input ? input.page_size : undefined,
+                    },
+                };
+        const raw = await context.callCapability(capability, capabilityInput, input.context.org_id);
+        return allocationQueryOutput({
+            view: input.view,
+            raw,
+            context,
+            capabilityId: capability,
+        });
+    },
+    summarize: querySummary,
+};
+export const saveAllocationConfigTool = {
+    name: 'save_allocation_config',
+    title: 'Save Allocation Configuration',
+    description: 'Create or update an allocation header, or replace its line collection with at least one complete target configuration. Saving does not execute allocation. An empty array cannot clear or delete configuration.',
+    risk: 'R1',
+    exposurePack: 'configuration',
+    capabilityIds: [
+        'suite.config.allocation_config.create',
+        'suite.config.allocation_config.update',
+        'suite.config.allocation_config.lines',
+    ],
+    fileAccess: 'none',
+    publicInputSchema: createPublicInputSchema(allocationConfigSaveInputSchema),
+    inputSchema: allocationConfigSaveInputSchema,
+    outputSchema: operationResultSchemas.save_allocation_config,
+    annotations: writeAnnotations,
+    async execute(rawInput, context) {
+        const input = allocationConfigSaveInputSchema.parse(rawInput);
+        const capability = input.object_type === 'config_lines'
+            ? 'suite.config.allocation_config.lines'
+            : input.operation === 'create'
+                ? 'suite.config.allocation_config.create'
+                : 'suite.config.allocation_config.update';
+        const recovery = 'object_id' in input
+            ? {
+                tool: 'query_allocation',
+                input: {
+                    context: { org_id: input.context.org_id },
+                    view: 'config_detail',
+                    config_id: input.object_id,
+                },
+            }
+            : {
+                tool: 'query_allocation',
+                input: {
+                    context: { org_id: input.context.org_id },
+                    view: 'config_list',
+                    ledger_id: input.values.ledger_id,
+                    coa_code: input.values.coa_code,
+                    page: 1,
+                    page_size: 20,
+                },
+            };
+        return saveConfig({
+            toolName: 'save_allocation_config',
+            objectType: input.object_type,
+            ...('object_id' in input ? { objectId: input.object_id } : {}),
+            idempotencyKey: input.idempotency_key,
+            orgId: input.context.org_id,
+            capabilityId: capability,
+            capabilityInput: input.object_type === 'config_lines'
+                ? {
+                    object_id: input.object_id,
+                    version: input.version,
+                    lines: input.lines,
+                }
+                : {
+                    ...('object_id' in input ? { object_id: input.object_id } : {}),
+                    ...('version' in input ? { version: input.version } : {}),
+                    values: input.values,
+                },
+            fingerprint: input,
+            context,
+            outputSchema: operationResultSchemas.save_allocation_config,
+            projectResult: allocationConfigResult,
+            ...(input.object_type === 'config_lines'
+                ? { targetIdField: 'cfg_head_id' }
+                : {}),
+            recovery,
+        });
+    },
+    summarize: resultSummary,
+};
+export const previewAllocationTool = {
+    name: 'preview_allocation',
+    title: 'Preview Journal Allocation',
+    description: 'Run the native allocation preview for a specified journal_id and create a single-use execution plan without creating allocation results. Call execute_allocation only after confirming the matched configuration, target lines, and amounts.',
+    risk: 'R0',
+    exposurePack: 'configuration',
+    capabilityIds: ['suite.aloc.generate.preview'],
+    fileAccess: 'none',
+    inputSchema: previewAllocationInputSchema,
+    outputSchema: previewAllocationOutputSchema,
+    annotations: readAnnotations,
+    async execute(rawInput, context) {
+        const input = previewAllocationInputSchema.parse(rawInput);
+        const preview = await context.callCapability('suite.aloc.generate.preview', { journal_id: input.journal_id }, input.context.org_id);
+        const snapshot = allocationPreviewSnapshot(preview);
+        return issueOperationPlan({
+            context,
+            executeTool: 'execute_allocation',
+            targetType: 'allocation',
+            targetIds: [input.journal_id],
+            targetVersions: [],
+            orgId: input.context.org_id,
+            parameters: input,
+            preview: snapshot,
+            operation: 'aloc.generate.preview',
+            publicPreview: snapshot,
+            outputSchema: previewAllocationOutputSchema,
+            privatePayload: { journal_id: input.journal_id },
+        });
+    },
+    summarize: allocationPlanSummary,
+};
+export const executeAllocationTool = {
+    name: 'execute_allocation',
+    title: 'Execute Journal Allocation',
+    description: 'Consume a user-confirmed plan issued by preview_allocation and generate the final allocation result for its bound journal_id. This Tool does not roll back results and must not be retried blindly.',
+    risk: 'R3',
+    exposurePack: 'configuration',
+    capabilityIds: ['suite.aloc.generate.preview', 'suite.aloc.generate.execute'],
+    fileAccess: 'none',
+    inputSchema: executePlannedInputSchema,
+    outputSchema: operationResultSchemas.execute_allocation,
+    annotations: writeAnnotations,
+    async execute(rawInput, context) {
+        const input = executePlannedInputSchema.parse(rawInput);
+        const binding = context.operationPlans.inspect(input.operation_plan_id, input.confirmation_token, 'execute_allocation');
+        return context.withResourceLock(`allocation:${binding.subject_id}`, () => executePlannedOperation({
+            toolName: 'execute_allocation',
+            operationPlanId: input.operation_plan_id,
+            confirmationToken: input.confirmation_token,
+            idempotencyKey: input.idempotency_key,
+            orgId: input.context.org_id,
+            capabilityId: 'suite.aloc.generate.execute',
+            context,
+            sourceOperation: 'aloc.generate.execute',
+            targetType: 'allocation',
+            outputSchema: operationResultSchemas.execute_allocation,
+            projectResult: allocationResult,
+            validatePlan: async (plan) => {
+                const preview = await context.callCapability('suite.aloc.generate.preview', { journal_id: plan.payload?.journal_id }, input.context.org_id);
+                if (hashOperationValue(allocationPreviewSnapshot(preview)) !==
+                    plan.preview_hash) {
+                    throw new FinTaxError('CONFIRMATION_REQUIRED', 'The allocation preview changed; run the preview again');
+                }
+            },
+            buildCapabilityInput: (plan) => plan.payload ?? {},
+        }));
+    },
+    summarize: resultSummary,
+};
+export const savePnlConfigTool = {
+    name: 'save_pnl_config',
+    title: 'Save Profit-and-Loss Configuration',
+    description: 'Create or update a profit-and-loss bucket, or add a member to an explicit bucket_id. Saving does not start a profit-and-loss calculation. This Tool provides no path to delete buckets or remove members.',
+    risk: 'R1',
+    exposurePack: 'configuration',
+    capabilityIds: [
+        'suite.config.pnl_bucket.create',
+        'suite.config.pnl_bucket.update',
+        'suite.config.pnl_bucket.member_add',
+    ],
+    fileAccess: 'none',
+    publicInputSchema: createPublicInputSchema(pnlConfigSaveInputSchema),
+    inputSchema: pnlConfigSaveInputSchema,
+    outputSchema: operationResultSchemas.save_pnl_config,
+    annotations: writeAnnotations,
+    async execute(rawInput, context) {
+        const input = pnlConfigSaveInputSchema.parse(rawInput);
+        const capability = input.object_type === 'member'
+            ? 'suite.config.pnl_bucket.member_add'
+            : input.operation === 'create'
+                ? 'suite.config.pnl_bucket.create'
+                : 'suite.config.pnl_bucket.update';
+        const objectId = input.object_type === 'member'
+            ? input.bucket_id
+            : 'object_id' in input
+                ? input.object_id
+                : undefined;
+        return saveConfig({
+            toolName: 'save_pnl_config',
+            objectType: input.object_type,
+            ...(objectId === undefined ? {} : { objectId }),
+            idempotencyKey: input.idempotency_key,
+            orgId: input.context.org_id,
+            capabilityId: capability,
+            capabilityInput: {
+                ...(input.object_type === 'member'
+                    ? { bucket_id: input.bucket_id }
+                    : {}),
+                ...('object_id' in input ? { object_id: input.object_id } : {}),
+                ...('version' in input ? { version: input.version } : {}),
+                values: input.values,
+            },
+            fingerprint: input,
+            context,
+            outputSchema: operationResultSchemas.save_pnl_config,
+            projectResult: pnlConfigResult,
+            ...(input.object_type === 'member'
+                ? {}
+                : {
+                    recovery: {
+                        tool: 'query_pnl',
+                        input: {
+                            context: { org_id: input.context.org_id },
+                            view: 'buckets',
+                            filters: { search: input.values.bucket_code },
+                            page: 1,
+                            page_size: 20,
+                        },
+                    },
+                }),
+        });
+    },
+    summarize: resultSummary,
+};
+export const runPnlCalculationTool = {
+    name: 'run_pnl_calculation',
+    title: 'Run Profit-and-Loss Calculation',
+    description: 'Start an asynchronous calculation for an explicit profit-and-loss bucket, mode, and date range and write profit-and-loss results. A successful call returns job_id. Poll with get_job_status and do not resubmit the same idempotency key.',
+    risk: 'R2',
+    exposurePack: 'configuration',
+    capabilityIds: ['suite.pnl.calculation.run'],
+    fileAccess: 'none',
+    inputSchema: runPnlCalculationInputSchema,
+    outputSchema: operationResultSchemas.run_pnl_calculation,
+    annotations: writeAnnotations,
+    async execute(rawInput, context) {
+        const input = runPnlCalculationInputSchema.parse(rawInput);
+        return context.withResourceLock(`pnl-bucket:${input.bucket_id}`, () => executeIdempotentWrite({
+            toolName: 'run_pnl_calculation',
+            idempotencyKey: input.idempotency_key,
+            orgId: input.context.org_id,
+            fingerprintValue: input,
+            capabilityId: 'suite.pnl.calculation.run',
+            capabilityInput: {
+                body: {
+                    mode: input.mode,
+                    bucket_id: input.bucket_id,
+                    symbol: input.symbol,
+                    from_date: input.from_date,
+                    to_date: input.to_date,
+                },
+            },
+            context,
+            outputSchema: operationResultSchemas.run_pnl_calculation,
+            recovery: {
+                tool: 'query_pnl',
+                input: { view: 'calculations', page: 1, page_size: 20 },
+            },
+            target: { field: 'bucket_id', id: input.bucket_id },
+            buildOutput: (raw) => {
+                const runId = asRecord(raw).id;
+                if (typeof runId !== 'string') {
+                    throw new FinTaxError('UPSTREAM_UNAVAILABLE', 'FinTax did not return a valid profit-and-loss calculation job ID, so its status cannot be queried');
+                }
+                return operationResult({
+                    operation: 'run_pnl_calculation',
+                    targetType: 'pnl_calculation',
+                    targetIds: [runId],
+                    result: pnlCalculationResult(raw),
+                    outputSchema: operationResultSchemas.run_pnl_calculation,
+                    context,
+                    sourceOperation: 'pnl.calculation.run',
+                    jobId: createPnlCalculationJobId(runId),
+                });
+            },
+        }));
+    },
+    summarize: resultSummary,
+};
+const generatorCapabilities = {
+    parameter: {
+        create: 'suite.config.generator_parameter.create',
+        update: 'suite.config.generator_parameter.update',
+    },
+    rule: {
+        create: 'suite.config.generator_rule.create',
+        update: 'suite.config.generator_rule.update',
+    },
+};
+export const saveGeneratorConfigTool = {
+    name: 'save_generator_config',
+    title: 'Save Generator Configuration',
+    description: 'Create or update generation parameters and generation-rule configuration without executing rules or maintaining schedules, callbacks, or arbitrary code entry points. Rule types remain restricted by the registered generator_type allowlist.',
+    risk: 'R2',
+    exposurePack: 'configuration',
+    capabilityIds: Object.values(generatorCapabilities).flatMap((value) => Object.values(value)),
+    fileAccess: 'none',
+    publicInputSchema: createPublicInputSchema(generatorConfigSaveInputSchema),
+    inputSchema: generatorConfigSaveInputSchema,
+    outputSchema: operationResultSchemas.save_generator_config,
+    annotations: writeAnnotations,
+    async execute(rawInput, context) {
+        const input = generatorConfigSaveInputSchema.parse(rawInput);
+        const capability = generatorCapabilities[input.object_type][input.operation];
+        return saveConfig({
+            toolName: 'save_generator_config',
+            objectType: input.object_type,
+            ...('object_id' in input ? { objectId: input.object_id } : {}),
+            idempotencyKey: input.idempotency_key,
+            orgId: input.context.org_id,
+            capabilityId: capability,
+            capabilityInput: {
+                ...('object_id' in input ? { object_id: input.object_id } : {}),
+                ...('version' in input ? { version: input.version } : {}),
+                values: input.values,
+            },
+            fingerprint: input,
+            context,
+            outputSchema: operationResultSchemas.save_generator_config,
+            projectResult: configurationIdentityResult,
+        });
+    },
+    summarize: resultSummary,
+};
+export const runGeneratorTool = {
+    name: 'run_generator',
+    title: 'Run Generator Rule',
+    description: 'Immediately run an explicitly selected saved generator rule with an optional business date. This Tool does not accept code, formulas, or dynamic rule definitions; configuration must first be saved through save_generator_config and validated by the service.',
+    risk: 'R2',
+    exposurePack: 'configuration',
+    capabilityIds: ['suite.pgen.rule.run'],
+    fileAccess: 'none',
+    inputSchema: runGeneratorOperationInputSchema,
+    outputSchema: operationResultSchemas.run_generator,
+    annotations: writeAnnotations,
+    async execute(rawInput, context) {
+        const input = runGeneratorOperationInputSchema.parse(rawInput);
+        return context.withResourceLock(`generator-rule:${input.rule_id}`, () => executeIdempotentWrite({
+            toolName: 'run_generator',
+            idempotencyKey: input.idempotency_key,
+            orgId: input.context.org_id,
+            fingerprintValue: input,
+            capabilityId: 'suite.pgen.rule.run',
+            capabilityInput: {
+                rule_id: input.rule_id,
+                business_date: input.business_date,
+            },
+            context,
+            outputSchema: operationResultSchemas.run_generator,
+            target: { field: 'rule_id', id: input.rule_id },
+            buildOutput: (raw) => operationResult({
+                operation: 'run_generator',
+                targetType: 'generator_rule',
+                targetIds: [input.rule_id],
+                result: generatorRunResult(raw),
+                outputSchema: operationResultSchemas.run_generator,
+                context,
+                sourceOperation: 'pgen.rule.run',
+            }),
+        }));
+    },
+    summarize: resultSummary,
+};
+export const configurationTools = [
+    queryMappingConfigTool,
+    saveMappingConfigTool,
+    queryAccountingRulesTool,
+    saveAccountingRuleTool,
+    queryAllocationTool,
+    saveAllocationConfigTool,
+    previewAllocationTool,
+    executeAllocationTool,
+    savePnlConfigTool,
+    runPnlCalculationTool,
+    saveGeneratorConfigTool,
+    runGeneratorTool,
+];
+//# sourceMappingURL=configuration-tools.js.map