@dizzlkheinz/ynab-mcpb 0.12.1

package/dist/tools/deltaSupport.js

@@ -0,0 +1,176 @@
+import { cacheManager } from '../server/cacheManager.js';
+import { DeltaCache } from '../server/deltaCache.js';
+import { ServerKnowledgeStore } from '../server/serverKnowledgeStore.js';
+import { DeltaFetcher } from './deltaFetcher.js';
+let sharedDeltaContext;
+export function setSharedDeltaSupport(options) {
+    if (!options) {
+        sharedDeltaContext = undefined;
+        return;
+    }
+    sharedDeltaContext = {
+        ...options,
+        manuallyConfigured: true,
+    };
+}
+export function getSharedDeltaSupport() {
+    if (!sharedDeltaContext) {
+        return undefined;
+    }
+    const result = {};
+    if (sharedDeltaContext.deltaFetcher) {
+        result.deltaFetcher = sharedDeltaContext.deltaFetcher;
+    }
+    if (sharedDeltaContext.deltaCache) {
+        result.deltaCache = sharedDeltaContext.deltaCache;
+    }
+    if (sharedDeltaContext.knowledgeStore) {
+        result.knowledgeStore = sharedDeltaContext.knowledgeStore;
+    }
+    return result;
+}
+function resolveSharedDeltaFetcher(ynabAPI) {
+    if (sharedDeltaContext &&
+        !sharedDeltaContext.manuallyConfigured &&
+        sharedDeltaContext.ynabAPI &&
+        sharedDeltaContext.ynabAPI !== ynabAPI) {
+        sharedDeltaContext = undefined;
+    }
+    if (sharedDeltaContext?.deltaFetcher) {
+        return sharedDeltaContext.deltaFetcher;
+    }
+    const context = sharedDeltaContext ? { ...sharedDeltaContext } : {};
+    if (context.manuallyConfigured === undefined) {
+        context.manuallyConfigured = false;
+    }
+    if (!context.deltaCache) {
+        if (!context.knowledgeStore) {
+            context.knowledgeStore = new ServerKnowledgeStore();
+        }
+        context.deltaCache = new DeltaCache(cacheManager, context.knowledgeStore);
+    }
+    const deltaFetcher = new DeltaFetcher(ynabAPI, context.deltaCache);
+    context.deltaFetcher = deltaFetcher;
+    if (!context.ynabAPI) {
+        context.ynabAPI = ynabAPI;
+    }
+    sharedDeltaContext = context;
+    return deltaFetcher;
+}
+function isDeltaFetcher(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        value instanceof DeltaFetcher &&
+        typeof value.fetchAccounts === 'function' &&
+        typeof value.fetchCategories === 'function');
+}
+function isDeltaCache(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        value instanceof DeltaCache &&
+        typeof value.fetchWithDelta === 'function');
+}
+function isServerKnowledgeStore(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        value instanceof ServerKnowledgeStore &&
+        typeof value.get === 'function' &&
+        typeof value.update === 'function');
+}
+function isParamsObject(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        (value.constructor === Object || value.constructor === undefined));
+}
+function getTypeName(value) {
+    if (value === null)
+        return 'null';
+    if (value === undefined)
+        return 'undefined';
+    const type = typeof value;
+    if (type !== 'object')
+        return type;
+    const constructorName = value.constructor?.name;
+    return constructorName ? `${type} (${constructorName})` : type;
+}
+export function resolveDeltaFetcherArgs(ynabAPI, deltaFetcherOrParams, maybeParams) {
+    if (maybeParams !== undefined) {
+        if (!isDeltaFetcher(deltaFetcherOrParams)) {
+            throw new Error('resolveDeltaFetcherArgs: When providing 3 arguments, the second argument must be a DeltaFetcher instance. ' +
+                `Got: ${getTypeName(deltaFetcherOrParams)}`);
+        }
+        if (!isParamsObject(maybeParams)) {
+            throw new Error('resolveDeltaFetcherArgs: When providing 3 arguments, the third argument must be a params object. ' +
+                `Got: ${getTypeName(maybeParams)}`);
+        }
+        return {
+            deltaFetcher: deltaFetcherOrParams,
+            params: maybeParams,
+        };
+    }
+    if (isDeltaFetcher(deltaFetcherOrParams)) {
+        throw new Error('resolveDeltaFetcherArgs: When providing 2 arguments, the second argument must be a params object, not a DeltaFetcher. ' +
+            'To use a custom DeltaFetcher, provide all 3 arguments: (ynabAPI, deltaFetcher, params)');
+    }
+    if (!isParamsObject(deltaFetcherOrParams)) {
+        throw new Error('resolveDeltaFetcherArgs: When providing 2 arguments, the second argument must be a params object. ' +
+            `Got: ${getTypeName(deltaFetcherOrParams)}`);
+    }
+    return {
+        deltaFetcher: resolveSharedDeltaFetcher(ynabAPI),
+        params: deltaFetcherOrParams,
+    };
+}
+export function resolveDeltaWriteArgs(deltaCacheOrParams, knowledgeStoreOrParams, maybeParams) {
+    if (maybeParams !== undefined) {
+        if (!isDeltaCache(deltaCacheOrParams)) {
+            throw new Error('resolveDeltaWriteArgs: When providing 3 arguments, the first argument must be a DeltaCache instance. ' +
+                `Got: ${getTypeName(deltaCacheOrParams)}`);
+        }
+        if (!isServerKnowledgeStore(knowledgeStoreOrParams)) {
+            throw new Error('resolveDeltaWriteArgs: When providing 3 arguments, the second argument must be a ServerKnowledgeStore instance. ' +
+                `Got: ${getTypeName(knowledgeStoreOrParams)}`);
+        }
+        if (!isParamsObject(maybeParams)) {
+            throw new Error('resolveDeltaWriteArgs: When providing 3 arguments, the third argument must be a params object. ' +
+                `Got: ${getTypeName(maybeParams)}`);
+        }
+        return {
+            deltaCache: deltaCacheOrParams,
+            knowledgeStore: knowledgeStoreOrParams,
+            params: maybeParams,
+        };
+    }
+    if (knowledgeStoreOrParams !== undefined) {
+        const isKnowledgeStore = isServerKnowledgeStore(knowledgeStoreOrParams);
+        const isParams = isParamsObject(knowledgeStoreOrParams);
+        if (!isKnowledgeStore && !isParams) {
+            throw new Error('resolveDeltaWriteArgs: When providing 2 arguments, the second argument must be either a ServerKnowledgeStore or a params object. ' +
+                `Got: ${getTypeName(knowledgeStoreOrParams)}`);
+        }
+        if (isParams) {
+            throw new Error('resolveDeltaWriteArgs: Invalid argument combination. When providing 2 arguments where the second is a params object, ' +
+                'this is ambiguous. Either provide 1 argument (params only) or 3 arguments (deltaCache, knowledgeStore, params).');
+        }
+        if (isKnowledgeStore) {
+            throw new Error('resolveDeltaWriteArgs: When providing DeltaCache and ServerKnowledgeStore, you must also provide params as the third argument. ' +
+                'Got 2 arguments, expected 3: (deltaCache, knowledgeStore, params)');
+        }
+    }
+    if (isDeltaCache(deltaCacheOrParams)) {
+        throw new Error('resolveDeltaWriteArgs: When providing only 1 argument, it must be a params object, not a DeltaCache. ' +
+            'To use a custom DeltaCache, provide all 3 arguments: (deltaCache, knowledgeStore, params)');
+    }
+    if (!isParamsObject(deltaCacheOrParams)) {
+        throw new Error('resolveDeltaWriteArgs: When providing only 1 argument, it must be a params object. ' +
+            `Got: ${getTypeName(deltaCacheOrParams)}`);
+    }
+    const fallbackKnowledgeStore = new ServerKnowledgeStore();
+    const fallbackDeltaCache = new DeltaCache(cacheManager, fallbackKnowledgeStore);
+    return {
+        deltaCache: fallbackDeltaCache,
+        knowledgeStore: fallbackKnowledgeStore,
+        params: deltaCacheOrParams,
+    };
+}

