@kirjapro/mcp-server 0.8.2 → 0.8.5

package/dist/tools/templates.js

@@ -1,636 +0,0 @@
-import { z } from "zod";
-import { ACCOUNTS } from "../accounts.js";
-import { getSupabase, getCompanyId } from "../auth.js";
-import { toResult, toErrorContent, sanitizeDbError, roundCents, resolveOpenFiscalYear, withIdempotency, IDEMPOTENCY_KEY_SCHEMA, ISO_DATE_SCHEMA, READ_ONLY_ANNOTATIONS, WRITE_ANNOTATIONS, } from "../utils.js";
-// ---- Pure functions (exported for testing) ----
-/**
- * Split a gross EUR amount into net + VAT using residual method.
- * vat = gross - net ensures no rounding drift.
- */
-export function splitVat(gross, vatRate) {
-    if (vatRate === 0)
-        return { net: roundCents(gross), vat: 0 };
-    const net = roundCents(gross / (1 + vatRate / 100));
-    const vat = roundCents(gross - net);
-    return { net, vat };
-}
-/**
- * Apply account overrides to entries (e.g. swap "2320" → "2330").
- */
-function applyOverrides(entries, overrides) {
-    if (!overrides)
-        return entries;
-    return entries.map((e) => ({
-        ...e,
-        accountNumber: overrides[e.accountNumber] ?? e.accountNumber,
-    }));
-}
-/**
- * Validate that each accountOverrides pair (source → target) satisfies:
- *   1. source exists in this company's chart,
- *   2. target exists and is active, and
- *   3. source.account_type === target.account_type.
- *
- * Prevents a caller from redirecting e.g. salary expense (`ELAKEKULUT`,
- * expense) into an owner-withdrawal account (equity) or VAT receivable
- * (asset) into a revenue account.
- */
-export async function validateAccountOverrides(overrides) {
-    const entries = Object.entries(overrides);
-    if (entries.length === 0)
-        return { ok: true };
-    const supabase = getSupabase();
-    const companyId = getCompanyId();
-    const needed = [...new Set(entries.flatMap(([from, to]) => [from, to]))];
-    const { data: accounts, error } = await supabase
-        .from("accounts")
-        .select("account_number, account_type, is_active")
-        .eq("company_id", companyId)
-        .in("account_number", needed);
-    if (error) {
-        return { error: sanitizeDbError("Failed to validate accountOverrides", error) };
-    }
-    const byNumber = new Map((accounts || []).map((a) => [a.account_number, a]));
-    for (const [from, to] of entries) {
-        const src = byNumber.get(from);
-        const tgt = byNumber.get(to);
-        if (!src) {
-            return {
-                error: `accountOverrides: source "${from}" not found in your chart of accounts.`,
-            };
-        }
-        if (!tgt) {
-            return {
-                error: `accountOverrides: target "${to}" not found in your chart of accounts.`,
-            };
-        }
-        if (!tgt.is_active) {
-            return {
-                error: `accountOverrides: target "${to}" is inactive.`,
-            };
-        }
-        if (src.account_type !== tgt.account_type) {
-            return {
-                error: `accountOverrides: cannot map "${from}" (${src.account_type}) to ` +
-                    `"${to}" (${tgt.account_type}). Override target must match source account type.`,
-            };
-        }
-    }
-    return { ok: true };
-}
-// ---- Template definitions ----
-function saleCashTemplate(revenueAccount, vatRate) {
-    return (amount, opts) => {
-        const { net, vat } = splitVat(amount, vatRate);
-        const entries = [
-            {
-                accountNumber: ACCOUNTS.KASSA,
-                debitAmount: roundCents(amount),
-                creditAmount: 0,
-            },
-            { accountNumber: revenueAccount, debitAmount: 0, creditAmount: net },
-        ];
-        if (vat > 0) {
-            entries.push({
-                accountNumber: ACCOUNTS.ALV_VELKA,
-                debitAmount: 0,
-                creditAmount: vat,
-            });
-        }
-        return applyOverrides(entries, opts?.accountOverrides);
-    };
-}
-function saleBankTemplate(revenueAccount, vatRate) {
-    return (amount, opts) => {
-        const { net, vat } = splitVat(amount, vatRate);
-        const entries = [
-            {
-                accountNumber: ACCOUNTS.PANKKITILI,
-                debitAmount: roundCents(amount),
-                creditAmount: 0,
-            },
-            { accountNumber: revenueAccount, debitAmount: 0, creditAmount: net },
-        ];
-        if (vat > 0) {
-            entries.push({
-                accountNumber: ACCOUNTS.ALV_VELKA,
-                debitAmount: 0,
-                creditAmount: vat,
-            });
-        }
-        return applyOverrides(entries, opts?.accountOverrides);
-    };
-}
-const TEMPLATES = [
-    // Cash sales
-    {
-        id: "cash_sale_25",
-        description: "Käteismyynti ALV 25,5%",
-        vatRate: 25.5,
-        expand: saleCashTemplate(ACCOUNTS.MYYNTI_25_5, 25.5),
-    },
-    {
-        id: "cash_sale_14",
-        description: "Käteismyynti ALV 13,5%",
-        vatRate: 13.5,
-        expand: saleCashTemplate(ACCOUNTS.MYYNTI_13_5, 13.5),
-    },
-    {
-        id: "cash_sale_10",
-        description: "Käteismyynti ALV 10%",
-        vatRate: 10,
-        expand: saleCashTemplate(ACCOUNTS.MYYNTI_10, 10),
-    },
-    {
-        id: "cash_sale_0",
-        description: "Käteismyynti ALV 0%",
-        vatRate: 0,
-        expand: saleCashTemplate(ACCOUNTS.MYYNTI_0, 0),
-    },
-    // Bank sales
-    {
-        id: "bank_sale_25",
-        description: "Pankkimyynti ALV 25,5%",
-        vatRate: 25.5,
-        expand: saleBankTemplate(ACCOUNTS.MYYNTI_25_5, 25.5),
-    },
-    {
-        id: "bank_sale_14",
-        description: "Pankkimyynti ALV 13,5%",
-        vatRate: 13.5,
-        expand: saleBankTemplate(ACCOUNTS.MYYNTI_13_5, 13.5),
-    },
-    {
-        id: "bank_sale_10",
-        description: "Pankkimyynti ALV 10%",
-        vatRate: 10,
-        expand: saleBankTemplate(ACCOUNTS.MYYNTI_10, 10),
-    },
-    // Invoice sale
-    {
-        id: "invoice_sale_25",
-        description: "Laskumyynti ALV 25,5% (myyntisaamiset)",
-        vatRate: 25.5,
-        expand: (amount, opts) => {
-            const { net, vat } = splitVat(amount, 25.5);
-            return applyOverrides([
-                {
-                    accountNumber: ACCOUNTS.MYYNTISAAMISET,
-                    debitAmount: roundCents(amount),
-                    creditAmount: 0,
-                },
-                { accountNumber: ACCOUNTS.MYYNTI_25_5, debitAmount: 0, creditAmount: net },
-                { accountNumber: ACCOUNTS.ALV_VELKA, debitAmount: 0, creditAmount: vat },
-            ], opts?.accountOverrides);
-        },
-    },
-    // Purchase expenses
-    {
-        id: "purchase_expense",
-        description: "Osto ALV 25,5% (pankkitililtä)",
-        vatRate: 25.5,
-        expand: (amount, opts) => {
-            const { net, vat } = splitVat(amount, 25.5);
-            return applyOverrides([
-                { accountNumber: ACCOUNTS.OSTOT, debitAmount: net, creditAmount: 0 },
-                { accountNumber: ACCOUNTS.ALV_SAAMISET, debitAmount: vat, creditAmount: 0 },
-                {
-                    accountNumber: ACCOUNTS.PANKKITILI,
-                    debitAmount: 0,
-                    creditAmount: roundCents(amount),
-                },
-            ], opts?.accountOverrides);
-        },
-    },
-    {
-        id: "service_expense",
-        description: "Ulkopuolinen palvelu ALV 25,5%",
-        vatRate: 25.5,
-        expand: (amount, opts) => {
-            const { net, vat } = splitVat(amount, 25.5);
-            return applyOverrides([
-                { accountNumber: ACCOUNTS.OSTOT_PALVELUT, debitAmount: net, creditAmount: 0 },
-                { accountNumber: ACCOUNTS.ALV_SAAMISET, debitAmount: vat, creditAmount: 0 },
-                {
-                    accountNumber: ACCOUNTS.PANKKITILI,
-                    debitAmount: 0,
-                    creditAmount: roundCents(amount),
-                },
-            ], opts?.accountOverrides);
-        },
-    },
-    // Rent (no VAT)
-    {
-        id: "rent_payment",
-        description: "Vuokranmaksu (pankkitililtä)",
-        vatRate: null,
-        expand: (amount, opts) => applyOverrides([
-            {
-                accountNumber: ACCOUNTS.TOIMITILAVUOKRAT,
-                debitAmount: roundCents(amount),
-                creditAmount: 0,
-            },
-            {
-                accountNumber: ACCOUNTS.PANKKITILI,
-                debitAmount: 0,
-                creditAmount: roundCents(amount),
-            },
-        ], opts?.accountOverrides),
-    },
-    // Bank transfer
-    {
-        id: "bank_transfer",
-        description: "Tilisiirto kassasta pankkitilille",
-        vatRate: null,
-        expand: (amount, opts) => applyOverrides([
-            {
-                accountNumber: ACCOUNTS.PANKKITILI,
-                debitAmount: roundCents(amount),
-                creditAmount: 0,
-            },
-            {
-                accountNumber: ACCOUNTS.KASSA,
-                debitAmount: 0,
-                creditAmount: roundCents(amount),
-            },
-        ], opts?.accountOverrides),
-    },
-];
-const TEMPLATE_MAP = new Map(TEMPLATES.map((t) => [t.id, t]));
-/**
- * Expand a template into journal entries for a given gross amount.
- * Returns an error string if the template is unknown.
- */
-export function expandTemplate(templateId, amount, opts) {
-    const template = TEMPLATE_MAP.get(templateId);
-    if (!template) {
-        return {
-            error: `Unknown template "${templateId}". Use kirjapro_list_templates to see available templates.`,
-        };
-    }
-    if (amount <= 0) {
-        return { error: "Amount must be positive." };
-    }
-    const entries = template.expand(amount, opts);
-    return { entries };
-}
-// ---- Account resolution + fiscal year validation (same pattern as transactions.ts) ----
-/**
- * Validate the fiscal year (exists, open, date in range) for a given
- * transaction date. Shared by `resolveAndCreate` and the atomic booking
- * wrappers in `bookings.ts` so they get the same preflight checks before
- * entering an advisory-locked RPC.
- */
-export async function validateFiscalYearForDate(fiscalYearId, transactionDate) {
-    const supabase = getSupabase();
-    const companyId = getCompanyId();
-    const { data: fy, error: fyError } = await supabase
-        .from("fiscal_years")
-        .select("id, is_closed, start_date, end_date")
-        .eq("id", fiscalYearId)
-        .eq("company_id", companyId)
-        .single();
-    if (fyError || !fy) {
-        return toErrorContent(`Fiscal year ${fiscalYearId} not found. Use kirjapro_get_dashboard or read kirjapro://fiscal-years resource.`);
-    }
-    if (fy.is_closed) {
-        return toErrorContent(`Fiscal year is closed (${fy.start_date} to ${fy.end_date}).`);
-    }
-    if (transactionDate < fy.start_date || transactionDate > fy.end_date) {
-        return toErrorContent(`Transaction date ${transactionDate} outside fiscal year (${fy.start_date} to ${fy.end_date}).`);
-    }
-    return { start_date: fy.start_date, end_date: fy.end_date };
-}
-/**
- * Resolve a set of account numbers to `{account_number -> id}` within the
- * current company. Returns `toErrorContent` on lookup failure or missing
- * accounts.
- */
-export async function resolveAccountNumbers(accountNumbers) {
-    const supabase = getSupabase();
-    const companyId = getCompanyId();
-    const unique = [...new Set(accountNumbers)];
-    const { data: accounts, error } = await supabase
-        .from("accounts")
-        .select("id, account_number")
-        .eq("company_id", companyId)
-        .in("account_number", unique);
-    if (error) {
-        return toErrorContent(sanitizeDbError("Failed to resolve accounts", error));
-    }
-    const map = new Map((accounts || []).map((a) => [a.account_number, a.id]));
-    const missing = unique.filter((n) => !map.has(n));
-    if (missing.length > 0) {
-        return toErrorContent(`Account numbers not found: ${missing.join(", ")}. Use kirjapro_list_accounts to see available accounts.`);
-    }
-    return map;
-}
-/**
- * Build DB-shaped journal entries from `TemplateEntry[]` using an
- * account-number -> id map. Caller is responsible for balance validation.
- */
-export function toJournalEntries(entries, accountMap) {
-    return entries.map((e) => ({
-        account_id: accountMap.get(e.accountNumber),
-        debit_amount: e.debitAmount,
-        credit_amount: e.creditAmount,
-    }));
-}
-export async function resolveAndCreate(params) {
-    const supabase = getSupabase();
-    const companyId = getCompanyId();
-    let fiscalYearId = params.fiscalYearId;
-    if (!fiscalYearId) {
-        const resolved = await resolveOpenFiscalYear(supabase, companyId);
-        if ("isError" in resolved)
-            return resolved;
-        fiscalYearId = resolved.id;
-    }
-    const fyResult = await validateFiscalYearForDate(fiscalYearId, params.transactionDate);
-    if ("isError" in fyResult)
-        return fyResult;
-    const accountResult = await resolveAccountNumbers(params.entries.map((e) => e.accountNumber));
-    if ("isError" in accountResult)
-        return accountResult;
-    // Validate balance
-    const totalDebit = roundCents(params.entries.reduce((s, e) => s + e.debitAmount, 0));
-    const totalCredit = roundCents(params.entries.reduce((s, e) => s + e.creditAmount, 0));
-    if (Math.abs(totalDebit - totalCredit) >= 0.01) {
-        return toErrorContent(`Template produced unbalanced entries: debits ${totalDebit.toFixed(2)} != credits ${totalCredit.toFixed(2)}.`);
-    }
-    const journalEntries = toJournalEntries(params.entries, accountResult);
-    const { data: transactionId, error: txError } = await supabase.rpc("create_transaction_with_entries", {
-        p_company_id: companyId,
-        p_fiscal_year_id: fiscalYearId,
-        p_transaction_date: params.transactionDate,
-        p_description: params.description,
-        p_document_number: params.documentNumber || "",
-        p_entries: journalEntries,
-    });
-    if (txError || !transactionId) {
-        return toErrorContent(txError ? sanitizeDbError("Failed to create transaction", txError) : "Failed to create transaction: no ID returned.");
-    }
-    return { id: transactionId };
-}
-// Account reference removed — use kirjapro_list_accounts or kirjapro://accounts/chart resource for lookups.
-// ---- Tool registration ----
-export function registerTemplateTools(server) {
-    // ---- READ: List Templates ----
-    server.registerTool("kirjapro_list_templates", {
-        description: 'List available transaction templates. Templates handle double-entry balancing and VAT splitting automatically.',
-        inputSchema: {},
-        outputSchema: {
-            templates: z.array(z.object({
-                id: z.string(),
-                description: z.string(),
-                vatRate: z.number().nullable(),
-            })),
-        },
-        annotations: READ_ONLY_ANNOTATIONS,
-    }, async () => {
-        const list = TEMPLATES.map((t) => ({
-            id: t.id,
-            description: t.description,
-            vatRate: t.vatRate,
-        }));
-        return toResult({ templates: list });
-    });
-    // ---- WRITE: Create from Template ----
-    server.registerTool("kirjapro_create_from_template", {
-        description: 'Create a transaction from a template. Use kirjapro_list_templates for available templates. accountOverrides swaps default accounts (e.g. {"2320": "2330"}).',
-        inputSchema: {
-            template: z
-                .string()
-                .describe('Template ID (e.g. "cash_sale_25", "purchase_expense")'),
-            fiscalYearId: z
-                .string()
-                .uuid()
-                .optional()
-                .describe("Fiscal year UUID (auto-resolved if omitted)"),
-            transactionDate: ISO_DATE_SCHEMA
-                .describe("Transaction date (YYYY-MM-DD)"),
-            amount: z
-                .number()
-                .finite()
-                .positive()
-                .max(1_000_000_000)
-                .describe("Gross amount in EUR"),
-            description: z
-                .string()
-                .min(1)
-                .max(500)
-                .describe("Transaction description"),
-            documentNumber: z.string().optional().describe("Document/receipt number"),
-            accountOverrides: z
-                .record(z.string(), z.string())
-                .optional()
-                .describe('Account number swaps, e.g. {"2320": "2330"}'),
-            idempotencyKey: IDEMPOTENCY_KEY_SCHEMA,
-        },
-        annotations: WRITE_ANNOTATIONS,
-    }, async (params) => {
-        const supabase = getSupabase();
-        const companyId = getCompanyId();
-        return withIdempotency(supabase, companyId, "kirjapro_create_from_template", params.idempotencyKey, params, async () => {
-            if (params.accountOverrides) {
-                const ov = await validateAccountOverrides(params.accountOverrides);
-                if ("error" in ov)
-                    return toErrorContent(ov.error);
-            }
-            const result = expandTemplate(params.template, params.amount, {
-                accountOverrides: params.accountOverrides,
-            });
-            if ("error" in result) {
-                return toErrorContent(result.error);
-            }
-            const createResult = await resolveAndCreate({
-                fiscalYearId: params.fiscalYearId,
-                transactionDate: params.transactionDate,
-                description: params.description,
-                documentNumber: params.documentNumber,
-                entries: result.entries,
-            });
-            if ("isError" in createResult) {
-                return createResult;
-            }
-            return toResult({
-                message: "Transaction created from template",
-                template: params.template,
-                transaction_id: createResult.id,
-                entries: result.entries,
-            });
-        });
-    });
-    // ---- WRITE: Batch Create from Template ----
-    server.registerTool("kirjapro_create_from_template_batch", {
-        description: 'Create multiple transactions from templates in one call (up to 50). Default mode "atomic" rolls back ALL on any failure; "best_effort" collects per-row errors.',
-        inputSchema: {
-            fiscalYearId: z
-                .string()
-                .uuid()
-                .optional()
-                .describe("Fiscal year UUID (auto-resolved if omitted)"),
-            mode: z
-                .enum(["atomic", "best_effort"])
-                .default("atomic")
-                .describe('Batch mode. "atomic" (default): all-or-nothing, rolls back on any row failure. "best_effort": commits what it can, returns per-row errors.'),
-            transactions: z
-                .array(z.object({
-                template: z.string().describe("Template ID"),
-                transactionDate: ISO_DATE_SCHEMA
-                    .describe("Date (YYYY-MM-DD)"),
-                amount: z
-                    .number()
-                    .finite()
-                    .positive()
-                    .max(1_000_000_000)
-                    .describe("Gross amount in EUR"),
-                description: z.string().min(1).max(500),
-                documentNumber: z.string().optional(),
-                accountOverrides: z.record(z.string(), z.string()).optional(),
-            }))
-                .min(1)
-                .max(50)
-                .describe("Array of template transactions to create (max 50)"),
-            idempotencyKey: IDEMPOTENCY_KEY_SCHEMA,
-        },
-        annotations: WRITE_ANNOTATIONS,
-    }, async (params) => {
-        const supabase = getSupabase();
-        const companyId = getCompanyId();
-        return withIdempotency(supabase, companyId, "kirjapro_create_from_template_batch", params.idempotencyKey, params, async () => {
-            let fiscalYearId = params.fiscalYearId;
-            if (!fiscalYearId) {
-                const resolved = await resolveOpenFiscalYear(supabase, companyId);
-                if ("isError" in resolved)
-                    return resolved;
-                fiscalYearId = resolved.id;
-            }
-            const { data: fy, error: fyError } = await supabase
-                .from("fiscal_years")
-                .select("id, is_closed, start_date, end_date")
-                .eq("id", fiscalYearId)
-                .eq("company_id", companyId)
-                .single();
-            if (fyError || !fy) {
-                return toErrorContent(`Fiscal year ${fiscalYearId} not found. Use kirjapro_get_dashboard or read kirjapro://fiscal-years resource.`);
-            }
-            if (fy.is_closed) {
-                return toErrorContent(`Fiscal year is closed (${fy.start_date} to ${fy.end_date}).`);
-            }
-            const mergedOverrides = {};
-            for (const tx of params.transactions) {
-                if (!tx.accountOverrides)
-                    continue;
-                for (const [from, to] of Object.entries(tx.accountOverrides)) {
-                    const prior = mergedOverrides[from];
-                    if (prior && prior !== to) {
-                        return toErrorContent(`accountOverrides conflict across batch: "${from}" is mapped to both ` +
-                            `"${prior}" and "${to}". Use a single target per source within one batch.`);
-                    }
-                    mergedOverrides[from] = to;
-                }
-            }
-            if (Object.keys(mergedOverrides).length > 0) {
-                const ov = await validateAccountOverrides(mergedOverrides);
-                if ("error" in ov)
-                    return toErrorContent(ov.error);
-            }
-            // Phase 1: expand templates + collect account numbers
-            const expanded = [];
-            const preFailed = [];
-            for (let i = 0; i < params.transactions.length; i++) {
-                const tx = params.transactions[i];
-                const result = expandTemplate(tx.template, tx.amount, {
-                    accountOverrides: tx.accountOverrides,
-                });
-                if ("error" in result) {
-                    preFailed.push({ index: i, error: result.error });
-                    continue;
-                }
-                if (tx.transactionDate < fy.start_date ||
-                    tx.transactionDate > fy.end_date) {
-                    preFailed.push({
-                        index: i,
-                        error: `Date ${tx.transactionDate} outside fiscal year range (${fy.start_date} to ${fy.end_date}).`,
-                    });
-                    continue;
-                }
-                const totalDebit = roundCents(result.entries.reduce((s, e) => s + e.debitAmount, 0));
-                const totalCredit = roundCents(result.entries.reduce((s, e) => s + e.creditAmount, 0));
-                if (Math.abs(totalDebit - totalCredit) >= 0.01) {
-                    preFailed.push({
-                        index: i,
-                        error: `Template produced unbalanced entries: debits ${totalDebit.toFixed(2)} != credits ${totalCredit.toFixed(2)}.`,
-                    });
-                    continue;
-                }
-                expanded.push({
-                    index: i,
-                    transactionDate: tx.transactionDate,
-                    description: tx.description,
-                    documentNumber: tx.documentNumber || "",
-                    entries: result.entries,
-                });
-            }
-            if (params.mode === "atomic" && preFailed.length > 0) {
-                return toErrorContent(`Atomic batch aborted: ${preFailed.length} transaction(s) failed validation. ` +
-                    `Fix all errors or use mode "best_effort" for partial commits.\n` +
-                    preFailed.map((f) => `  [${f.index}] ${f.error}`).join("\n"));
-            }
-            if (expanded.length === 0) {
-                return toResult({
-                    mode: params.mode,
-                    created_count: 0,
-                    failed_count: preFailed.length,
-                    created: [],
-                    failed: preFailed,
-                });
-            }
-            // Phase 2: resolve all account numbers in one batch
-            const allAccountNumbers = [
-                ...new Set(expanded.flatMap((e) => e.entries.map((en) => en.accountNumber))),
-            ];
-            const accountResult = await resolveAccountNumbers(allAccountNumbers);
-            if ("isError" in accountResult)
-                return accountResult;
-            const accountMap = accountResult;
-            // Phase 3: build RPC payload
-            const rpcTransactions = expanded.map((e) => ({
-                transaction_date: e.transactionDate,
-                description: e.description,
-                document_number: e.documentNumber,
-                entries: toJournalEntries(e.entries, accountMap),
-            }));
-            const { data: rpcResult, error: rpcError } = await supabase.rpc("create_transactions_batch_atomic", {
-                p_company_id: companyId,
-                p_fiscal_year_id: fiscalYearId,
-                p_transactions: rpcTransactions,
-                p_mode: params.mode,
-            });
-            if (rpcError) {
-                return toErrorContent(sanitizeDbError("Batch create failed", rpcError));
-            }
-            const result = rpcResult;
-            const created = result.created.map((c) => ({
-                id: c.id,
-                description: c.description,
-                date: c.date,
-                index: expanded[c.index].index,
-            }));
-            const rpcFailed = result.failed.map((f) => ({
-                index: expanded[f.index].index,
-                error: sanitizeDbError("Failed to create transaction", {
-                    message: f.error,
-                }),
-            }));
-            return toResult({
-                mode: params.mode,
-                created_count: created.length,
-                failed_count: preFailed.length + rpcFailed.length,
-                created,
-                failed: [...preFailed, ...rpcFailed],
-            });
-        });
-    });
-}

package/dist/tools/transactions.d.ts

@@ -1,2 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-export declare function registerTransactionTools(server: McpServer): void;