@dizzlkheinz/ynab-mcpb 0.18.3 → 0.19.0

package/dist/tools/adapters.d.ts

@@ -1,13 +1,18 @@
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import type { ToolExecutionPayload, DefaultArgumentResolver, ProgressCallback } from '../server/toolRegistry.js';
-import type { ToolContext, Handler, DeltaHandler, WriteHandler, NoInputHandler } from '../types/toolRegistration.js';
-import type { DeltaFetcher } from './deltaFetcher.js';
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type ErrorHandler } from "../server/errorHandler.js";
+import type { DefaultArgumentResolver, ProgressCallback, ToolExecutionPayload } from "../server/toolRegistry.js";
+import type { DeltaHandler, Handler, NoInputHandler, ToolContext, WriteHandler } from "../types/toolRegistration.js";
+import type { DeltaFetcher } from "./deltaFetcher.js";
 export declare function createAdapters(context: ToolContext): {
-    adapt: <TInput extends Record<string, unknown>>(handler: Handler<TInput>) => ({ input }: ToolExecutionPayload<TInput>) => Promise<CallToolResult>;
+    adapt: <TInput extends Record<string, unknown>>(handler: Handler<TInput>) => ({ input, }: ToolExecutionPayload<TInput>) => Promise<CallToolResult>;
     adaptNoInput: (handler: NoInputHandler) => (_payload: ToolExecutionPayload<Record<string, unknown>>) => Promise<CallToolResult>;
-    adaptWithDelta: <TInput extends Record<string, unknown>>(handler: DeltaHandler<TInput>) => ({ input }: ToolExecutionPayload<TInput>) => Promise<CallToolResult>;
-    adaptWithDeltaAndProgress: <TInput extends Record<string, unknown>>(handler: (api: import("ynab").API, deltaFetcher: DeltaFetcher, params: TInput, sendProgress?: ProgressCallback) => Promise<CallToolResult>) => ({ input, context }: ToolExecutionPayload<TInput>) => Promise<CallToolResult>;
-    adaptWrite: <TInput extends Record<string, unknown>>(handler: WriteHandler<TInput>) => ({ input }: ToolExecutionPayload<TInput>) => Promise<CallToolResult>;
+    adaptWithDelta: <TInput extends Record<string, unknown>>(handler: DeltaHandler<TInput>) => ({ input, }: ToolExecutionPayload<TInput>) => Promise<CallToolResult>;
+    adaptWithDeltaAndProgress: <TInput extends Record<string, unknown>>(handler: (api: import("ynab").API, deltaFetcher: DeltaFetcher, params: TInput, sendProgress?: ProgressCallback, errorHandler?: ErrorHandler) => Promise<CallToolResult>) => ({ input, context: execContext, }: ToolExecutionPayload<TInput>) => Promise<CallToolResult>;
+    adaptWrite: <TInput extends Record<string, unknown>>(handler: WriteHandler<TInput>) => ({ input, }: ToolExecutionPayload<TInput>) => Promise<CallToolResult>;
+};
+export declare function createErrorHelpers(context: ToolContext): {
+    withToolErrorHandling: <T>(operation: () => Promise<T>, toolName: string, operationName: string) => Promise<T | CallToolResult>;
+    handleToolError: (error: unknown, toolName: string, operation: string) => CallToolResult;
 };
 export declare function createBudgetResolver(context: ToolContext): <TInput extends {
     budget_id?: string | undefined;

package/dist/tools/adapters.js

@@ -1,23 +1,33 @@
-import { BudgetResolver } from '../server/budgetResolver.js';
-import { DefaultArgumentResolutionError } from '../server/toolRegistry.js';
+import { BudgetResolver } from "../server/budgetResolver.js";
+import { handleToolError as _handleToolError, withToolErrorHandling as _withToolErrorHandling, } from "../server/errorHandler.js";
+import { DefaultArgumentResolutionError } from "../server/toolRegistry.js";
 export function createAdapters(context) {
     const { ynabAPI, deltaFetcher, deltaCache, serverKnowledgeStore } = context;
+    const { errorHandler } = context;
     return {
-        adapt: (handler) => async ({ input }) => handler(ynabAPI, input),
-        adaptNoInput: (handler) => async (_payload) => handler(ynabAPI),
-        adaptWithDelta: (handler) => async ({ input }) => handler(ynabAPI, deltaFetcher, input),
-        adaptWithDeltaAndProgress: (handler) => async ({ input, context }) => handler(ynabAPI, deltaFetcher, input, context.sendProgress),
-        adaptWrite: (handler) => async ({ input }) => handler(ynabAPI, deltaCache, serverKnowledgeStore, input),
+        adapt: (handler) => async ({ input, }) => handler(ynabAPI, input, errorHandler),
+        adaptNoInput: (handler) => async (_payload) => handler(ynabAPI, errorHandler),
+        adaptWithDelta: (handler) => async ({ input, }) => handler(ynabAPI, deltaFetcher, input, errorHandler),
+        adaptWithDeltaAndProgress: (handler) => async ({ input, context: execContext, }) => handler(ynabAPI, deltaFetcher, input, execContext.sendProgress, errorHandler),
+        adaptWrite: (handler) => async ({ input, }) => handler(ynabAPI, deltaCache, serverKnowledgeStore, input, errorHandler),
+    };
+}
+export function createErrorHelpers(context) {
+    const { errorHandler } = context;
+    return {
+        withToolErrorHandling: (operation, toolName, operationName) => _withToolErrorHandling(operation, toolName, operationName, errorHandler),
+        handleToolError: (error, toolName, operation) => _handleToolError(error, toolName, operation, errorHandler),
     };
 }
 export function createBudgetResolver(context) {
     return () => {
         return ({ rawArguments }) => {
-            const provided = typeof rawArguments['budget_id'] === 'string' && rawArguments['budget_id'].length > 0
-                ? rawArguments['budget_id']
+            const provided = typeof rawArguments["budget_id"] === "string" &&
+                rawArguments["budget_id"].length > 0
+                ? rawArguments["budget_id"]
                 : undefined;
-            const result = BudgetResolver.resolveBudgetId(provided, context.getDefaultBudgetId());
-            if (typeof result === 'string') {
+            const result = BudgetResolver.resolveBudgetId(provided, context.getDefaultBudgetId(), context.errorHandler);
+            if (typeof result === "string") {
                 return { budget_id: result };
             }
             throw new DefaultArgumentResolutionError(result);

package/dist/tools/budgetTools.d.ts

@@ -1,12 +1,13 @@
-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 GetBudgetSchema: z.ZodObject<{
     budget_id: z.ZodString;
 }, z.core.$strict>;
 export type GetBudgetParams = z.infer<typeof GetBudgetSchema>;
-export declare function handleListBudgets(ynabAPI: ynab.API, deltaFetcherOrParams?: DeltaFetcher | Record<string, unknown>, maybeParams?: Record<string, unknown>): Promise<CallToolResult>;
-export declare function handleGetBudget(ynabAPI: ynab.API, params: GetBudgetParams): Promise<CallToolResult>;
+export declare function handleListBudgets(ynabAPI: ynab.API, deltaFetcherOrParams?: DeltaFetcher | Record<string, unknown>, maybeParams?: Record<string, unknown>, errorHandler?: ErrorHandler): Promise<CallToolResult>;
+export declare function handleGetBudget(ynabAPI: ynab.API, params: GetBudgetParams, errorHandler?: ErrorHandler): Promise<CallToolResult>;
 export declare const registerBudgetTools: ToolFactory;

package/dist/tools/budgetTools.js

@@ -1,16 +1,16 @@
-import { z } from 'zod/v4';
-import { withToolErrorHandling } from '../types/index.js';
-import { responseFormatter } from '../server/responseFormatter.js';
-import { resolveDeltaFetcherArgs } from './deltaSupport.js';
-import { createAdapters } from './adapters.js';
-import { ToolAnnotationPresets } from './toolCategories.js';
-import { emptyObjectSchema } from './schemas/common.js';
+import { z } from "zod/v4";
+import { responseFormatter } from "../server/responseFormatter.js";
+import { withToolErrorHandling } from "../types/index.js";
+import { createAdapters } from "./adapters.js";
+import { resolveDeltaFetcherArgs } from "./deltaSupport.js";
+import { emptyObjectSchema } from "./schemas/common.js";
+import { ToolAnnotationPresets } from "./toolCategories.js";
 export const GetBudgetSchema = 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 handleListBudgets(ynabAPI, deltaFetcherOrParams, maybeParams) {
+export async function handleListBudgets(ynabAPI, deltaFetcherOrParams, maybeParams, errorHandler) {
     const { deltaFetcher } = resolveDeltaFetcherArgs(ynabAPI, (deltaFetcherOrParams ?? {}), maybeParams);
     return await withToolErrorHandling(async () => {
         const result = await deltaFetcher.fetchBudgets();
@@ -19,7 +19,7 @@ export async function handleListBudgets(ynabAPI, deltaFetcherOrParams, maybePara
         return {
             content: [
                 {
-                    type: 'text',
+                    type: "text",
                     text: responseFormatter.format({
                         budgets: budgets.map((budget) => ({
                             id: budget.id,
@@ -32,22 +32,22 @@ export async function handleListBudgets(ynabAPI, deltaFetcherOrParams, maybePara
                         })),
                         cached: wasCached,
                         cache_info: wasCached
-                            ? `Data retrieved from cache for improved performance${result.usedDelta ? ' (delta merge applied)' : ''}`
-                            : 'Fresh data retrieved from YNAB API',
+                            ? `Data retrieved from cache for improved performance${result.usedDelta ? " (delta merge applied)" : ""}`
+                            : "Fresh data retrieved from YNAB API",
                     }),
                 },
             ],
         };
-    }, 'ynab:list_budgets', 'listing budgets');
+    }, "ynab:list_budgets", "listing budgets", errorHandler);
 }
-export async function handleGetBudget(ynabAPI, params) {
+export async function handleGetBudget(ynabAPI, params, errorHandler) {
     return await withToolErrorHandling(async () => {
         const response = await ynabAPI.budgets.getBudgetById(params.budget_id);
         const budget = response.data.budget;
         return {
             content: [
                 {
-                    type: 'text',
+                    type: "text",
                     text: responseFormatter.format({
                         budget: {
                             id: budget.id,
@@ -61,37 +61,37 @@ export async function handleGetBudget(ynabAPI, params) {
                             categories_count: budget.categories?.length ?? 0,
                             payees_count: budget.payees?.length ?? 0,
                             months_count: budget.months?.length ?? 0,
-                            message: 'Use list_accounts, list_categories, list_payees, and list_months to get detailed lists',
+                            message: "Use list_accounts, list_categories, list_payees, and list_months to get detailed lists",
                         },
                     }),
                 },
             ],
         };
-    }, 'ynab:get_budget', 'getting budget details');
+    }, "ynab:get_budget", "getting budget details", errorHandler);
 }
 export const registerBudgetTools = (registry, context) => {
     const { adapt, adaptWithDelta } = createAdapters(context);
     registry.register({
-        name: 'list_budgets',
+        name: "list_budgets",
         description: "List all budgets associated with the user's account",
         inputSchema: emptyObjectSchema,
         handler: adaptWithDelta(handleListBudgets),
         metadata: {
             annotations: {
                 ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                title: 'YNAB: List Budgets',
+                title: "YNAB: List Budgets",
             },
         },
     });
     registry.register({
-        name: 'get_budget',
-        description: 'Get detailed information for a specific budget',
+        name: "get_budget",
+        description: "Get detailed information for a specific budget",
         inputSchema: GetBudgetSchema,
         handler: adapt(handleGetBudget),
         metadata: {
             annotations: {
                 ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                title: 'YNAB: Get Budget Details',
+                title: "YNAB: Get Budget Details",
             },
         },
     });

package/dist/tools/categoryTools.d.ts

@@ -1,10 +1,11 @@
-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 { DeltaCache } from '../server/deltaCache.js';
-import type { ServerKnowledgeStore } from '../server/serverKnowledgeStore.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 { DeltaCache } from "../server/deltaCache.js";
+import type { ErrorHandler } from "../server/errorHandler.js";
+import type { ServerKnowledgeStore } from "../server/serverKnowledgeStore.js";
+import type { ToolFactory } from "../types/toolRegistration.js";
+import type { DeltaFetcher } from "./deltaFetcher.js";
 export declare const ListCategoriesSchema: z.ZodObject<{
     budget_id: z.ZodString;
 }, z.core.$strict>;
@@ -23,7 +24,7 @@ export declare const UpdateCategorySchema: z.ZodObject<{
 export type UpdateCategoryParams = z.infer<typeof UpdateCategorySchema>;
 export declare function handleListCategories(ynabAPI: ynab.API, deltaFetcher: DeltaFetcher, params: ListCategoriesParams): Promise<CallToolResult>;
 export declare function handleListCategories(ynabAPI: ynab.API, params: ListCategoriesParams): Promise<CallToolResult>;
-export declare function handleGetCategory(ynabAPI: ynab.API, params: GetCategoryParams): Promise<CallToolResult>;
+export declare function handleGetCategory(ynabAPI: ynab.API, params: GetCategoryParams, errorHandler?: ErrorHandler): Promise<CallToolResult>;
 export declare function handleUpdateCategory(ynabAPI: ynab.API, deltaCache: DeltaCache, knowledgeStore: ServerKnowledgeStore, params: UpdateCategoryParams): Promise<CallToolResult>;
 export declare function handleUpdateCategory(ynabAPI: ynab.API, params: UpdateCategoryParams): Promise<CallToolResult>;
 export declare const registerCategoryTools: ToolFactory;

package/dist/tools/categoryTools.js

@@ -1,34 +1,38 @@
-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, resolveDeltaWriteArgs } 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, resolveDeltaWriteArgs, } from "./deltaSupport.js";
+import { ToolAnnotationPresets } from "./toolCategories.js";
 export const ListCategoriesSchema = z
     .object({
-    budget_id: z.string().min(1, 'Budget ID is required'),
+    budget_id: z.string().min(1, "Budget ID is required"),
 })
     .strict();
 export const GetCategorySchema = z
     .object({
-    budget_id: z.string().min(1, 'Budget ID is required'),
-    category_id: z.string().min(1, 'Category ID is required'),
+    budget_id: z.string().min(1, "Budget ID is required"),
+    category_id: z.string().min(1, "Category ID is required"),
 })
     .strict();
 export const UpdateCategorySchema = z
     .object({
-    budget_id: z.string().min(1, 'Budget ID is required'),
-    category_id: z.string().min(1, 'Category ID is required'),
-    budgeted: z.number().int('Budgeted amount must be an integer in milliunits'),
+    budget_id: z.string().min(1, "Budget ID is required"),
+    category_id: z.string().min(1, "Category ID is required"),
+    budgeted: z
+        .number()
+        .int("Budgeted amount must be an integer in milliunits"),
     dry_run: z.boolean().optional(),
 })
     .strict();
 function convertGoalFields(category) {
     return {
-        goal_target: category.goal_target != null ? milliunitsToAmount(category.goal_target) : undefined,
+        goal_target: category.goal_target != null
+            ? milliunitsToAmount(category.goal_target)
+            : undefined,
         goal_under_funded: category.goal_under_funded != null
             ? milliunitsToAmount(category.goal_under_funded)
             : undefined,
@@ -40,7 +44,7 @@ function convertGoalFields(category) {
             : undefined,
     };
 }
-export async function handleListCategories(ynabAPI, deltaFetcherOrParams, maybeParams) {
+export async function handleListCategories(ynabAPI, deltaFetcherOrParams, maybeParams, errorHandler) {
     const { deltaFetcher, params } = resolveDeltaFetcherArgs(ynabAPI, deltaFetcherOrParams, maybeParams);
     return await withToolErrorHandling(async () => {
         const result = await deltaFetcher.fetchCategories(params.budget_id);
@@ -66,7 +70,7 @@ export async function handleListCategories(ynabAPI, deltaFetcherOrParams, maybeP
         return {
             content: [
                 {
-                    type: 'text',
+                    type: "text",
                     text: responseFormatter.format({
                         categories: allCategories,
                         category_groups: categoryGroups.map((group) => ({
@@ -77,17 +81,17 @@ export async function handleListCategories(ynabAPI, deltaFetcherOrParams, maybeP
                         })),
                         cached: wasCached,
                         cache_info: wasCached
-                            ? `Data retrieved from cache for improved performance${result.usedDelta ? ' (delta merge applied)' : ''}`
-                            : 'Fresh data retrieved from YNAB API',
+                            ? `Data retrieved from cache for improved performance${result.usedDelta ? " (delta merge applied)" : ""}`
+                            : "Fresh data retrieved from YNAB API",
                     }),
                 },
             ],
         };
-    }, 'ynab:list_categories', 'listing categories');
+    }, "ynab:list_categories", "listing categories", errorHandler);
 }
-export async function handleGetCategory(ynabAPI, params) {
+export async function handleGetCategory(ynabAPI, params, errorHandler) {
     return await withToolErrorHandling(async () => {
-        const cacheKey = CacheManager.generateKey(CacheKeys.CATEGORIES, 'get', params.budget_id, params.category_id);
+        const cacheKey = CacheManager.generateKey(CacheKeys.CATEGORIES, "get", params.budget_id, params.category_id);
         const wasCached = cacheManager.has(cacheKey);
         const category = await cacheManager.wrap(cacheKey, {
             ttl: CACHE_TTLS.CATEGORIES,
@@ -99,7 +103,7 @@ export async function handleGetCategory(ynabAPI, params) {
         return {
             content: [
                 {
-                    type: 'text',
+                    type: "text",
                     text: responseFormatter.format({
                         category: {
                             id: category.id,
@@ -119,27 +123,27 @@ export async function handleGetCategory(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_category', 'getting category');
+    }, "ynab:get_category", "getting category", errorHandler);
 }
-export async function handleUpdateCategory(ynabAPI, deltaCacheOrParams, knowledgeStoreOrParams, maybeParams) {
+export async function handleUpdateCategory(ynabAPI, deltaCacheOrParams, knowledgeStoreOrParams, maybeParams, _errorHandler) {
     const { deltaCache, knowledgeStore, params } = resolveDeltaWriteArgs(deltaCacheOrParams, knowledgeStoreOrParams, maybeParams);
     try {
         if (params.dry_run) {
             const currentDate = new Date();
-            const currentMonth = `${currentDate.getFullYear()}-${String(currentDate.getMonth() + 1).padStart(2, '0')}-01`;
+            const currentMonth = `${currentDate.getFullYear()}-${String(currentDate.getMonth() + 1).padStart(2, "0")}-01`;
             return {
                 content: [
                     {
-                        type: 'text',
+                        type: "text",
                         text: responseFormatter.format({
                             dry_run: true,
-                            action: 'update_category',
+                            action: "update_category",
                             request: {
                                 budget_id: params.budget_id,
                                 category_id: params.category_id,
@@ -152,28 +156,28 @@ export async function handleUpdateCategory(ynabAPI, deltaCacheOrParams, knowledg
             };
         }
         const currentDate = new Date();
-        const currentMonth = `${currentDate.getFullYear()}-${String(currentDate.getMonth() + 1).padStart(2, '0')}-01`;
+        const currentMonth = `${currentDate.getFullYear()}-${String(currentDate.getMonth() + 1).padStart(2, "0")}-01`;
         const response = await ynabAPI.categories.updateMonthCategory(params.budget_id, currentMonth, params.category_id, { category: { budgeted: params.budgeted } });
         const category = response.data.category;
-        const categoriesListCacheKey = CacheManager.generateKey(CacheKeys.CATEGORIES, 'list', params.budget_id);
-        const specificCategoryCacheKey = CacheManager.generateKey(CacheKeys.CATEGORIES, 'get', params.budget_id, params.category_id);
+        const categoriesListCacheKey = CacheManager.generateKey(CacheKeys.CATEGORIES, "list", params.budget_id);
+        const specificCategoryCacheKey = CacheManager.generateKey(CacheKeys.CATEGORIES, "get", params.budget_id, params.category_id);
         cacheManager.delete(categoriesListCacheKey);
         cacheManager.delete(specificCategoryCacheKey);
-        const monthsListCacheKey = CacheManager.generateKey(CacheKeys.MONTHS, 'list', params.budget_id);
-        const currentMonthCacheKey = CacheManager.generateKey(CacheKeys.MONTHS, 'get', params.budget_id, currentMonth);
+        const monthsListCacheKey = CacheManager.generateKey(CacheKeys.MONTHS, "list", params.budget_id);
+        const currentMonthCacheKey = CacheManager.generateKey(CacheKeys.MONTHS, "get", params.budget_id, currentMonth);
         cacheManager.delete(monthsListCacheKey);
         cacheManager.delete(currentMonthCacheKey);
         deltaCache.invalidate(params.budget_id, CacheKeys.CATEGORIES);
         deltaCache.invalidate(params.budget_id, CacheKeys.MONTHS);
         const serverKnowledge = response.data.server_knowledge;
-        if (typeof serverKnowledge === 'number') {
+        if (typeof serverKnowledge === "number") {
             knowledgeStore.update(categoriesListCacheKey, serverKnowledge);
             knowledgeStore.update(monthsListCacheKey, serverKnowledge);
         }
         return {
             content: [
                 {
-                    type: 'text',
+                    type: "text",
                     text: responseFormatter.format({
                         category: {
                             id: category.id,
@@ -198,48 +202,48 @@ export async function handleUpdateCategory(ynabAPI, deltaCacheOrParams, knowledg
         };
     }
     catch (error) {
-        return handleCategoryError(error, 'Failed to update category');
+        return handleCategoryError(error, "Failed to update category");
     }
 }
 export const registerCategoryTools = (registry, context) => {
     const { adapt, adaptWithDelta, adaptWrite } = createAdapters(context);
     const budgetResolver = createBudgetResolver(context);
     registry.register({
-        name: 'list_categories',
-        description: 'List all categories for a specific budget',
+        name: "list_categories",
+        description: "List all categories for a specific budget",
         inputSchema: ListCategoriesSchema,
         handler: adaptWithDelta(handleListCategories),
         defaultArgumentResolver: budgetResolver(),
         metadata: {
             annotations: {
                 ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                title: 'YNAB: List Categories',
+                title: "YNAB: List Categories",
             },
         },
     });
     registry.register({
-        name: 'get_category',
-        description: 'Get detailed information for a specific category',
+        name: "get_category",
+        description: "Get detailed information for a specific category",
         inputSchema: GetCategorySchema,
         handler: adapt(handleGetCategory),
         defaultArgumentResolver: budgetResolver(),
         metadata: {
             annotations: {
                 ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                title: 'YNAB: Get Category Details',
+                title: "YNAB: Get Category Details",
             },
         },
     });
     registry.register({
-        name: 'update_category',
-        description: 'Update the budgeted amount for a category in the current month',
+        name: "update_category",
+        description: "Update the budgeted amount for a category in the current month",
         inputSchema: UpdateCategorySchema,
         handler: adaptWrite(handleUpdateCategory),
         defaultArgumentResolver: budgetResolver(),
         metadata: {
             annotations: {
                 ...ToolAnnotationPresets.WRITE_EXTERNAL_UPDATE,
-                title: 'YNAB: Update Category Budget',
+                title: "YNAB: Update Category Budget",
             },
         },
     });
@@ -247,26 +251,31 @@ export const registerCategoryTools = (registry, context) => {
 function handleCategoryError(error, defaultMessage) {
     let errorMessage = defaultMessage;
     if (error instanceof Error) {
-        if (error.message.includes('401') || error.message.includes('Unauthorized')) {
-            errorMessage = 'Invalid or expired YNAB access token';
+        if (error.message.includes("401") ||
+            error.message.includes("Unauthorized")) {
+            errorMessage = "Invalid or expired YNAB access token";
         }
-        else if (error.message.includes('403') || error.message.includes('Forbidden')) {
-            errorMessage = 'Insufficient permissions to access YNAB data';
+        else if (error.message.includes("403") ||
+            error.message.includes("Forbidden")) {
+            errorMessage = "Insufficient permissions to access YNAB data";
         }
-        else if (error.message.includes('404') || error.message.includes('Not Found')) {
-            errorMessage = 'Budget or category not found';
+        else if (error.message.includes("404") ||
+            error.message.includes("Not Found")) {
+            errorMessage = "Budget or category not found";
         }
-        else if (error.message.includes('429') || error.message.includes('Too Many Requests')) {
-            errorMessage = 'Rate limit exceeded. Please try again later';
+        else if (error.message.includes("429") ||
+            error.message.includes("Too Many Requests")) {
+            errorMessage = "Rate limit exceeded. Please try again later";
         }
-        else if (error.message.includes('500') || error.message.includes('Internal Server Error')) {
-            errorMessage = 'YNAB service is currently unavailable';
+        else if (error.message.includes("500") ||
+            error.message.includes("Internal Server Error")) {
+            errorMessage = "YNAB service is currently unavailable";
         }
     }
     return {
         content: [
             {
-                type: 'text',
+                type: "text",
                 text: responseFormatter.format({
                     error: {
                         message: errorMessage,

package/dist/tools/compareTransactions/formatter.d.ts

@@ -1,6 +1,6 @@
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import * as ynab from 'ynab';
-import { BankTransaction, YNABTransaction, TransactionMatch } from './types.js';
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import type * as ynab from "ynab";
+import type { BankTransaction, TransactionMatch, YNABTransaction } from "./types.js";
 export declare function findSuggestedPayee(description: string, payees: ynab.Payee[]): {
     suggested_payee_id?: string;
     suggested_payee_name?: string;

package/dist/tools/compareTransactions/formatter.js

@@ -1,4 +1,4 @@
-import { responseFormatter } from '../../server/responseFormatter.js';
+import { responseFormatter } from "../../server/responseFormatter.js";
 export function findSuggestedPayee(description, payees) {
     if (!description) {
         return {};
@@ -15,12 +15,12 @@ export function findSuggestedPayee(description, payees) {
         }
     }
     const suggested_name = description
-        .replace(/\d+/g, '')
-        .replace(/\s+/g, ' ')
+        .replace(/\d+/g, "")
+        .replace(/\s+/g, " ")
         .trim();
     return {
         suggested_payee_name: suggested_name,
-        suggestion_reason: `No matching payee found. Suggested new payee name from description.`,
+        suggestion_reason: "No matching payee found. Suggested new payee name from description.",
     };
 }
 export function buildSummary(bankTransactions, ynabTransactions, matches, unmatchedBank, unmatchedYnab, parameters, dateRange) {
@@ -39,10 +39,10 @@ export function buildSummary(bankTransactions, ynabTransactions, matches, unmatc
 }
 export function formatMatches(matches) {
     return matches.map((match) => ({
-        bank_date: match.bank_transaction.date.toISOString().split('T')[0],
+        bank_date: match.bank_transaction.date.toISOString().split("T")[0],
         bank_amount: (match.bank_transaction.amount / 1000).toFixed(2),
         bank_description: match.bank_transaction.description,
-        ynab_date: match.ynab_transaction.date.toISOString().split('T')[0],
+        ynab_date: match.ynab_transaction.date.toISOString().split("T")[0],
         ynab_amount: (match.ynab_transaction.amount / 1000).toFixed(2),
         ynab_payee: match.ynab_transaction.payee_name,
         ynab_transaction: {
@@ -57,7 +57,7 @@ export function formatUnmatchedBank(unmatchedBank, payees) {
     return unmatchedBank.map((txn) => {
         const payeeSuggestion = findSuggestedPayee(txn.description, payees);
         return {
-            date: txn.date.toISOString().split('T')[0],
+            date: txn.date.toISOString().split("T")[0],
             amount: (txn.amount / 1000).toFixed(2),
             description: txn.description,
             row_number: txn.row_number,
@@ -68,7 +68,7 @@ export function formatUnmatchedBank(unmatchedBank, payees) {
 export function formatUnmatchedYNAB(unmatchedYnab) {
     return unmatchedYnab.map((txn) => ({
         id: txn.id,
-        date: txn.date.toISOString().split('T')[0],
+        date: txn.date.toISOString().split("T")[0],
         amount: (txn.amount / 1000).toFixed(2),
         payee_name: txn.payee_name,
         memo: txn.memo,
@@ -84,7 +84,7 @@ export function buildComparisonResult(matchResults, bankTransactions, ynabTransa
     return {
         content: [
             {
-                type: 'text',
+                type: "text",
                 text: responseFormatter.format({
                     summary,
                     matches: formattedMatches,

package/dist/tools/compareTransactions/index.d.ts

@@ -1,13 +1,13 @@
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import * as ynab from 'ynab';
-import { z } from 'zod/v4';
-export type { BankTransaction, YNABTransaction, TransactionMatch } from './types.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";
+export type { BankTransaction, YNABTransaction, TransactionMatch, } from "./types.js";
 export declare const CompareTransactionsSchema: z.ZodObject<{
     budget_id: z.ZodString;
     account_id: z.ZodString;
     csv_file_path: z.ZodOptional<z.ZodString>;
     csv_data: z.ZodOptional<z.ZodString>;
-    date_range_days: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     amount_tolerance: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     date_tolerance_days: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
     enable_chronology_bonus: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -27,4 +27,4 @@ export declare const CompareTransactionsSchema: z.ZodObject<{
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 export type CompareTransactionsParams = z.infer<typeof CompareTransactionsSchema>;
-export declare function handleCompareTransactions(ynabAPI: ynab.API, params: CompareTransactionsParams): Promise<CallToolResult>;
+export declare function handleCompareTransactions(ynabAPI: ynab.API, params: CompareTransactionsParams, errorHandler?: ErrorHandler): Promise<CallToolResult>;