package/dist/tools/exportTransactions.d.ts

@@ -0,0 +1,17 @@
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import * as ynab from 'ynab';
+import { z } from 'zod/v4';
+export declare const ExportTransactionsSchema: z.ZodObject<{
+    budget_id: z.ZodString;
+    account_id: z.ZodOptional<z.ZodString>;
+    category_id: z.ZodOptional<z.ZodString>;
+    since_date: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodEnum<{
+        uncategorized: "uncategorized";
+        unapproved: "unapproved";
+    }>>;
+    filename: z.ZodOptional<z.ZodString>;
+    minimal: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strict>;
+export type ExportTransactionsParams = z.infer<typeof ExportTransactionsSchema>;
+export declare function handleExportTransactions(ynabAPI: ynab.API, params: ExportTransactionsParams): Promise<CallToolResult>;

package/dist/tools/exportTransactions.js

@@ -0,0 +1,191 @@
+import { z } from 'zod/v4';
+import { withToolErrorHandling } from '../types/index.js';
+import { responseFormatter } from '../server/responseFormatter.js';
+import { writeFileSync, mkdirSync } from 'fs';
+import { format } from 'date-fns';
+import { join, resolve } from 'path';
+import { homedir } from 'os';
+export const ExportTransactionsSchema = z
+    .object({
+    budget_id: z.string().min(1, 'Budget ID is required'),
+    account_id: z.string().optional(),
+    category_id: z.string().optional(),
+    since_date: z
+        .string()
+        .regex(/^\d{4}-\d{2}-\d{2}$/, 'Date must be in ISO format (YYYY-MM-DD)')
+        .optional(),
+    type: z.enum(['uncategorized', 'unapproved']).optional(),
+    filename: z.string().optional(),
+    minimal: z.boolean().optional().default(true),
+})
+    .strict();
+function generateExportFilename(params, transactionCount) {
+    if (params.filename) {
+        return params.filename.endsWith('.json') ? params.filename : `${params.filename}.json`;
+    }
+    const timestamp = format(new Date(), 'yyyy-MM-dd_HH-mm-ss');
+    let description = 'transactions';
+    const filters = [];
+    if (params.since_date) {
+        filters.push(`since_${params.since_date}`);
+    }
+    if (params.account_id) {
+        filters.push(`account_${params.account_id.substring(0, 8)}`);
+    }
+    if (params.category_id) {
+        filters.push(`category_${params.category_id.substring(0, 8)}`);
+    }
+    if (params.type) {
+        filters.push(params.type);
+    }
+    if (params.minimal !== false) {
+        filters.push('minimal');
+    }
+    if (filters.length > 0) {
+        description = filters.join('_');
+    }
+    return `ynab_${description}_${transactionCount}items_${timestamp}.json`;
+}
+function getDefaultExportPath() {
+    const platform = process.platform;
+    const home = homedir();
+    switch (platform) {
+        case 'win32':
+            return join(home, 'Downloads');
+        case 'darwin':
+            return join(home, 'Downloads');
+        case 'linux':
+        case 'freebsd':
+        case 'openbsd':
+        case 'sunos':
+        case 'aix':
+            return process.env['XDG_DOCUMENTS_DIR'] || join(home, 'Documents');
+        default:
+            return join(home, 'Downloads');
+    }
+}
+function getExportPath() {
+    const exportPath = process.env['YNAB_EXPORT_PATH']?.trim();
+    let targetPath;
+    if (!exportPath) {
+        targetPath = getDefaultExportPath();
+    }
+    else {
+        if (exportPath.startsWith('~/')) {
+            targetPath = join(homedir(), exportPath.slice(2));
+        }
+        else {
+            targetPath = resolve(exportPath);
+        }
+    }
+    try {
+        mkdirSync(targetPath, { recursive: true });
+    }
+    catch (error) {
+        console.warn(`Failed to create export directory ${targetPath}, using platform default:`, error);
+        const fallbackPath = getDefaultExportPath();
+        try {
+            mkdirSync(fallbackPath, { recursive: true });
+            return fallbackPath;
+        }
+        catch (fallbackError) {
+            console.warn('Failed to create default folder, using current directory:', fallbackError);
+            return process.cwd();
+        }
+    }
+    return targetPath;
+}
+export async function handleExportTransactions(ynabAPI, params) {
+    return await withToolErrorHandling(async () => {
+        let response;
+        if (params.account_id) {
+            response = await ynabAPI.transactions.getTransactionsByAccount(params.budget_id, params.account_id, params.since_date);
+        }
+        else if (params.category_id) {
+            response = await ynabAPI.transactions.getTransactionsByCategory(params.budget_id, params.category_id, params.since_date);
+        }
+        else {
+            response = await ynabAPI.transactions.getTransactions(params.budget_id, params.since_date, params.type);
+        }
+        const transactions = response.data.transactions;
+        const exportDir = getExportPath();
+        const filename = generateExportFilename(params, transactions.length);
+        const fullPath = join(exportDir, filename);
+        const exportData = {
+            export_info: {
+                exported_at: new Date().toISOString(),
+                total_transactions: transactions.length,
+                minimal: params.minimal !== false,
+                filters: {
+                    budget_id: params.budget_id,
+                    account_id: params.account_id || null,
+                    category_id: params.category_id || null,
+                    since_date: params.since_date || null,
+                    type: params.type || null,
+                },
+            },
+            transactions: transactions.map((transaction) => {
+                if (params.minimal !== false) {
+                    return {
+                        id: transaction.id,
+                        date: transaction.date,
+                        amount: transaction.amount,
+                        payee_name: transaction.payee_name,
+                        cleared: transaction.cleared,
+                    };
+                }
+                else {
+                    return {
+                        id: transaction.id,
+                        date: transaction.date,
+                        amount: transaction.amount,
+                        memo: transaction.memo,
+                        cleared: transaction.cleared,
+                        approved: transaction.approved,
+                        flag_color: transaction.flag_color,
+                        account_id: transaction.account_id,
+                        payee_id: transaction.payee_id,
+                        category_id: transaction.category_id,
+                        transfer_account_id: transaction.transfer_account_id,
+                        transfer_transaction_id: transaction.transfer_transaction_id,
+                        matched_transaction_id: transaction.matched_transaction_id,
+                        import_id: transaction.import_id,
+                        deleted: transaction.deleted,
+                        account_name: transaction.account_name,
+                        payee_name: transaction.payee_name,
+                        category_name: transaction.category_name,
+                    };
+                }
+            }),
+        };
+        writeFileSync(fullPath, JSON.stringify(exportData, null, 2), 'utf-8');
+        const previewCount = Math.min(10, transactions.length);
+        const preview = transactions.slice(0, previewCount);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: responseFormatter.format({
+                        message: `Successfully exported ${transactions.length} transactions${params.minimal !== false ? ' (minimal fields)' : ' (full fields)'}`,
+                        filename: filename,
+                        full_path: fullPath,
+                        export_directory: exportDir,
+                        export_mode: params.minimal !== false ? 'minimal' : 'full',
+                        minimal_fields: params.minimal !== false ? 'id, date, amount, payee_name, cleared' : null,
+                        filename_explanation: 'Filename format: ynab_{filters}_{count}items_{timestamp}.json - identifies what data was exported, when, and how many transactions',
+                        preview_count: previewCount,
+                        total_count: transactions.length,
+                        preview_transactions: preview.map((transaction) => ({
+                            id: transaction.id,
+                            date: transaction.date,
+                            amount: transaction.amount,
+                            memo: transaction.memo,
+                            payee_name: transaction.payee_name,
+                            category_name: transaction.category_name,
+                        })),
+                    }),
+                },
+            ],
+        };
+    }, 'ynab:export_transactions', 'exporting transactions');
+}

