@dizzlkheinz/ynab-mcpb 0.18.4 → 0.19.0

package/dist/tools/deltaSupport.js

@@ -1,7 +1,7 @@
-import { cacheManager } from '../server/cacheManager.js';
-import { DeltaCache } from '../server/deltaCache.js';
-import { ServerKnowledgeStore } from '../server/serverKnowledgeStore.js';
-import { DeltaFetcher } from './deltaFetcher.js';
+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) {
@@ -39,7 +39,9 @@ function resolveSharedDeltaFetcher(ynabAPI) {
     if (sharedDeltaContext?.deltaFetcher) {
         return sharedDeltaContext.deltaFetcher;
     }
-    const context = sharedDeltaContext ? { ...sharedDeltaContext } : {};
+    const context = sharedDeltaContext
+        ? { ...sharedDeltaContext }
+        : {};
     if (context.manuallyConfigured === undefined) {
         context.manuallyConfigured = false;
     }
@@ -59,37 +61,37 @@ function resolveSharedDeltaFetcher(ynabAPI) {
 }
 function isDeltaFetcher(value) {
     return (value !== null &&
-        typeof value === 'object' &&
+        typeof value === "object" &&
         value instanceof DeltaFetcher &&
-        typeof value.fetchAccounts === 'function' &&
-        typeof value.fetchCategories === 'function');
+        typeof value.fetchAccounts === "function" &&
+        typeof value.fetchCategories === "function");
 }
 function isDeltaCache(value) {
     return (value !== null &&
-        typeof value === 'object' &&
+        typeof value === "object" &&
         value instanceof DeltaCache &&
-        typeof value.fetchWithDelta === 'function');
+        typeof value.fetchWithDelta === "function");
 }
 function isServerKnowledgeStore(value) {
     return (value !== null &&
-        typeof value === 'object' &&
+        typeof value === "object" &&
         value instanceof ServerKnowledgeStore &&
-        typeof value.get === 'function' &&
-        typeof value.update === 'function');
+        typeof value.get === "function" &&
+        typeof value.update === "function");
 }
 function isParamsObject(value) {
     return (value !== null &&
-        typeof value === 'object' &&
+        typeof value === "object" &&
         !Array.isArray(value) &&
         (value.constructor === Object || value.constructor === undefined));
 }
 function getTypeName(value) {
     if (value === null)
-        return 'null';
+        return "null";
     if (value === undefined)
-        return 'undefined';
+        return "undefined";
     const type = typeof value;
-    if (type !== 'object')
+    if (type !== "object")
         return type;
     const constructorName = value.constructor?.name;
     return constructorName ? `${type} (${constructorName})` : type;
@@ -97,12 +99,10 @@ function getTypeName(value) {
 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)}`);
+            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)}`);
+            throw new Error(`resolveDeltaFetcherArgs: When providing 3 arguments, the third argument must be a params object. Got: ${getTypeName(maybeParams)}`);
         }
         return {
             deltaFetcher: deltaFetcherOrParams,
@@ -110,12 +110,11 @@ export function resolveDeltaFetcherArgs(ynabAPI, deltaFetcherOrParams, maybePara
         };
     }
     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)');
+        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)}`);
+        throw new Error(`resolveDeltaFetcherArgs: When providing 2 arguments, the second argument must be a params object. Got: ${getTypeName(deltaFetcherOrParams)}`);
     }
     return {
         deltaFetcher: resolveSharedDeltaFetcher(ynabAPI),
@@ -125,16 +124,13 @@ export function resolveDeltaFetcherArgs(ynabAPI, deltaFetcherOrParams, maybePara
 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)}`);
