@dizzlkheinz/ynab-mcpb 0.18.4 → 0.19.0

package/dist/server/responseFormatter.js

@@ -1,9 +1,9 @@
-import { AsyncLocalStorage } from 'async_hooks';
+import { AsyncLocalStorage } from "node:async_hooks";
 function parseBool(value, fallback) {
     if (value === undefined)
         return fallback;
     const v = value.trim().toLowerCase();
-    return v === '1' || v === 'true' || v === 'yes' || v === 'on';
+    return v === "1" || v === "true" || v === "yes" || v === "on";
 }
 function parseIntSafe(value, fallback) {
     if (value === undefined)
@@ -14,15 +14,15 @@ function parseIntSafe(value, fallback) {
 class ResponseFormatter {
     constructor() {
         this.als = new AsyncLocalStorage();
-        this.defaultMinify = parseBool(process.env['YNAB_MCP_MINIFY_OUTPUT'], true);
-        this.prettySpaces = parseIntSafe(process.env['YNAB_MCP_PRETTY_SPACES'], 2);
+        this.defaultMinify = parseBool(process.env["YNAB_MCP_MINIFY_OUTPUT"], true);
+        this.prettySpaces = parseIntSafe(process.env["YNAB_MCP_PRETTY_SPACES"], 2);
     }
     configure(options) {
         if (!options)
             return;
-        if (typeof options.defaultMinify === 'boolean')
+        if (typeof options.defaultMinify === "boolean")
             this.defaultMinify = options.defaultMinify;
-        if (typeof options.prettySpaces === 'number' && options.prettySpaces >= 0) {
+        if (typeof options.prettySpaces === "number" && options.prettySpaces >= 0) {
             this.prettySpaces = options.prettySpaces;
         }
     }

package/dist/server/securityMiddleware.d.ts

@@ -1,5 +1,5 @@
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod/v4';
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod/v4";
 export interface SecurityContext {
     accessToken: string;
     toolName: string;

package/dist/server/securityMiddleware.js

@@ -1,19 +1,19 @@
-import { z } from 'zod/v4';
-import { fromZodError } from 'zod-validation-error';
-import { globalRateLimiter, RateLimitError } from './rateLimiter.js';
-import { globalRequestLogger } from './requestLogger.js';
-import { ErrorHandler } from './errorHandler.js';
-import { responseFormatter } from './responseFormatter.js';
+import { fromZodError } from "zod-validation-error";
+import { z } from "zod/v4";
+import { createErrorHandler } from "./errorHandler.js";
+import { RateLimitError, globalRateLimiter } from "./rateLimiter.js";
+import { globalRequestLogger } from "./requestLogger.js";
+import { responseFormatter } from "./responseFormatter.js";
 export class SecurityMiddleware {
     static async withSecurity(context, schema, operation) {
         const startTime = Date.now();
         try {
-            const validatedParams = await this.validateInput(schema, context.parameters);
-            await this.checkRateLimit(context.accessToken);
-            globalRateLimiter.recordRequest(this.hashToken(context.accessToken));
+            const validatedParams = await SecurityMiddleware.validateInput(schema, context.parameters);
+            await SecurityMiddleware.checkRateLimit(context.accessToken);
+            globalRateLimiter.recordRequest(SecurityMiddleware.hashToken(context.accessToken));
             const result = await operation(validatedParams);
             const duration = Date.now() - startTime;
-            const rateLimitInfo = globalRateLimiter.getStatus(this.hashToken(context.accessToken));
+            const rateLimitInfo = globalRateLimiter.getStatus(SecurityMiddleware.hashToken(context.accessToken));
             globalRequestLogger.logSuccess(context.toolName, context.operation, context.parameters, duration, {
                 remaining: rateLimitInfo.remaining,
                 isLimited: rateLimitInfo.isLimited,
@@ -22,17 +22,19 @@ export class SecurityMiddleware {
         }
         catch (error) {
             const duration = Date.now() - startTime;
-            const rateLimitInfo = globalRateLimiter.getStatus(this.hashToken(context.accessToken));
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            const rateLimitInfo = globalRateLimiter.getStatus(SecurityMiddleware.hashToken(context.accessToken));
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
             globalRequestLogger.logError(context.toolName, context.operation, context.parameters, errorMessage, duration, {
                 remaining: rateLimitInfo.remaining,
                 isLimited: rateLimitInfo.isLimited,
             });
             if (error instanceof RateLimitError) {
-                return this.createRateLimitErrorResponse(error);
+                return SecurityMiddleware.createRateLimitErrorResponse(error);
             }
-            if (error instanceof Error && error.message.includes('Validation failed')) {
-                return ErrorHandler.createValidationError('Invalid parameters for ' + context.toolName, error.message);
+            if (error instanceof Error &&
+                error.message.includes("Validation failed")) {
+                const errorHandler = createErrorHandler(responseFormatter);
+                return errorHandler.createValidationError(`Invalid parameters for ${context.toolName}`, error.message);
             }
             throw error;
         }
@@ -50,10 +52,10 @@ export class SecurityMiddleware {
         }
     }
     static async checkRateLimit(accessToken) {
-        const tokenHash = this.hashToken(accessToken);
+        const tokenHash = SecurityMiddleware.hashToken(accessToken);
         const rateLimitInfo = globalRateLimiter.isAllowed(tokenHash);
         if (rateLimitInfo.isLimited) {
-            throw new RateLimitError('Rate limit exceeded. Please wait before making additional requests.', rateLimitInfo.resetTime, rateLimitInfo.remaining);
+            throw new RateLimitError("Rate limit exceeded. Please wait before making additional requests.", rateLimitInfo.resetTime, rateLimitInfo.remaining);
         }
     }
     static createRateLimitErrorResponse(error) {
@@ -61,10 +63,10 @@ export class SecurityMiddleware {
             isError: true,
             content: [
                 {
-                    type: 'text',
+                    type: "text",
                     text: responseFormatter.format({
                         error: {
-                            code: 'RATE_LIMIT_EXCEEDED',
+                            code: "RATE_LIMIT_EXCEEDED",
                             message: error.message,
                             details: {
                                 resetTime: error.resetTime.toISOString(),
@@ -88,7 +90,7 @@ export class SecurityMiddleware {
     static getSecurityStats() {
         return {
             rateLimitStats: {
-                message: 'Rate limiting is active with YNAB API limits (200 requests/hour)',
+                message: "Rate limiting is active with YNAB API limits (200 requests/hour)",
             },
             requestStats: globalRequestLogger.getStats(),
         };

package/dist/server/serverKnowledgeStore.js

@@ -12,7 +12,7 @@ export class ServerKnowledgeStore {
         this.knowledge.set(cacheKey, value);
     }
     reset(keyPattern) {
-        if (keyPattern === undefined || keyPattern === '') {
+        if (keyPattern === undefined || keyPattern === "") {
             this.knowledge.clear();
             return;
         }

package/dist/server/toolRegistry.d.ts

@@ -1,6 +1,6 @@
-import type { CallToolResult, Tool } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod/v4';
-import type { MCPToolAnnotations } from '../types/toolAnnotations.js';
+import type { CallToolResult, Tool } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod/v4";
+import type { MCPToolAnnotations } from "../types/toolAnnotations.js";
 export type SecurityWrapperFactory = <T extends Record<string, unknown>>(namespace: string, operation: string, schema: z.ZodSchema<T>) => (accessToken: string) => (params: Record<string, unknown>) => (handler: (validated: T) => Promise<CallToolResult>) => Promise<CallToolResult>;
 export interface ErrorHandlerContract {
     handleError(error: unknown, context: string): CallToolResult;

package/dist/server/toolRegistry.js

@@ -1,13 +1,13 @@
-import { z, toJSONSchema } from 'zod/v4';
-import { fromZodError } from 'zod-validation-error';
+import { fromZodError } from "zod-validation-error";
+import { toJSONSchema, z } from "zod/v4";
 export class DefaultArgumentResolutionError extends Error {
     constructor(result) {
-        super('Default argument resolution failed');
+        super("Default argument resolution failed");
         this.result = result;
-        this.name = 'DefaultArgumentResolutionError';
+        this.name = "DefaultArgumentResolutionError";
     }
 }
-const MINIFY_HINT_KEYS = ['minify', '_minify', '__minify'];
+const MINIFY_HINT_KEYS = ["minify", "_minify", "__minify"];
 export class ToolRegistry {
     constructor(deps) {
         this.deps = deps;
@@ -22,7 +22,7 @@ export class ToolRegistry {
         const resolved = {
             ...definition,
             security: {
-                namespace: definition.security?.namespace ?? 'ynab',
+                namespace: definition.security?.namespace ?? "ynab",
                 operation: definition.security?.operation ?? definition.name,
             },
         };
@@ -42,7 +42,7 @@ export class ToolRegistry {
                 inputSchema,
             };
             if (tool.outputSchema) {
-                const outputSchema = this.generateJsonSchema(tool.outputSchema, 'output');
+                const outputSchema = this.generateJsonSchema(tool.outputSchema, "output");
                 result.outputSchema = outputSchema;
             }
             if (tool.metadata?.annotations) {
@@ -78,7 +78,7 @@ export class ToolRegistry {
     async executeTool(options) {
         const tool = this.tools.get(options.name);
         if (!tool) {
-            return this.deps.errorHandler.createValidationError(`Unknown tool: ${options.name}`, 'The requested tool is not registered with the server');
+            return this.deps.errorHandler.createValidationError(`Unknown tool: ${options.name}`, "The requested tool is not registered with the server");
         }
         if (this.deps.validateAccessToken) {
             try {
@@ -107,9 +107,9 @@ export class ToolRegistry {
                 if (this.isCallToolResult(error)) {
                     return error;
                 }
-                return this.deps.errorHandler.createValidationError('Invalid parameters', error instanceof Error
+                return this.deps.errorHandler.createValidationError("Invalid parameters", error instanceof Error
                     ? error.message
-                    : 'Unknown error during default argument resolution');
+                    : "Unknown error during default argument resolution");
             }
         }
         const rawArguments = {
@@ -160,9 +160,9 @@ export class ToolRegistry {
         }
     }
     isCallToolResult(value) {
-        return (typeof value === 'object' &&
+        return (typeof value === "object" &&
             value !== null &&
-            'content' in value &&
+            "content" in value &&
             Array.isArray(value.content));
     }
     normalizeSecurityError(error, tool) {
@@ -170,18 +170,18 @@ export class ToolRegistry {
             const validationError = fromZodError(error);
             return this.deps.errorHandler.createValidationError(`Invalid parameters for ${tool.name}`, validationError.message);
         }
-        if (error instanceof Error && error.message.includes('Validation failed')) {
+        if (error instanceof Error && error.message.includes("Validation failed")) {
             return this.deps.errorHandler.createValidationError(`Invalid parameters for ${tool.name}`, error.message);
         }
         return this.deps.errorHandler.handleError(error, `executing ${tool.name}`);
     }
     extractMinifyOverride(options, args) {
-        if (typeof options.minifyOverride === 'boolean') {
+        if (typeof options.minifyOverride === "boolean") {
             return options.minifyOverride;
         }
         for (const key of MINIFY_HINT_KEYS) {
             const value = args[key];
-            if (typeof value === 'boolean') {
+            if (typeof value === "boolean") {
                 delete args[key];
                 return value;
             }
@@ -189,40 +189,41 @@ export class ToolRegistry {
         return undefined;
     }
     assertValidDefinition(definition) {
-        if (!definition || typeof definition !== 'object') {
-            throw new Error('Tool definition must be an object');
+        if (!definition || typeof definition !== "object") {
+            throw new Error("Tool definition must be an object");
         }
-        if (!definition.name || typeof definition.name !== 'string') {
-            throw new Error('Tool definition requires a non-empty name');
+        if (!definition.name || typeof definition.name !== "string") {
+            throw new Error("Tool definition requires a non-empty name");
         }
         if (!ToolRegistry.MCP_TOOL_NAME_REGEX.test(definition.name)) {
-            throw new Error(`Tool name '${definition.name}' violates MCP guidelines: ` +
-                `must be 1-128 chars using only [a-zA-Z0-9_.-]`);
+            throw new Error(`Tool name '${definition.name}' violates MCP guidelines: must be 1-128 chars using only [a-zA-Z0-9_.-]`);
         }
-        if (!definition.description || typeof definition.description !== 'string') {
+        if (!definition.description || typeof definition.description !== "string") {
             throw new Error(`Tool '${definition.name}' requires a description`);
         }
-        if (!definition.inputSchema || typeof definition.inputSchema.parse !== 'function') {
+        if (!definition.inputSchema ||
+            typeof definition.inputSchema.parse !== "function") {
             throw new Error(`Tool '${definition.name}' requires a valid Zod schema`);
         }
-        if (definition.outputSchema && typeof definition.outputSchema.parse !== 'function') {
+        if (definition.outputSchema &&
+            typeof definition.outputSchema.parse !== "function") {
             throw new Error(`Tool '${definition.name}' outputSchema must be a valid Zod schema when provided`);
         }
-        if (typeof definition.handler !== 'function') {
+        if (typeof definition.handler !== "function") {
             throw new Error(`Tool '${definition.name}' requires a handler function`);
         }
         if (definition.defaultArgumentResolver &&
-            typeof definition.defaultArgumentResolver !== 'function') {
+            typeof definition.defaultArgumentResolver !== "function") {
             throw new Error(`Tool '${definition.name}' defaultArgumentResolver must be a function when provided`);
         }
     }
-    generateJsonSchema(schema, ioMode = 'input') {
+    generateJsonSchema(schema, ioMode = "input") {
         try {
-            return toJSONSchema(schema, { target: 'draft-2020-12', io: ioMode });
+            return toJSONSchema(schema, { target: "draft-2020-12", io: ioMode });
         }
         catch (error) {
             console.warn(`Failed to generate JSON schema for tool: ${error}`);
-            return { type: 'object', additionalProperties: true };
+            return { type: "object", additionalProperties: true };
         }
     }
     validateOutput(toolName, output) {
@@ -231,18 +232,21 @@ export class ToolRegistry {
             return output;
         }
         if (!output.content || output.content.length === 0) {
-            return this.deps.errorHandler.createValidationError(`Output validation failed for ${toolName}`, 'Handler returned empty content', ['Ensure the handler returns valid content in the response']);
+            return this.deps.errorHandler.createValidationError(`Output validation failed for ${toolName}`, "Handler returned empty content", ["Ensure the handler returns valid content in the response"]);
         }
         const invalidItems = [];
         for (let i = 0; i < output.content.length; i++) {
             const item = output.content[i];
             if (!item) {
-                invalidItems.push({ index: i, reason: 'item is null or undefined' });
+                invalidItems.push({ index: i, reason: "item is null or undefined" });
             }
-            else if (item.type !== 'text') {
-                invalidItems.push({ index: i, reason: `type is "${item.type}" instead of "text"` });
+            else if (item.type !== "text") {
+                invalidItems.push({
+                    index: i,
+                    reason: `type is "${item.type}" instead of "text"`,
+                });
             }
-            else if (typeof item.text !== 'string') {
+            else if (typeof item.text !== "string") {
                 invalidItems.push({
                     index: i,
                     reason: `text property is ${typeof item.text} instead of string`,
@@ -252,27 +256,30 @@ export class ToolRegistry {
         if (invalidItems.length > 0) {
             const invalidItemsDetails = invalidItems
                 .map((inv) => `  - Item ${inv.index}: ${inv.reason}`)
-                .join('\n');
+                .join("\n");
             return this.deps.errorHandler.createValidationError(`Output validation failed for ${toolName}`, `Handler returned invalid content items (${invalidItems.length} of ${output.content.length} failed):\n${invalidItemsDetails}`, ['Ensure all content items have type="text" and a valid text property']);
         }
         const firstContent = output.content[0];
-        if (firstContent.type !== 'text') {
-            throw new Error('Unexpected: firstContent is not text after validation');
+        if (!firstContent) {
+            return this.deps.errorHandler.createValidationError(`Output validation failed for ${toolName}`, "Handler returned empty content", ["Ensure the handler returns valid content in the response"]);
+        }
+        if (firstContent.type !== "text") {
+            throw new Error("Unexpected: firstContent is not text after validation");
         }
         let parsedOutput;
         try {
             parsedOutput = JSON.parse(firstContent.text);
         }
         catch (parseError) {
-            return this.deps.errorHandler.createValidationError(`Output validation failed for ${toolName}`, `Invalid JSON in handler output: ${parseError instanceof Error ? parseError.message : String(parseError)}`, ['Ensure the handler returns valid JSON']);
+            return this.deps.errorHandler.createValidationError(`Output validation failed for ${toolName}`, `Invalid JSON in handler output: ${parseError instanceof Error ? parseError.message : String(parseError)}`, ["Ensure the handler returns valid JSON"]);
         }
         const result = validator.safeParse(parsedOutput);
         if (!result.success) {
             const validationError = fromZodError(result.error);
             const validationErrors = validationError.message;
             return this.deps.errorHandler.createValidationError(`Output validation failed for ${toolName}`, `Handler output does not match declared output schema: ${validationErrors}`, [
-                'Check that the handler returns data matching the output schema',
-                'Review the tool definition output schema',
+                "Check that the handler returns data matching the output schema",
+                "Review the tool definition output schema",
             ]);
         }
         return output;

package/dist/tools/__tests__/deltaTestUtils.d.ts

@@ -1,11 +1,11 @@
-import { vi } from 'vitest';
-import { DeltaFetcher } from '../deltaFetcher.js';
+import { vi } from "vitest";
+import { DeltaFetcher } from "../deltaFetcher.js";
 export interface MockDeltaResult<T> {
     data: T[];
     wasCached?: boolean;
     usedDelta?: boolean;
 }
-type DeltaFetcherMethod = 'fetchAccounts' | 'fetchBudgets' | 'fetchCategories' | 'fetchMonths';
+type DeltaFetcherMethod = "fetchAccounts" | "fetchBudgets" | "fetchCategories" | "fetchMonths";
 export declare function createDeltaFetcherMock<T>(method: DeltaFetcherMethod, result: MockDeltaResult<T>): {
     fetcher: DeltaFetcher;
     spy: ReturnType<typeof vi.fn>;

package/dist/tools/__tests__/deltaTestUtils.js

@@ -1,5 +1,5 @@
-import { vi } from 'vitest';
-import { DeltaFetcher } from '../deltaFetcher.js';
+import { vi } from "vitest";
+import { DeltaFetcher } from "../deltaFetcher.js";
 export function createDeltaFetcherMock(method, result) {
     const resolved = {
         wasCached: false,

package/dist/tools/accountTools.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 ListAccountsSchema: z.ZodObject<{
     budget_id: z.ZodString;
     limit: z.ZodOptional<z.ZodNumber>;
@@ -33,7 +34,7 @@ export declare const CreateAccountSchema: z.ZodObject<{
 export type CreateAccountParams = z.infer<typeof CreateAccountSchema>;
 export declare function handleListAccounts(ynabAPI: ynab.API, deltaFetcher: DeltaFetcher, params: ListAccountsParams): Promise<CallToolResult>;
 export declare function handleListAccounts(ynabAPI: ynab.API, params: ListAccountsParams): Promise<CallToolResult>;
-export declare function handleGetAccount(ynabAPI: ynab.API, params: GetAccountParams): Promise<CallToolResult>;
+export declare function handleGetAccount(ynabAPI: ynab.API, params: GetAccountParams, errorHandler?: ErrorHandler): Promise<CallToolResult>;
 export declare function handleCreateAccount(ynabAPI: ynab.API, deltaCache: DeltaCache, knowledgeStore: ServerKnowledgeStore, params: CreateAccountParams): Promise<CallToolResult>;
 export declare function handleCreateAccount(ynabAPI: ynab.API, params: CreateAccountParams): Promise<CallToolResult>;
 export declare const registerAccountTools: ToolFactory;

package/dist/tools/accountTools.js

@@ -1,42 +1,42 @@
-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 ListAccountsSchema = z
     .object({
-    budget_id: z.string().min(1, 'Budget ID is required'),
+    budget_id: z.string().min(1, "Budget ID is required"),
     limit: z.number().int().positive().optional(),
 })
     .strict();
 export const GetAccountSchema = z
     .object({
-    budget_id: z.string().min(1, 'Budget ID is required'),
-    account_id: z.string().min(1, 'Account ID is required'),
+    budget_id: z.string().min(1, "Budget ID is required"),
+    account_id: z.string().min(1, "Account ID is required"),
 })
     .strict();
 export const CreateAccountSchema = z
     .object({
-    budget_id: z.string().min(1, 'Budget ID is required'),
-    name: z.string().min(1, 'Account name is required'),
+    budget_id: z.string().min(1, "Budget ID is required"),
+    name: z.string().min(1, "Account name is required"),
     type: z.enum([
-        'checking',
-        'savings',
-        'creditCard',
-        'cash',
-        'lineOfCredit',
-        'otherAsset',
-        'otherLiability',
+        "checking",
+        "savings",
+        "creditCard",
+        "cash",
+        "lineOfCredit",
+        "otherAsset",
+        "otherLiability",
     ]),
     balance: z.number().optional(),
     dry_run: z.boolean().optional(),
 })
     .strict();
-export async function handleListAccounts(ynabAPI, deltaFetcherOrParams, maybeParams) {
+export async function handleListAccounts(ynabAPI, deltaFetcherOrParams, maybeParams, errorHandler) {
     const { deltaFetcher, params } = resolveDeltaFetcherArgs(ynabAPI, deltaFetcherOrParams, maybeParams);
     return await withToolErrorHandling(async () => {
         const result = await deltaFetcher.fetchAccounts(params.budget_id);
@@ -49,7 +49,7 @@ export async function handleListAccounts(ynabAPI, deltaFetcherOrParams, maybePar
         return {
             content: [
                 {
-                    type: 'text',
+                    type: "text",
                     text: responseFormatter.format({
                         accounts: accounts.map((account) => ({
                             id: account.id,
@@ -69,17 +69,17 @@ export async function handleListAccounts(ynabAPI, deltaFetcherOrParams, maybePar
                         returned_count: accounts.length,
                         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_accounts', 'listing accounts');
+    }, "ynab:list_accounts", "listing accounts", errorHandler);
 }
-export async function handleGetAccount(ynabAPI, params) {
+export async function handleGetAccount(ynabAPI, params, errorHandler) {
     return await withToolErrorHandling(async () => {
-        const cacheKey = CacheManager.generateKey(CacheKeys.ACCOUNTS, 'get', params.budget_id, params.account_id);
+        const cacheKey = CacheManager.generateKey(CacheKeys.ACCOUNTS, "get", params.budget_id, params.account_id);
         const wasCached = cacheManager.has(cacheKey);
         const account = await cacheManager.wrap(cacheKey, {
             ttl: CACHE_TTLS.ACCOUNTS,
@@ -91,7 +91,7 @@ export async function handleGetAccount(ynabAPI, params) {
         return {
             content: [
                 {
-                    type: 'text',
+                    type: "text",
                     text: responseFormatter.format({
                         account: {
                             id: account.id,
@@ -109,25 +109,25 @@ export async function handleGetAccount(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_account', 'getting account details');
+    }, "ynab:get_account", "getting account details", errorHandler);
 }
-export async function handleCreateAccount(ynabAPI, deltaCacheOrParams, knowledgeStoreOrParams, maybeParams) {
+export async function handleCreateAccount(ynabAPI, deltaCacheOrParams, knowledgeStoreOrParams, maybeParams, errorHandler) {
     const { deltaCache, params } = resolveDeltaWriteArgs(deltaCacheOrParams, knowledgeStoreOrParams, maybeParams);
     return await withToolErrorHandling(async () => {
         if (params.dry_run) {
             return {
                 content: [
                     {
-                        type: 'text',
+                        type: "text",
                         text: responseFormatter.format({
                             dry_run: true,
-                            action: 'create_account',
+                            action: "create_account",
                             request: {
                                 budget_id: params.budget_id,
                                 name: params.name,
@@ -148,13 +148,13 @@ export async function handleCreateAccount(ynabAPI, deltaCacheOrParams, knowledge
             account: accountData,
         });
         const account = response.data.account;
-        const accountsListCacheKey = CacheManager.generateKey(CacheKeys.ACCOUNTS, 'list', params.budget_id);
+        const accountsListCacheKey = CacheManager.generateKey(CacheKeys.ACCOUNTS, "list", params.budget_id);
         cacheManager.delete(accountsListCacheKey);
         deltaCache.invalidate(params.budget_id, CacheKeys.ACCOUNTS);
         return {
             content: [
                 {
-                    type: 'text',
+                    type: "text",
                     text: responseFormatter.format({
                         account: {
                             id: account.id,
@@ -174,47 +174,47 @@ export async function handleCreateAccount(ynabAPI, deltaCacheOrParams, knowledge
                 },
             ],
         };
-    }, 'ynab:create_account', 'creating account');
+    }, "ynab:create_account", "creating account", errorHandler);
 }
 export const registerAccountTools = (registry, context) => {
     const { adapt, adaptWithDelta, adaptWrite } = createAdapters(context);
     const budgetResolver = createBudgetResolver(context);
     registry.register({
-        name: 'list_accounts',
-        description: 'List all accounts for a specific budget',
+        name: "list_accounts",
+        description: "List all accounts for a specific budget",
         inputSchema: ListAccountsSchema,
         handler: adaptWithDelta(handleListAccounts),
         defaultArgumentResolver: budgetResolver(),
         metadata: {
             annotations: {
                 ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                title: 'YNAB: List Accounts',
+                title: "YNAB: List Accounts",
             },
         },
     });
     registry.register({
-        name: 'get_account',
-        description: 'Get detailed information for a specific account',
+        name: "get_account",
+        description: "Get detailed information for a specific account",
         inputSchema: GetAccountSchema,
         handler: adapt(handleGetAccount),
         defaultArgumentResolver: budgetResolver(),
         metadata: {
             annotations: {
                 ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                title: 'YNAB: Get Account Details',
+                title: "YNAB: Get Account Details",
             },
         },
     });
     registry.register({
-        name: 'create_account',
-        description: 'Create a new account in the specified budget',
+        name: "create_account",
+        description: "Create a new account in the specified budget",
         inputSchema: CreateAccountSchema,
         handler: adaptWrite(handleCreateAccount),
         defaultArgumentResolver: budgetResolver(),
         metadata: {
             annotations: {
                 ...ToolAnnotationPresets.WRITE_EXTERNAL_CREATE,
-                title: 'YNAB: Create Account',
+                title: "YNAB: Create Account",
             },
         },
     });