package/dist/tools/monthTools.d.ts

@@ -0,0 +1,16 @@
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import * as ynab from 'ynab';
+import { z } from 'zod/v4';
+import type { DeltaFetcher } from './deltaFetcher.js';
+export declare const GetMonthSchema: z.ZodObject<{
+    budget_id: z.ZodString;
+    month: z.ZodString;
+}, z.core.$strict>;
+export type GetMonthParams = z.infer<typeof GetMonthSchema>;
+export declare const ListMonthsSchema: z.ZodObject<{
+    budget_id: z.ZodString;
+}, z.core.$strict>;
+export type ListMonthsParams = z.infer<typeof ListMonthsSchema>;
+export declare function handleGetMonth(ynabAPI: ynab.API, params: GetMonthParams): Promise<CallToolResult>;
+export declare function handleListMonths(ynabAPI: ynab.API, deltaFetcher: DeltaFetcher, params: ListMonthsParams): Promise<CallToolResult>;
+export declare function handleListMonths(ynabAPI: ynab.API, params: ListMonthsParams): Promise<CallToolResult>;

package/dist/tools/monthTools.js

@@ -0,0 +1,107 @@
+import { z } from 'zod/v4';
+import { withToolErrorHandling } from '../types/index.js';
+import { responseFormatter } from '../server/responseFormatter.js';
+import { milliunitsToAmount } from '../utils/amountUtils.js';
+import { cacheManager, CACHE_TTLS, CacheManager } from '../server/cacheManager.js';
+import { resolveDeltaFetcherArgs } from './deltaSupport.js';
+export const GetMonthSchema = z
+    .object({
+    budget_id: z.string().min(1, 'Budget ID is required'),
+    month: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, 'Month must be in YYYY-MM-DD format'),
+})
+    .strict();
+export const ListMonthsSchema = z
+    .object({
+    budget_id: z.string().min(1, 'Budget ID is required'),
+})
+    .strict();
+export async function handleGetMonth(ynabAPI, params) {
+    return await withToolErrorHandling(async () => {
+        const cacheKey = CacheManager.generateKey('month', 'get', params.budget_id, params.month);
+        const wasCached = cacheManager.has(cacheKey);
+        const month = await cacheManager.wrap(cacheKey, {
+            ttl: CACHE_TTLS.MONTHS,
+            loader: async () => {
+                const response = await ynabAPI.months.getBudgetMonth(params.budget_id, params.month);
+                return response.data.month;
+            },
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: responseFormatter.format({
+                        month: {
+                            month: month.month,
+                            note: month.note,
+                            income: milliunitsToAmount(month.income),
+                            budgeted: milliunitsToAmount(month.budgeted),
+                            activity: milliunitsToAmount(month.activity),
+                            to_be_budgeted: milliunitsToAmount(month.to_be_budgeted),
+                            age_of_money: month.age_of_money,
+                            deleted: month.deleted,
+                            categories: month.categories?.map((category) => ({
+                                id: category.id,
+                                category_group_id: category.category_group_id,
+                                category_group_name: category.category_group_name,
+                                name: category.name,
+                                hidden: category.hidden,
+                                original_category_group_id: category.original_category_group_id,
+                                note: category.note,
+                                budgeted: milliunitsToAmount(category.budgeted),
+                                activity: milliunitsToAmount(category.activity),
+                                balance: milliunitsToAmount(category.balance),
+                                goal_type: category.goal_type,
+                                goal_creation_month: category.goal_creation_month,
+                                goal_target: category.goal_target,
+                                goal_target_month: category.goal_target_month,
+                                goal_percentage_complete: category.goal_percentage_complete,
+                                goal_months_to_budget: category.goal_months_to_budget,
+                                goal_under_funded: category.goal_under_funded,
+                                goal_overall_funded: category.goal_overall_funded,
+                                goal_overall_left: category.goal_overall_left,
+                                deleted: category.deleted,
+                            })),
+                        },
+                        cached: wasCached,
+                        cache_info: wasCached
+                            ? 'Data retrieved from cache for improved performance'
+                            : 'Fresh data retrieved from YNAB API',
+                    }),
+                },
+            ],
+        };
+    }, 'ynab:get_month', 'getting month data');
+}
+export async function handleListMonths(ynabAPI, deltaFetcherOrParams, maybeParams) {
+    const { deltaFetcher, params } = resolveDeltaFetcherArgs(ynabAPI, deltaFetcherOrParams, maybeParams);
+    return await withToolErrorHandling(async () => {
+        const result = await deltaFetcher.fetchMonths(params.budget_id);
+        const months = result.data;
+        const wasCached = result.wasCached;
+        const usedDelta = result.usedDelta;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: responseFormatter.format({
+                        months: months.map((month) => ({
+                            month: month.month,
+                            note: month.note,
+                            income: milliunitsToAmount(month.income),
+                            budgeted: milliunitsToAmount(month.budgeted),
+                            activity: milliunitsToAmount(month.activity),
+                            to_be_budgeted: milliunitsToAmount(month.to_be_budgeted),
+                            age_of_money: month.age_of_money,
+                            deleted: month.deleted,
+                        })),
+                        cached: wasCached,
+                        cache_info: wasCached
+                            ? `Data retrieved from cache for improved performance${usedDelta ? ' (delta merge applied)' : ''}`
+                            : 'Fresh data retrieved from YNAB API',
+                    }),
+                },
+            ],
+        };
+    }, 'ynab:list_months', 'listing months');
+}