+            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)}`);
+            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)}`);
+            throw new Error(`resolveDeltaWriteArgs: When providing 3 arguments, the third argument must be a params object. Got: ${getTypeName(maybeParams)}`);
         }
         return {
             deltaCache: deltaCacheOrParams,
@@ -146,25 +142,23 @@ export function resolveDeltaWriteArgs(deltaCacheOrParams, knowledgeStoreOrParams
         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)}`);
+            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).');
+            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)');
+            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)');
+        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)}`);
+        throw new Error(`resolveDeltaWriteArgs: When providing only 1 argument, it must be a params object. Got: ${getTypeName(deltaCacheOrParams)}`);
     }
     if (sharedDeltaContext) {
         if (!sharedDeltaContext.knowledgeStore) {

package/dist/tools/exportTransactions.d.ts

@@ -1,6 +1,7 @@
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import * as ynab from 'ynab';
-import { z } from 'zod/v4';
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type * as ynab from "ynab";
+import { z } from "zod/v4";
+import type { ErrorHandler } from "../server/errorHandler.js";
 export declare const ExportTransactionsSchema: z.ZodObject<{
     budget_id: z.ZodString;
     account_id: z.ZodOptional<z.ZodString>;
@@ -14,4 +15,4 @@ export declare const ExportTransactionsSchema: z.ZodObject<{
     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>;
+export declare function handleExportTransactions(ynabAPI: ynab.API, params: ExportTransactionsParams, errorHandler?: ErrorHandler): Promise<CallToolResult>;

package/dist/tools/exportTransactions.js

@@ -1,30 +1,32 @@
-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';
+import { mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { format } from "date-fns";
+import { z } from "zod/v4";
+import { responseFormatter } from "../server/responseFormatter.js";
+import { withToolErrorHandling } from "../types/index.js";
 export const ExportTransactionsSchema = z
     .object({
-    budget_id: z.string().min(1, 'Budget ID is required'),
+    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)')
+        .regex(/^\d{4}-\d{2}-\d{2}$/, "Date must be in ISO format (YYYY-MM-DD)")
         .optional(),
-    type: z.enum(['uncategorized', 'unapproved']).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`;
+        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 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}`);
@@ -39,10 +41,10 @@ function generateExportFilename(params, transactionCount) {
         filters.push(params.type);
     }
     if (params.minimal !== false) {
-        filters.push('minimal');
+        filters.push("minimal");
     }
     if (filters.length > 0) {
-        description = filters.join('_');
+        description = filters.join("_");
     }
     return `ynab_${description}_${transactionCount}items_${timestamp}.json`;
 }
@@ -50,28 +52,28 @@ 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');
+        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');
+            return join(home, "Downloads");
     }
 }
 function getExportPath() {
-    const exportPath = process.env['YNAB_EXPORT_PATH']?.trim();
+    const exportPath = process.env["YNAB_EXPORT_PATH"]?.trim();
     let targetPath;
     if (!exportPath) {
         targetPath = getDefaultExportPath();
     }
     else {
-        if (exportPath.startsWith('~/')) {
+        if (exportPath.startsWith("~/")) {
             targetPath = join(homedir(), exportPath.slice(2));
         }
         else {
@@ -89,13 +91,13 @@ function getExportPath() {
             return fallbackPath;
         }
         catch (fallbackError) {
-            console.warn('Failed to create default folder, using current directory:', fallbackError);
+            console.warn("Failed to create default folder, using current directory:", fallbackError);
             return process.cwd();
         }
     }
     return targetPath;
 }
-export async function handleExportTransactions(ynabAPI, params) {
+export async function handleExportTransactions(ynabAPI, params, errorHandler) {
     return await withToolErrorHandling(async () => {
         let response;
         if (params.account_id) {
@@ -134,45 +136,45 @@ export async function handleExportTransactions(ynabAPI, params) {
                         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,
-                    };
-                }
+                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');
+        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',
+                    type: "text",
                     text: responseFormatter.format({
-                        message: `Successfully exported ${transactions.length} transactions${params.minimal !== false ? ' (minimal fields)' : ' (full fields)'}`,
+                        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',
+                        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) => ({
@@ -187,5 +189,5 @@ export async function handleExportTransactions(ynabAPI, params) {
                 },
             ],
         };
-    }, 'ynab:export_transactions', 'exporting transactions');
+    }, "ynab:export_transactions", "exporting transactions", errorHandler);
 }

package/dist/tools/monthTools.d.ts

@@ -1,8 +1,9 @@
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import * as ynab from 'ynab';
-import { z } from 'zod/v4';
-import type { DeltaFetcher } from './deltaFetcher.js';
-import type { ToolFactory } from '../types/toolRegistration.js';
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type * as ynab from "ynab";
+import { z } from "zod/v4";
+import type { ErrorHandler } from "../server/errorHandler.js";
+import type { ToolFactory } from "../types/toolRegistration.js";
+import type { DeltaFetcher } from "./deltaFetcher.js";
 export declare const GetMonthSchema: z.ZodObject<{
     budget_id: z.ZodString;
     month: z.ZodString;
@@ -12,7 +13,7 @@ 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 handleGetMonth(ynabAPI: ynab.API, params: GetMonthParams, errorHandler?: ErrorHandler): 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>;
 export declare const registerMonthTools: ToolFactory;

package/dist/tools/monthTools.js

@@ -1,26 +1,28 @@
-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 { CacheKeys } from '../server/cacheKeys.js';
-import { resolveDeltaFetcherArgs } from './deltaSupport.js';
-import { createAdapters, createBudgetResolver } from './adapters.js';
-import { ToolAnnotationPresets } from './toolCategories.js';
+import { z } from "zod/v4";
+import { CacheKeys } from "../server/cacheKeys.js";
+import { CACHE_TTLS, CacheManager, cacheManager, } from "../server/cacheManager.js";
+import { responseFormatter } from "../server/responseFormatter.js";
+import { withToolErrorHandling } from "../types/index.js";
+import { milliunitsToAmount } from "../utils/amountUtils.js";
+import { createAdapters, createBudgetResolver } from "./adapters.js";
+import { resolveDeltaFetcherArgs } from "./deltaSupport.js";
+import { ToolAnnotationPresets } from "./toolCategories.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'),
+    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'),
+    budget_id: z.string().min(1, "Budget ID is required"),
 })
     .strict();
-export async function handleGetMonth(ynabAPI, params) {
+export async function handleGetMonth(ynabAPI, params, errorHandler) {
     return await withToolErrorHandling(async () => {
-        const cacheKey = CacheManager.generateKey(CacheKeys.MONTHS, 'get', params.budget_id, params.month);
+        const cacheKey = CacheManager.generateKey(CacheKeys.MONTHS, "get", params.budget_id, params.month);
         const wasCached = cacheManager.has(cacheKey);
         const month = await cacheManager.wrap(cacheKey, {
             ttl: CACHE_TTLS.MONTHS,
@@ -32,7 +34,7 @@ export async function handleGetMonth(ynabAPI, params) {
         return {
             content: [
                 {
-                    type: 'text',
+                    type: "text",
                     text: responseFormatter.format({
                         month: {
                             month: month.month,
@@ -68,15 +70,15 @@ export async function handleGetMonth(ynabAPI, params) {
                         },
                         cached: wasCached,
                         cache_info: wasCached
-                            ? 'Data retrieved from cache for improved performance'
-                            : 'Fresh data retrieved from YNAB API',
+                            ? "Data retrieved from cache for improved performance"
+                            : "Fresh data retrieved from YNAB API",
                     }),
                 },
             ],
         };
-    }, 'ynab:get_month', 'getting month data');
+    }, "ynab:get_month", "getting month data", errorHandler);
 }
-export async function handleListMonths(ynabAPI, deltaFetcherOrParams, maybeParams) {
+export async function handleListMonths(ynabAPI, deltaFetcherOrParams, maybeParams, errorHandler) {
     const { deltaFetcher, params } = resolveDeltaFetcherArgs(ynabAPI, deltaFetcherOrParams, maybeParams);
     return await withToolErrorHandling(async () => {
         const result = await deltaFetcher.fetchMonths(params.budget_id);
@@ -86,7 +88,7 @@ export async function handleListMonths(ynabAPI, deltaFetcherOrParams, maybeParam
         return {
             content: [
                 {
-                    type: 'text',
+                    type: "text",
                     text: responseFormatter.format({
                         months: months.map((month) => ({
                             month: month.month,
@@ -100,40 +102,40 @@ export async function handleListMonths(ynabAPI, deltaFetcherOrParams, maybeParam
                         })),
                         cached: wasCached,
                         cache_info: wasCached
-                            ? `Data retrieved from cache for improved performance${usedDelta ? ' (delta merge applied)' : ''}`
-                            : 'Fresh data retrieved from YNAB API',
+                            ? `Data retrieved from cache for improved performance${usedDelta ? " (delta merge applied)" : ""}`
+                            : "Fresh data retrieved from YNAB API",
                     }),
                 },
             ],
         };
-    }, 'ynab:list_months', 'listing months');
+    }, "ynab:list_months", "listing months", errorHandler);
 }
 export const registerMonthTools = (registry, context) => {
     const { adapt, adaptWithDelta } = createAdapters(context);
     const budgetResolver = createBudgetResolver(context);
     registry.register({
-        name: 'get_month',
-        description: 'Get budget data for a specific month',
+        name: "get_month",
+        description: "Get budget data for a specific month",
         inputSchema: GetMonthSchema,
         handler: adapt(handleGetMonth),
         defaultArgumentResolver: budgetResolver(),
         metadata: {
             annotations: {
                 ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                title: 'YNAB: Get Month Details',
+                title: "YNAB: Get Month Details",
             },
         },
     });
     registry.register({
-        name: 'list_months',
-        description: 'List all months summary data for a budget',
+        name: "list_months",
+        description: "List all months summary data for a budget",
         inputSchema: ListMonthsSchema,
         handler: adaptWithDelta(handleListMonths),
         defaultArgumentResolver: budgetResolver(),
         metadata: {
             annotations: {
                 ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                title: 'YNAB: List Months',
+                title: "YNAB: List Months",
             },
         },
     });

package/dist/tools/payeeTools.d.ts

@@ -1,8 +1,9 @@
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import * as ynab from 'ynab';
-import { z } from 'zod/v4';
-import type { DeltaFetcher } from './deltaFetcher.js';
-import type { ToolFactory } from '../types/toolRegistration.js';
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type * as ynab from "ynab";
+import { z } from "zod/v4";
+import type { ErrorHandler } from "../server/errorHandler.js";
+import type { ToolFactory } from "../types/toolRegistration.js";
+import type { DeltaFetcher } from "./deltaFetcher.js";
 export declare const ListPayeesSchema: z.ZodObject<{
     budget_id: z.ZodString;
     limit: z.ZodOptional<z.ZodNumber>;
@@ -15,5 +16,5 @@ export declare const GetPayeeSchema: z.ZodObject<{
 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>;
+export declare function handleGetPayee(ynabAPI: ynab.API, params: GetPayeeParams, errorHandler?: ErrorHandler): Promise<CallToolResult>;
 export declare const registerPayeeTools: ToolFactory;