@taxdao/fintax-mcp 0.2.0

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

@@ -0,0 +1,678 @@
+import { executeBusinessDocumentOffsetInputSchema, executeBusinessDocumentPostInputSchema, operationPlanOutputSchema, prepareBusinessDocumentPostInputSchema, prepareJournalSubmissionInputSchema, previewBusinessDocumentOffsetInputSchema, previewBusinessDocumentOffsetOutputSchema, queryBusinessDocumentOffsetCandidatesInputSchema, queryBusinessDocumentOffsetCandidatesOutputSchema, submitBusinessDocumentInputSchema, submitJournalsInputSchema, } from '../../schemas/domains/extended-operations.js';
+import { operationResultSchemas } from '../../schemas/domains/extended-operation-results.js';
+import { createPublicInputSchema } from '../../schemas/public-input.js';
+import { FinTaxError } from '../../errors/fintax-error.js';
+import { hashOperationValue } from '../../policies/operation-plan.js';
+import { journalDocumentsUpstreamSchema } from '../../schemas/domains/journals.js';
+import { executeIdempotentWrite } from '../core-edit/idempotent-write.js';
+import { executePlannedOperation, issueOperationPlan, operationResult, planSummary, requiredUpstreamArray, resultSummary, } from './tool-support.js';
+const workflowAnnotations = {
+    readOnlyHint: false,
+    destructiveHint: false,
+    idempotentHint: false,
+    openWorldHint: false,
+};
+const prepareAnnotations = {
+    ...workflowAnnotations,
+    readOnlyHint: true,
+    idempotentHint: true,
+};
+function documentCapabilities(type) {
+    const prefix = type === 'payable' ? 'suite.ap.payable' : 'suite.ar.receivable';
+    return {
+        detail: `${prefix}.detail`,
+        submit: `${prefix}.verify_submit`,
+        post: `${prefix}.post`,
+        candidates: `${prefix}.offset_candidates`,
+        internalCandidates: `${prefix}.internal_offset_candidates`,
+        offset: `${prefix}.offset_apply`,
+    };
+}
+function sourceOperation(capabilityId) {
+    return capabilityId.replace(/^suite\./, '');
+}
+function recordValue(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function submissionResult(value) {
+    const raw = recordValue(value);
+    if (typeof raw.submitted === 'number') {
+        const failed = requiredUpstreamArray(raw.failed);
+        return {
+            submitted: raw.submitted,
+            failed: failed.map((item) => {
+                const record = recordValue(item);
+                return {
+                    journal_id: record.journal_id,
+                    journal_number: record.journal_number ?? null,
+                };
+            }),
+        };
+    }
+    const verifyResult = raw.verify_result === null || raw.verify_result === undefined
+        ? null
+        : recordValue(raw.verify_result);
+    const submitResult = raw.submit_result === null || raw.submit_result === undefined
+        ? null
+        : recordValue(raw.submit_result);
+    return {
+        verified: raw.verified,
+        submitted: raw.submitted,
+        verify_result: verifyResult === null
+            ? null
+            : {
+                ...(typeof verifyResult.journal_id === 'string'
+                    ? { journal_id: verifyResult.journal_id }
+                    : {}),
+                verification_status: verifyResult.verification_status,
+            },
+        submit_result: submitResult === null
+            ? null
+            : {
+                approval_status: submitResult.approval_status,
+                current_node_name: submitResult.current_node_name ?? null,
+            },
+    };
+}
+function documentPostResult(value) {
+    const raw = recordValue(value);
+    const items = requiredUpstreamArray(raw.items);
+    return {
+        requested: raw.requested,
+        posted: raw.posted,
+        journals: raw.journals,
+        items: items.map((item) => {
+            const record = recordValue(item);
+            return { status: record.status, journals: record.journals };
+        }),
+        attachments_copied: raw.attachments_copied,
+        attachments_skipped: raw.attachments_skipped,
+        attachments_failed: raw.attachments_failed,
+    };
+}
+function documentOffsetResult(value) {
+    const raw = recordValue(value);
+    const offsetLines = requiredUpstreamArray(raw.offset_lines);
+    const diffLines = requiredUpstreamArray(raw.diff_lines);
+    const remaining = requiredUpstreamArray(raw.invoice_remaining);
+    return {
+        offset_lines: offsetLines.map((item) => {
+            const record = recordValue(item);
+            return {
+                offset_line_id: record.offset_line_id,
+                source_type: record.source_type,
+                source_id: record.source_id,
+                quantity: record.quantity,
+                symbol: record.symbol,
+                base_amount: record.base_amount ?? null,
+            };
+        }),
+        diff_lines: diffLines.map((item) => ({
+            offset_line_id: recordValue(item).offset_line_id,
+        })),
+        invoice_remaining: remaining.map((item) => {
+            const record = recordValue(item);
+            return { symbol: record.symbol, remaining: record.remaining };
+        }),
+        offset_date: raw.offset_date,
+        gl_date: raw.gl_date,
+    };
+}
+function journalSubmissionSnapshot(value) {
+    const parsed = journalDocumentsUpstreamSchema.parse(value);
+    return {
+        recommended_rule_h_id: parsed.recommended_rule_h_id,
+        matched_rules: parsed.matched_rules.map((rule) => ({
+            rule_h_id: rule.rule_h_id,
+            rule_code: rule.rule_code,
+            rule_name: rule.rule_name,
+            is_balanced: rule.is_balanced,
+            unavailable_reason: rule.unavailable_reason,
+            journals: rule.journals.map((journal) => ({
+                id: journal.id,
+                journal_number: journal.journal_number,
+                period_name: journal.period_name,
+                entry_source: journal.entry_source,
+                source_type: journal.source_type,
+                journal_type: journal.journal_type,
+                biz_date: journal.biz_date,
+                gl_date: journal.gl_date,
+                description: journal.description,
+                org_id: journal.org_id,
+                ledger_id: journal.ledger_id,
+                version: journal.version,
+                approval_status: journal.approval_status,
+                verification_status: journal.verification_status,
+                lines: journal.lines.map((line) => ({
+                    id: line.id,
+                    coa_code: line.coa_code,
+                    coa_name: line.coa_name,
+                    description: line.description,
+                    base_currency: line.base_currency,
+                    base_debit: line.base_debit,
+                    base_credit: line.base_credit,
+                    origin_currency: line.origin_currency,
+                    origin_debit: line.origin_debit,
+                    origin_credit: line.origin_credit,
+                    attributes: line.attributes.map((attribute) => ({
+                        slot: attribute.slot,
+                        code: attribute.code,
+                        value: attribute.value,
+                    })),
+                    source_id: line.source_id,
+                    source_type: line.source_type,
+                    rate_amount: line.rate_amount,
+                    rate_time: line.rate_time,
+                })),
+            })),
+        })),
+    };
+}
+function journalSnapshots(value) {
+    return value.matched_rules.flatMap((matchedRule) => matchedRule.journals);
+}
+function assertCurrentVersion(value, objectId, version, objectName) {
+    const record = recordValue(value);
+    if (record.id !== objectId || record.version !== version) {
+        throw new FinTaxError('CONFLICT', `${objectName} state or version changed; query it again before preparing the operation`);
+    }
+}
+function offsetCandidate(value) {
+    const candidate = recordValue(value);
+    return {
+        source_type: candidate.source_type,
+        source_id: candidate.source_id,
+        symbol: candidate.symbol,
+        quantity: candidate.quantity,
+        base_amount: candidate.base_amount ?? null,
+        base_currency: candidate.base_currency ?? null,
+        base_rate: candidate.base_rate ?? null,
+        biz_date: candidate.biz_date ?? null,
+        source_ref: candidate.source_ref ?? null,
+        main_account_name: candidate.main_account_name ?? null,
+        sub_account_code: candidate.sub_account_code ?? null,
+    };
+}
+function offsetCandidatesSnapshot(value) {
+    const record = recordValue(value);
+    return {
+        invoice_symbols: requiredUpstreamArray(record.invoice_symbols),
+        groups: requiredUpstreamArray(record.groups).map((group) => {
+            const item = recordValue(group);
+            return {
+                symbol: item.symbol,
+                candidates: requiredUpstreamArray(item.candidates).map(offsetCandidate),
+            };
+        }),
+    };
+}
+function candidateRecords(value) {
+    return new Map(value.groups.flatMap((group) => group.candidates.flatMap((candidate) => typeof candidate.source_type === 'string' &&
+        typeof candidate.source_id === 'string'
+        ? [
+            [
+                `${candidate.source_type}:${candidate.source_id}`,
+                candidate,
+            ],
+        ]
+        : [])));
+}
+function offsetCandidatesSummary(output) {
+    const parsed = queryBusinessDocumentOffsetCandidatesOutputSchema.parse(output);
+    const count = parsed.data.groups.reduce((total, group) => total + group.candidates.length, 0);
+    return `Returned ${count} available offset candidates.`;
+}
+function offsetPlanSummary(output) {
+    const parsed = previewBusinessDocumentOffsetOutputSchema.parse(output);
+    return `The offset preview selected ${parsed.data.preview.selected_candidates.length} transactions with offset date ${parsed.data.preview.offset_date} and general-ledger date ${parsed.data.preview.gl_date}; user confirmation is required before execution.`;
+}
+export const prepareJournalSubmissionTool = {
+    name: 'prepare_journal_submission',
+    title: 'Prepare Batch Journal Submission',
+    description: 'Read the current state and version of two or more journals and create a single-use batch-submission plan without submitting them. Use this Tool only for batch submission; submit one journal directly with submit_journals in single mode.',
+    risk: 'R0',
+    exposurePack: 'workflow',
+    capabilityIds: ['suite.acct.journal.detail'],
+    fileAccess: 'none',
+    inputSchema: prepareJournalSubmissionInputSchema,
+    outputSchema: operationPlanOutputSchema,
+    annotations: prepareAnnotations,
+    async execute(rawInput, context) {
+        const input = prepareJournalSubmissionInputSchema.parse(rawInput);
+        const details = await Promise.all(input.journals.map((journal) => context.callCapability('suite.acct.journal.detail', { journal_id: journal.journal_id }, input.context.org_id)));
+        const snapshots = details.map(journalSubmissionSnapshot);
+        input.journals.forEach((journal, index) => {
+            const snapshot = journalSnapshots(snapshots[index]).find((item) => item.id === journal.journal_id);
+            assertCurrentVersion(snapshot, journal.journal_id, journal.version, 'Journal');
+        });
+        return issueOperationPlan({
+            context,
+            executeTool: 'submit_journals',
+            targetType: 'journal',
+            targetIds: input.journals.map((journal) => journal.journal_id),
+            targetVersions: input.journals.map((journal) => journal.version),
+            orgId: input.context.org_id,
+            parameters: input,
+            preview: snapshots,
+            operation: 'acct.journal.detail',
+            privatePayload: {
+                journal_ids: input.journals.map((journal) => journal.journal_id),
+            },
+        });
+    },
+    summarize: planSummary,
+};
+async function submitSingleJournal(input, context) {
+    return executeIdempotentWrite({
+        toolName: 'submit_journals',
+        idempotencyKey: input.idempotency_key,
+        orgId: input.context.org_id,
+        fingerprintValue: input,
+        capabilityId: 'suite.acct.journal.verify_submit',
+        capabilityInput: {
+            journal_id: input.journal_id,
+            version: input.version,
+        },
+        context,
+        outputSchema: operationResultSchemas.submit_journals,
+        recovery: {
+            tool: 'query_journals',
+            input: {
+                view: 'detail',
+                journal_id: input.journal_id,
+                context: { org_id: input.context.org_id },
+            },
+        },
+        target: { field: 'journal_id', id: input.journal_id },
+        buildOutput: (raw) => operationResult({
+            operation: 'submit_journals',
+            targetType: 'journal',
+            targetIds: [input.journal_id],
+            result: submissionResult(raw),
+            outputSchema: operationResultSchemas.submit_journals,
+            context,
+            sourceOperation: 'acct.journal.verifyAndSubmit',
+        }),
+    });
+}
+export const submitJournalsTool = {
+    name: 'submit_journals',
+    title: 'Submit Journals',
+    description: 'Submit one journal or a batch of journals for approval. Use single mode for one journal. For two or more journals, call prepare_journal_submission first and use batch mode only after the user confirms the plan summary. This Tool does not post, reverse, or delete journals.',
+    risk: 'R2',
+    exposurePack: 'workflow',
+    capabilityIds: [
+        'suite.acct.journal.verify_submit',
+        'suite.acct.journal.batch_submit',
+        'suite.acct.journal.detail',
+    ],
+    fileAccess: 'none',
+    publicInputSchema: createPublicInputSchema(submitJournalsInputSchema),
+    inputSchema: submitJournalsInputSchema,
+    outputSchema: operationResultSchemas.submit_journals,
+    annotations: workflowAnnotations,
+    async execute(rawInput, context) {
+        const input = submitJournalsInputSchema.parse(rawInput);
+        if (input.mode === 'single') {
+            return context.withResourceLock(`journal:${input.journal_id}`, () => submitSingleJournal(input, context));
+        }
+        return executePlannedOperation({
+            toolName: 'submit_journals',
+            operationPlanId: input.operation_plan_id,
+            confirmationToken: input.confirmation_token,
+            idempotencyKey: input.idempotency_key,
+            orgId: input.context.org_id,
+            capabilityId: 'suite.acct.journal.batch_submit',
+            context,
+            sourceOperation: 'acct.journal.submitApprovalBatch',
+            targetType: 'journal',
+            outputSchema: operationResultSchemas.submit_journals,
+            projectResult: submissionResult,
+            validatePlan: async (binding) => {
+                const details = await Promise.all(binding.subject_id
+                    .split(',')
+                    .filter(Boolean)
+                    .map((journalId) => context.callCapability('suite.acct.journal.detail', { journal_id: journalId }, input.context.org_id)));
+                const snapshots = details.map(journalSubmissionSnapshot);
+                if (hashOperationValue(snapshots) !== binding.preview_hash) {
+                    throw new FinTaxError('CONFIRMATION_REQUIRED', 'The journal state changed; run the preparation step again');
+                }
+            },
+            buildCapabilityInput: (binding) => ({
+                journal_ids: binding.payload?.journal_ids,
+            }),
+        });
+    },
+    summarize: resultSummary,
+};
+export const submitBusinessDocumentTool = {
+    name: 'submit_business_document',
+    title: 'Submit Receivable or Payable Document',
+    description: 'Validate and submit one receivable or payable document for approval. It accepts only one document and its current version; it does not perform batch submission, posting, or offsetting.',
+    risk: 'R2',
+    exposurePack: 'workflow',
+    capabilityIds: [
+        'suite.ap.payable.verify_submit',
+        'suite.ar.receivable.verify_submit',
+    ],
+    fileAccess: 'none',
+    inputSchema: submitBusinessDocumentInputSchema,
+    outputSchema: operationResultSchemas.submit_business_document,
+    annotations: workflowAnnotations,
+    async execute(rawInput, context) {
+        const input = submitBusinessDocumentInputSchema.parse(rawInput);
+        const capability = documentCapabilities(input.document_type).submit;
+        return context.withResourceLock(`${input.document_type}:${input.document_id}`, () => executeIdempotentWrite({
+            toolName: 'submit_business_document',
+            idempotencyKey: input.idempotency_key,
+            orgId: input.context.org_id,
+            fingerprintValue: input,
+            capabilityId: capability,
+            capabilityInput: {
+                document_id: input.document_id,
+                version: input.version,
+            },
+            context,
+            outputSchema: operationResultSchemas.submit_business_document,
+            recovery: {
+                tool: input.document_type === 'payable'
+                    ? 'get_payable_document'
+                    : 'get_receivable_document',
+                input: {
+                    document_id: input.document_id,
+                    context: { org_id: input.context.org_id },
+                },
+            },
+            target: { field: 'document_id', id: input.document_id },
+            buildOutput: (raw) => operationResult({
+                operation: 'submit_business_document',
+                targetType: input.document_type,
+                targetIds: [input.document_id],
+                result: submissionResult(raw),
+                outputSchema: operationResultSchemas.submit_business_document,
+                context,
+                sourceOperation: sourceOperation(capability),
+            }),
+        }));
+    },
+    summarize: resultSummary,
+};
+export const prepareBusinessDocumentPostTool = {
+    name: 'prepare_business_document_post',
+    title: 'Prepare Receivable or Payable Document Posting',
+    description: 'Read the current state and version of one receivable or payable document and create a posting plan without posting it. Call execute_business_document_post only after the plan summary has been confirmed.',
+    risk: 'R0',
+    exposurePack: 'workflow',
+    capabilityIds: ['suite.ap.payable.detail', 'suite.ar.receivable.detail'],
+    fileAccess: 'none',
+    inputSchema: prepareBusinessDocumentPostInputSchema,
+    outputSchema: operationPlanOutputSchema,
+    annotations: prepareAnnotations,
+    async execute(rawInput, context) {
+        const input = prepareBusinessDocumentPostInputSchema.parse(rawInput);
+        const capability = documentCapabilities(input.document_type).detail;
+        const detail = await context.callCapability(capability, { document_id: input.document_id }, input.context.org_id);
+        assertCurrentVersion(detail, input.document_id, input.version, input.document_type === 'payable'
+            ? 'Payable document'
+            : 'Receivable document');
+        return issueOperationPlan({
+            context,
+            executeTool: 'execute_business_document_post',
+            targetType: input.document_type,
+            targetIds: [input.document_id],
+            targetVersions: [input.version],
+            orgId: input.context.org_id,
+            parameters: input,
+            preview: detail,
+            operation: sourceOperation(capability),
+            privatePayload: {
+                document_type: input.document_type,
+                document_id: input.document_id,
+                version: input.version,
+            },
+        });
+    },
+    summarize: planSummary,
+};
+export const executeBusinessDocumentPostTool = {
+    name: 'execute_business_document_post',
+    title: 'Post Receivable or Payable Document',
+    description: 'Consume a user-confirmed plan issued by prepare_business_document_post and post one document. After a timeout, do not blindly retry with a new plan.',
+    risk: 'R3',
+    exposurePack: 'workflow',
+    capabilityIds: [
+        'suite.ap.payable.post',
+        'suite.ar.receivable.post',
+        'suite.ap.payable.detail',
+        'suite.ar.receivable.detail',
+    ],
+    fileAccess: 'none',
+    inputSchema: executeBusinessDocumentPostInputSchema,
+    outputSchema: operationResultSchemas.execute_business_document_post,
+    annotations: workflowAnnotations,
+    async execute(rawInput, context) {
+        const input = executeBusinessDocumentPostInputSchema.parse(rawInput);
+        const binding = context.operationPlans.inspect(input.operation_plan_id, input.confirmation_token, 'execute_business_document_post');
+        const type = binding.payload?.document_type;
+        const capability = documentCapabilities(type).post;
+        return executePlannedOperation({
+            toolName: 'execute_business_document_post',
+            operationPlanId: input.operation_plan_id,
+            confirmationToken: input.confirmation_token,
+            idempotencyKey: input.idempotency_key,
+            orgId: input.context.org_id,
+            capabilityId: capability,
+            context,
+            sourceOperation: sourceOperation(capability),
+            targetType: type,
+            outputSchema: operationResultSchemas.execute_business_document_post,
+            projectResult: documentPostResult,
+            recovery: {
+                tool: type === 'payable'
+                    ? 'get_payable_document'
+                    : 'get_receivable_document',
+                input: {
+                    document_id: binding.subject_id,
+                    context: { org_id: input.context.org_id },
+                },
+            },
+            validatePlan: async (plan) => {
+                const detail = await context.callCapability(documentCapabilities(type).detail, { document_id: plan.payload?.document_id }, input.context.org_id);
+                if (hashOperationValue(detail) !== plan.preview_hash) {
+                    throw new FinTaxError('CONFIRMATION_REQUIRED', 'The document state changed; run the preparation step again');
+                }
+            },
+            buildCapabilityInput: (plan) => ({
+                document_id: plan.payload?.document_id,
+            }),
+        });
+    },
+    summarize: resultSummary,
+};
+export const queryBusinessDocumentOffsetCandidatesTool = {
+    name: 'query_business_document_offset_candidates',
+    title: 'Query Receivable or Payable Offset Candidates',
+    description: 'Query the external or internal transactions currently available to offset a specified receivable or payable document. Returns transaction IDs, currencies, amounts, business dates, and account summaries without creating an operation plan.',
+    risk: 'R0',
+    exposurePack: 'workflow',
+    capabilityIds: [
+        'suite.ap.payable.offset_candidates',
+        'suite.ap.payable.internal_offset_candidates',
+        'suite.ar.receivable.offset_candidates',
+        'suite.ar.receivable.internal_offset_candidates',
+    ],
+    fileAccess: 'none',
+    inputSchema: queryBusinessDocumentOffsetCandidatesInputSchema,
+    outputSchema: queryBusinessDocumentOffsetCandidatesOutputSchema,
+    annotations: prepareAnnotations,
+    async execute(rawInput, context) {
+        const input = queryBusinessDocumentOffsetCandidatesInputSchema.parse(rawInput);
+        const capabilities = documentCapabilities(input.document_type);
+        const capability = input.candidate_scope === 'internal'
+            ? capabilities.internalCandidates
+            : capabilities.candidates;
+        const candidates = offsetCandidatesSnapshot(await context.callCapability(capability, { document_id: input.document_id }, input.context.org_id));
+        return queryBusinessDocumentOffsetCandidatesOutputSchema.parse({
+            ok: true,
+            data: {
+                document_type: input.document_type,
+                document_id: input.document_id,
+                candidate_scope: input.candidate_scope,
+                ...candidates,
+            },
+            warnings: [],
+            trace_id: context.traceId,
+            source_refs: [
+                { service: 'suite', operation: sourceOperation(capability) },
+            ],
+        });
+    },
+    summarize: offsetCandidatesSummary,
+};
+export const previewBusinessDocumentOffsetTool = {
+    name: 'preview_business_document_offset',
+    title: 'Preview Receivable or Payable Offset',
+    description: 'Reload the current offset candidates and bind the transactions explicitly selected through query_business_document_offset_candidates into a single-use offset plan without writing an offset result. Call execute_business_document_offset only after confirming the candidates and dates.',
+    risk: 'R0',
+    exposurePack: 'workflow',
+    capabilityIds: [
+        'suite.ap.payable.offset_candidates',
+        'suite.ap.payable.internal_offset_candidates',
+        'suite.ar.receivable.offset_candidates',
+        'suite.ar.receivable.internal_offset_candidates',
+    ],
+    fileAccess: 'none',
+    inputSchema: previewBusinessDocumentOffsetInputSchema,
+    outputSchema: previewBusinessDocumentOffsetOutputSchema,
+    annotations: prepareAnnotations,
+    async execute(rawInput, context) {
+        const input = previewBusinessDocumentOffsetInputSchema.parse(rawInput);
+        const capabilities = documentCapabilities(input.document_type);
+        const capability = input.candidate_scope === 'internal'
+            ? capabilities.internalCandidates
+            : capabilities.candidates;
+        const candidates = await context.callCapability(capability, { document_id: input.document_id }, input.context.org_id);
+        const candidateSnapshot = offsetCandidatesSnapshot(candidates);
+        const available = candidateRecords(candidateSnapshot);
+        const selectedCandidates = input.allocations.map((allocation) => {
+            const candidate = available.get(`${allocation.source_type}:${allocation.transaction_id}`);
+            if (candidate === undefined) {
+                throw new FinTaxError('CONFLICT', 'The selected offset transaction is no longer in the current candidate list; select it again');
+            }
+            return candidate;
+        });
+        return issueOperationPlan({
+            context,
+            executeTool: 'execute_business_document_offset',
+            targetType: `${input.document_type}_offset`,
+            targetIds: [input.document_id],
+            targetVersions: [],
+            orgId: input.context.org_id,
+            parameters: input,
+            preview: candidateSnapshot,
+            operation: sourceOperation(capability),
+            publicPreview: {
+                document_type: input.document_type,
+                document_id: input.document_id,
+                candidate_scope: input.candidate_scope,
+                selected_candidates: selectedCandidates,
+                offset_date: input.offset_date,
+                gl_date: input.gl_date,
+                period: input.period ?? null,
+            },
+            outputSchema: previewBusinessDocumentOffsetOutputSchema,
+            privatePayload: {
+                document_type: input.document_type,
+                document_id: input.document_id,
+                candidate_scope: input.candidate_scope,
+                body: {
+                    txnRefs: input.allocations.map((allocation) => ({
+                        sourceType: allocation.source_type,
+                        sourceId: allocation.transaction_id,
+                    })),
+                    offsetDate: input.offset_date,
+                    glDate: input.gl_date,
+                    mode: 'APPEND',
+                    periodName: input.period,
+                },
+            },
+        });
+    },
+    summarize: offsetPlanSummary,
+};
+export const executeBusinessDocumentOffsetTool = {
+    name: 'execute_business_document_offset',
+    title: 'Execute Receivable or Payable Offset',
+    description: 'Consume a user-confirmed plan issued by preview_business_document_offset and apply the offset. It does not clear existing offsets and never uses a REPLACE deletion path.',
+    risk: 'R2',
+    exposurePack: 'workflow',
+    capabilityIds: [
+        'suite.ap.payable.offset_apply',
+        'suite.ar.receivable.offset_apply',
+        'suite.ap.payable.offset_candidates',
+        'suite.ap.payable.internal_offset_candidates',
+        'suite.ar.receivable.offset_candidates',
+        'suite.ar.receivable.internal_offset_candidates',
+    ],
+    fileAccess: 'none',
+    inputSchema: executeBusinessDocumentOffsetInputSchema,
+    outputSchema: operationResultSchemas.execute_business_document_offset,
+    annotations: workflowAnnotations,
+    async execute(rawInput, context) {
+        const input = executeBusinessDocumentOffsetInputSchema.parse(rawInput);
+        const binding = context.operationPlans.inspect(input.operation_plan_id, input.confirmation_token, 'execute_business_document_offset');
+        const type = binding.payload?.document_type;
+        const capability = documentCapabilities(type).offset;
+        return executePlannedOperation({
+            toolName: 'execute_business_document_offset',
+            operationPlanId: input.operation_plan_id,
+            confirmationToken: input.confirmation_token,
+            idempotencyKey: input.idempotency_key,
+            orgId: input.context.org_id,
+            capabilityId: capability,
+            context,
+            sourceOperation: sourceOperation(capability),
+            targetType: `${type}_offset`,
+            outputSchema: operationResultSchemas.execute_business_document_offset,
+            projectResult: documentOffsetResult,
+            recovery: {
+                tool: type === 'payable'
+                    ? 'get_payable_document'
+                    : 'get_receivable_document',
+                input: {
+                    document_id: binding.subject_id,
+                    context: { org_id: input.context.org_id },
+                },
+            },
+            validatePlan: async (plan) => {
+                const capabilities = documentCapabilities(type);
+                const candidateCapability = plan.payload?.candidate_scope === 'internal'
+                    ? capabilities.internalCandidates
+                    : capabilities.candidates;
+                const candidates = await context.callCapability(candidateCapability, { document_id: plan.payload?.document_id }, input.context.org_id);
+                if (hashOperationValue(offsetCandidatesSnapshot(candidates)) !==
+                    plan.preview_hash) {
+                    throw new FinTaxError('CONFIRMATION_REQUIRED', 'The offset candidates changed; run the preview again');
+                }
+            },
+            buildCapabilityInput: (plan) => ({
+                document_id: plan.payload?.document_id,
+                body: plan.payload?.body,
+            }),
+        });
+    },
+    summarize: resultSummary,
+};
+export const workflowTools = [
+    prepareJournalSubmissionTool,
+    submitJournalsTool,
+    submitBusinessDocumentTool,
+    prepareBusinessDocumentPostTool,
+    executeBusinessDocumentPostTool,
+    queryBusinessDocumentOffsetCandidatesTool,
+    previewBusinessDocumentOffsetTool,
+    executeBusinessDocumentOffsetTool,
+];
+//# sourceMappingURL=workflow-tools.js.map