package/dist/tools/payeeTools.d.ts

@@ -0,0 +1,17 @@
+import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import * as ynab from 'ynab';
+import { z } from 'zod/v4';
+import type { DeltaFetcher } from './deltaFetcher.js';
+export declare const ListPayeesSchema: z.ZodObject<{
+    budget_id: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type ListPayeesParams = z.infer<typeof ListPayeesSchema>;
+export declare const GetPayeeSchema: z.ZodObject<{
+    budget_id: z.ZodString;
+    payee_id: z.ZodString;
+}, z.core.$strict>;
+export type GetPayeeParams = z.infer<typeof GetPayeeSchema>;
+export declare function handleListPayees(ynabAPI: ynab.API, deltaFetcher: DeltaFetcher, params: ListPayeesParams): Promise<CallToolResult>;
+export declare function handleListPayees(ynabAPI: ynab.API, params: ListPayeesParams): Promise<CallToolResult>;
+export declare function handleGetPayee(ynabAPI: ynab.API, params: GetPayeeParams): Promise<CallToolResult>;

package/dist/tools/payeeTools.js

@@ -0,0 +1,82 @@
+import { z } from 'zod/v4';
+import { withToolErrorHandling } from '../types/index.js';
+import { responseFormatter } from '../server/responseFormatter.js';
+import { cacheManager, CACHE_TTLS, CacheManager } from '../server/cacheManager.js';
+import { resolveDeltaFetcherArgs } from './deltaSupport.js';
+export const ListPayeesSchema = z
+    .object({
+    budget_id: z.string().min(1, 'Budget ID is required'),
+    limit: z.number().int().positive().optional(),
+})
+    .strict();
+export const GetPayeeSchema = z
+    .object({
+    budget_id: z.string().min(1, 'Budget ID is required'),
+    payee_id: z.string().min(1, 'Payee ID is required'),
+})
+    .strict();
+export async function handleListPayees(ynabAPI, deltaFetcherOrParams, maybeParams) {
+    const { deltaFetcher, params } = resolveDeltaFetcherArgs(ynabAPI, deltaFetcherOrParams, maybeParams);
+    return await withToolErrorHandling(async () => {
+        const result = await deltaFetcher.fetchPayees(params.budget_id);
+        let payees = result.data;
+        const wasCached = result.wasCached;
+        const totalCount = payees.length;
+        if (params.limit !== undefined) {
+            payees = payees.slice(0, params.limit);
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: responseFormatter.format({
+                        payees: payees.map((payee) => ({
+                            id: payee.id,
+                            name: payee.name,
+                            transfer_account_id: payee.transfer_account_id,
+                            deleted: payee.deleted,
+                        })),
+                        total_count: totalCount,
+                        returned_count: payees.length,
+                        cached: wasCached,
+                        cache_info: wasCached
+                            ? `Data retrieved from cache for improved performance${result.usedDelta ? ' (delta merge applied)' : ''}`
+                            : 'Fresh data retrieved from YNAB API',
+                    }),
+                },
+            ],
+        };
+    }, 'ynab:list_payees', 'listing payees');
+}
+export async function handleGetPayee(ynabAPI, params) {
+    return await withToolErrorHandling(async () => {
+        const cacheKey = CacheManager.generateKey('payee', 'get', params.budget_id, params.payee_id);
+        const wasCached = cacheManager.has(cacheKey);
+        const payee = await cacheManager.wrap(cacheKey, {
+            ttl: CACHE_TTLS.PAYEES,
+            loader: async () => {
+                const response = await ynabAPI.payees.getPayeeById(params.budget_id, params.payee_id);
+                return response.data.payee;
+            },
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: responseFormatter.format({
+                        payee: {
+                            id: payee.id,
+                            name: payee.name,
+                            transfer_account_id: payee.transfer_account_id,
+                            deleted: payee.deleted,
+                        },
+                        cached: wasCached,
+                        cache_info: wasCached
+                            ? 'Data retrieved from cache for improved performance'
+                            : 'Fresh data retrieved from YNAB API',
+                    }),
+                },
+            ],
+        };
+    }, 'ynab:get_payee', 'getting payee details');
+}

package/dist/tools/reconcileAdapter.d.ts

@@ -0,0 +1,25 @@
+import type { ReconciliationAnalysis } from './reconciliation/types.js';
+import type { LegacyReconciliationResult } from './reconciliation/executor.js';
+interface AdapterOptions {
+    accountName?: string;
+    accountId?: string;
+    currencyCode?: string;
+    csvFormat?: CsvFormatPayload;
+    auditMetadata?: Record<string, unknown>;
+}
+interface DualChannelPayload {
+    human: string;
+    structured: Record<string, unknown>;
+}
+interface CsvFormatPayload {
+    delimiter: string;
+    decimal_separator: string;
+    thousands_separator: string | null;
+    date_format: string;
+    header_row: boolean;
+    date_column: string | null;
+    amount_column: string | null;
+    payee_column: string | null;
+}
+export declare const buildReconciliationPayload: (analysis: ReconciliationAnalysis, options?: AdapterOptions, execution?: LegacyReconciliationResult) => DualChannelPayload;
+export {};