@dizzlkheinz/ynab-mcpb 0.12.2 → 0.15.0

package/src/server/toolRegistry.ts

@@ -1,5 +1,6 @@
 import type { CallToolResult, Tool } from '@modelcontextprotocol/sdk/types.js';
 import { z, toJSONSchema } from 'zod/v4';
+import { fromZodError } from 'zod-validation-error';
 import type { MCPToolAnnotations } from '../types/toolAnnotations.js';
 
 export type SecurityWrapperFactory = <T extends Record<string, unknown>>(
@@ -162,7 +163,10 @@ export class ToolRegistry {
         inputSchema,
       };
       if (tool.outputSchema) {
-        const outputSchema = this.generateJsonSchema(tool.outputSchema) as Tool['outputSchema'];
+        const outputSchema = this.generateJsonSchema(
+          tool.outputSchema,
+          'output',
+        ) as Tool['outputSchema'];
         result.outputSchema = outputSchema;
       }
       if (tool.metadata?.annotations) {
@@ -311,9 +315,10 @@ export class ToolRegistry {
     tool: RegisteredTool<Record<string, unknown>, Record<string, unknown>>,
   ): CallToolResult {
     if (error instanceof z.ZodError) {
+      const validationError = fromZodError(error);
       return this.deps.errorHandler.createValidationError(
         `Invalid parameters for ${tool.name}`,
-        error.message,
+        validationError.message,
       );
     }
 
@@ -388,9 +393,12 @@ export class ToolRegistry {
     }
   }
 
-  private generateJsonSchema(schema: z.ZodTypeAny): Record<string, unknown> {
+  private generateJsonSchema(
+    schema: z.ZodTypeAny,
+    ioMode: 'input' | 'output' = 'input',
+  ): Record<string, unknown> {
     try {
-      return toJSONSchema(schema, { target: 'draft-2020-12', io: 'output' });
+      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 };
@@ -467,12 +475,8 @@ export class ToolRegistry {
     // Validate against schema
     const result = validator.safeParse(parsedOutput);
     if (!result.success) {
-      const validationErrors = result.error.issues
-        .map((err) => {
-          const path = err.path.join('.');
-          return path ? `${path}: ${err.message}` : err.message;
-        })
-        .join('; ');
+      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}`,

package/src/tools/__tests__/categoryTools.test.ts

@@ -9,6 +9,7 @@ import {
   UpdateCategorySchema,
 } from '../categoryTools.js';
 import { createDeltaFetcherMock, createRejectingDeltaFetcherMock } from './deltaTestUtils.js';
+import { CacheKeys } from '../../server/cacheKeys.js';
 
 // Mock the cache manager
 vi.mock('../../server/cacheManager.js', () => ({
@@ -60,9 +61,22 @@ describe('Category Tools', () => {
       },
     );
     (cacheManager.has as ReturnType<typeof vi.fn>).mockReturnValue(false);
-    (CacheManager.generateKey as ReturnType<typeof vi.fn>).mockImplementation(
-      (prefix: string, ...parts: (string | number | boolean | undefined)[]) =>
-        [prefix, ...parts.filter((part) => part !== undefined)].join(':'),
+    (CacheManager.generateKey as any).mockImplementation(
+      (prefix: string, type: string, budgetId: string, id?: string) => {
+        if (prefix === CacheKeys.CATEGORIES && type === 'list') {
+          return `categories:list:${budgetId}`;
+        }
+        if (prefix === CacheKeys.CATEGORIES && type === 'get' && id) {
+          return `categories:get:${budgetId}:${id}`;
+        }
+        if (prefix === CacheKeys.MONTHS && type === 'list') {
+          return `months:list:${budgetId}`;
+        }
+        if (prefix === CacheKeys.MONTHS && type === 'get' && id) {
+          return `months:get:${budgetId}:${id}`;
+        }
+        return `${prefix}:${type}:${budgetId}:${id || ''}`;
+      },
     );
   });
 
@@ -450,34 +464,38 @@ describe('Category Tools', () => {
         data: { category: mockUpdatedCategory },
       });
 
-      const mockCacheKeys = [
-        'categories:list:budget-1:generated-key',
-        'category:get:budget-1:category-1:generated-key',
-      ];
-      (CacheManager.generateKey as any)
-        .mockReturnValueOnce(mockCacheKeys[0])
-        .mockReturnValueOnce(mockCacheKeys[1]);
-
-      const result = await handleUpdateCategory(mockYnabAPI, {
+      await handleUpdateCategory(mockYnabAPI, {
         budget_id: 'budget-1',
         category_id: 'category-1',
         budgeted: 60000,
       });
 
       // Verify cache was invalidated for both category list and specific category
-      expect(CacheManager.generateKey).toHaveBeenCalledWith('categories', 'list', 'budget-1');
       expect(CacheManager.generateKey).toHaveBeenCalledWith(
-        'category',
+        CacheKeys.CATEGORIES,
+        'list',
+        'budget-1',
+      );
+      expect(CacheManager.generateKey).toHaveBeenCalledWith(
+        CacheKeys.CATEGORIES,
         'get',
         'budget-1',
         'category-1',
       );
-      expect(cacheManager.delete).toHaveBeenCalledWith(mockCacheKeys[0]);
-      expect(cacheManager.delete).toHaveBeenCalledWith(mockCacheKeys[1]);
+      expect(cacheManager.delete).toHaveBeenCalledWith(`categories:list:budget-1`);
+      expect(cacheManager.delete).toHaveBeenCalledWith(`categories:get:budget-1:category-1`);
 
-      expect(result.content).toHaveLength(1);
-      const parsedContent = JSON.parse(result.content[0].text);
-      expect(parsedContent.category.budgeted).toBe(60);
+      // Verify month-related caches were invalidated
+      expect(CacheManager.generateKey).toHaveBeenCalledWith(CacheKeys.MONTHS, 'list', 'budget-1');
+      expect(CacheManager.generateKey).toHaveBeenCalledWith(
+        CacheKeys.MONTHS,
+        'get',
+        'budget-1',
+        expect.stringMatching(/^\d{4}-\d{2}-01$/),
+      );
+      const currentMonth = `${new Date().getFullYear()}-${String(new Date().getMonth() + 1).padStart(2, '0')}-01`;
+      expect(cacheManager.delete).toHaveBeenCalledWith(`months:list:budget-1`);
+      expect(cacheManager.delete).toHaveBeenCalledWith(`months:get:budget-1:${currentMonth}`);
     });
 
     it('should not invalidate cache on dry_run category update', async () => {

package/src/tools/__tests__/transactionTools.test.ts

@@ -352,6 +352,61 @@ describe('transactionTools', () => {
       const response = JSON.parse(result.content[0].text);
       expect(response.error.message).toBe('Failed to list transactions');
     });
+
+    it('should include cached property in large response path', async () => {
+      // Create large transaction list (> 90KB)
+      const largeTransactionList: ynab.TransactionDetail[] = [];
+      for (let i = 0; i < 5000; i++) {
+        largeTransactionList.push({
+          id: `transaction-${i}`,
+          date: '2025-01-01',
+          amount: -10000,
+          memo: 'Test transaction with long memo to increase size '.repeat(10),
+          cleared: 'cleared',
+          approved: true,
+          flag_color: null,
+          account_id: 'test-account',
+          payee_id: null,
+          category_id: null,
+          transfer_account_id: null,
+          transfer_transaction_id: null,
+          matched_transaction_id: null,
+          import_id: null,
+          import_payee_name: null,
+          import_payee_name_original: null,
+          debt_transaction_type: null,
+          deleted: false,
+          account_name: 'Test Account',
+          payee_name: 'Test Payee',
+          category_name: 'Test Category',
+          subtransactions: [],
+        } as ynab.TransactionDetail);
+      }
+
+      const mockResponse = {
+        data: {
+          transactions: largeTransactionList,
+        },
+      };
+
+      (mockYnabAPI.transactions.getTransactionsByAccount as any).mockResolvedValue(mockResponse);
+
+      const result = await handleListTransactions(mockYnabAPI, {
+        budget_id: 'test-budget',
+        account_id: 'test-account',
+      });
+
+      const content = result.content?.[0];
+      expect(content).toBeDefined();
+      expect(content?.type).toBe('text');
+
+      const parsedResponse = JSON.parse(content!.text);
+
+      // Should have cached property even in large response path
+      expect(parsedResponse.cached).toBeDefined();
+      expect(parsedResponse.cached).toBe(false);
+      expect(parsedResponse.cache_info).toBeDefined();
+    });
   });
 
   describe('GetTransactionSchema', () => {
@@ -1852,8 +1907,9 @@ describe('transactionTools', () => {
       const result = CreateTransactionsSchema.safeParse(params);
       expect(result.success).toBe(false);
       if (!result.success) {
-        const issue = result.error.issues.find((i) => i.path.includes('subtransactions'));
-        expect(issue?.message).toContain('Subtransactions are not supported');
+        const issue = result.error.issues.find((i) => i.code === 'unrecognized_keys');
+        expect(issue).toBeDefined();
+        expect((issue as any)?.keys).toContain('subtransactions');
       }
     });
 

package/src/tools/accountTools.ts

@@ -8,6 +8,7 @@ import { cacheManager, CACHE_TTLS, CacheManager } from '../server/cacheManager.j
 import type { DeltaFetcher } from './deltaFetcher.js';
 import type { DeltaCache } from '../server/deltaCache.js';
 import type { ServerKnowledgeStore } from '../server/serverKnowledgeStore.js';
+import { CacheKeys } from '../server/cacheKeys.js';
 import { resolveDeltaFetcherArgs, resolveDeltaWriteArgs } from './deltaSupport.js';
 
 /**
@@ -139,7 +140,7 @@ export async function handleGetAccount(
     async () => {
       // Use enhanced CacheManager wrap method
       const cacheKey = CacheManager.generateKey(
-        'account',
+        CacheKeys.ACCOUNTS,
         'get',
         params.budget_id,
         params.account_id,
@@ -248,10 +249,14 @@ export async function handleCreateAccount(
       const account = response.data.account;
 
       // Invalidate accounts list cache after successful account creation
-      const accountsListCacheKey = CacheManager.generateKey('accounts', 'list', params.budget_id);
+      const accountsListCacheKey = CacheManager.generateKey(
+        CacheKeys.ACCOUNTS,
+        'list',
+        params.budget_id,
+      );
       cacheManager.delete(accountsListCacheKey);
 
-      deltaCache.invalidate(params.budget_id, 'accounts');
+      deltaCache.invalidate(params.budget_id, CacheKeys.ACCOUNTS);
 
       return {
         content: [

package/src/tools/categoryTools.ts

@@ -8,6 +8,7 @@ import { cacheManager, CACHE_TTLS, CacheManager } from '../server/cacheManager.j
 import type { DeltaFetcher } from './deltaFetcher.js';
 import type { DeltaCache } from '../server/deltaCache.js';
 import type { ServerKnowledgeStore } from '../server/serverKnowledgeStore.js';
+import { CacheKeys } from '../server/cacheKeys.js';
 import { resolveDeltaFetcherArgs, resolveDeltaWriteArgs } from './deltaSupport.js';
 
 /**
@@ -158,7 +159,7 @@ export async function handleGetCategory(
     async () => {
       // Use enhanced CacheManager wrap method
       const cacheKey = CacheManager.generateKey(
-        'category',
+        CacheKeys.CATEGORIES,
         'get',
         params.budget_id,
         params.category_id,
@@ -271,9 +272,13 @@ export async function handleUpdateCategory(
     const category = response.data.category;
 
     // Invalidate category-related caches after successful update
-    const categoriesListCacheKey = CacheManager.generateKey('categories', 'list', params.budget_id);
+    const categoriesListCacheKey = CacheManager.generateKey(
+      CacheKeys.CATEGORIES,
+      'list',
+      params.budget_id,
+    );
     const specificCategoryCacheKey = CacheManager.generateKey(
-      'category',
+      CacheKeys.CATEGORIES,
       'get',
       params.budget_id,
       params.category_id,
@@ -282,9 +287,9 @@ export async function handleUpdateCategory(
     cacheManager.delete(specificCategoryCacheKey);
 
     // Invalidate month-related caches as category budget changes affect month data
-    const monthsListCacheKey = CacheManager.generateKey('months', 'list', params.budget_id);
+    const monthsListCacheKey = CacheManager.generateKey(CacheKeys.MONTHS, 'list', params.budget_id);
     const currentMonthCacheKey = CacheManager.generateKey(
-      'month',
+      CacheKeys.MONTHS,
       'get',
       params.budget_id,
       currentMonth,
@@ -292,8 +297,8 @@ export async function handleUpdateCategory(
     cacheManager.delete(monthsListCacheKey);
     cacheManager.delete(currentMonthCacheKey);
 
-    deltaCache.invalidate(params.budget_id, 'categories');
-    deltaCache.invalidate(params.budget_id, 'months');
+    deltaCache.invalidate(params.budget_id, CacheKeys.CATEGORIES);
+    deltaCache.invalidate(params.budget_id, CacheKeys.MONTHS);
     const serverKnowledge = response.data.server_knowledge;
     if (typeof serverKnowledge === 'number') {
       knowledgeStore.update(categoriesListCacheKey, serverKnowledge);

package/src/tools/monthTools.ts

@@ -6,6 +6,7 @@ import { responseFormatter } from '../server/responseFormatter.js';
 import { milliunitsToAmount } from '../utils/amountUtils.js';
 import { cacheManager, CACHE_TTLS, CacheManager } from '../server/cacheManager.js';
 import type { DeltaFetcher } from './deltaFetcher.js';
+import { CacheKeys } from '../server/cacheKeys.js';
 import { resolveDeltaFetcherArgs } from './deltaSupport.js';
 
 /**
@@ -42,7 +43,12 @@ export async function handleGetMonth(
   return await withToolErrorHandling(
     async () => {
       // Always use cache
-      const cacheKey = CacheManager.generateKey('month', '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<ynab.MonthDetail>(cacheKey, {
         ttl: CACHE_TTLS.MONTHS,

package/src/tools/payeeTools.ts

@@ -5,6 +5,7 @@ import { withToolErrorHandling } from '../types/index.js';
 import { responseFormatter } from '../server/responseFormatter.js';
 import { cacheManager, CACHE_TTLS, CacheManager } from '../server/cacheManager.js';
 import type { DeltaFetcher } from './deltaFetcher.js';
+import { CacheKeys } from '../server/cacheKeys.js';
 import { resolveDeltaFetcherArgs } from './deltaSupport.js';
 
 /**
@@ -104,7 +105,12 @@ export async function handleGetPayee(
   return await withToolErrorHandling(
     async () => {
       // Use enhanced CacheManager wrap method
-      const cacheKey = CacheManager.generateKey('payee', 'get', params.budget_id, params.payee_id);
+      const cacheKey = CacheManager.generateKey(
+        CacheKeys.PAYEES,
+        'get',
+        params.budget_id,
+        params.payee_id,
+      );
       const wasCached = cacheManager.has(cacheKey);
       const payee = await cacheManager.wrap<ynab.Payee>(cacheKey, {
         ttl: CACHE_TTLS.PAYEES,

package/src/tools/reconcileAdapter.ts

@@ -76,7 +76,7 @@ interface LegacyBalanceReconciliation {
 
 const toBankTransactionView = (txn: BankTransaction, currency: string) => ({
   ...txn,
-  amount_money: toMoneyValueFromDecimal(txn.amount, currency),
+  amount_money: toMoneyValue(txn.amount, currency),
 });
 
 const toYNABTransactionView = (txn: YNABTransaction, currency: string) => ({
@@ -85,15 +85,20 @@ const toYNABTransactionView = (txn: YNABTransaction, currency: string) => ({
 });
 
 const convertMatch = (match: TransactionMatch, currency: string) => ({
-  ...match,
-  bank_transaction: toBankTransactionView(match.bank_transaction, currency),
-  ynab_transaction: match.ynab_transaction
-    ? toYNABTransactionView(match.ynab_transaction, currency)
+  bank_transaction: toBankTransactionView(match.bankTransaction, currency),
+  ynab_transaction: match.ynabTransaction
+    ? toYNABTransactionView(match.ynabTransaction, currency)
     : undefined,
   candidates: match.candidates?.map((candidate) => ({
     ...candidate,
     ynab_transaction: toYNABTransactionView(candidate.ynab_transaction, currency),
   })),
+  confidence: match.confidence,
+  confidence_score: match.confidenceScore,
+  match_reason: match.matchReason,
+  top_confidence: match.topConfidence,
+  action_hint: match.actionHint,
+  recommendation: match.recommendation,
 });
 
 const convertInsight = (insight: ReconciliationInsight) => ({

package/src/tools/reconciliation/__tests__/adapter.test.ts

@@ -34,38 +34,41 @@ const buildAnalysis = (): ReconciliationAnalysis => ({
   },
   auto_matches: [
     {
-      bank_transaction: {
+      bankTransaction: {
         id: 'bank-1',
         date: '2025-10-15',
-        amount: -45.23,
+        amount: -45230,
         payee: 'Shell Gas',
-        original_csv_row: 2,
+        sourceRow: 2,
+        raw: { date: '2025-10-15', amount: '-45.23', description: 'Shell Gas' },
       },
-      ynab_transaction: {
+      ynabTransaction: {
         id: 'ynab-1',
         date: '2025-10-14',
         amount: -45230,
-        payee_name: 'Shell',
-        category_name: 'Auto',
+        payee: 'Shell',
+        categoryName: 'Auto',
         cleared: 'uncleared',
         approved: true,
+        memo: null,
       },
       candidates: [],
       confidence: 'high',
-      confidence_score: 97,
-      match_reason: 'exact_amount_and_date',
-      top_confidence: 97,
-      action_hint: 'mark_cleared',
+      confidenceScore: 97,
+      matchReason: 'exact_amount_and_date',
+      topConfidence: 97,
+      actionHint: 'mark_cleared',
     },
   ],
   suggested_matches: [
     {
-      bank_transaction: {
+      bankTransaction: {
         id: 'bank-2',
         date: '2025-10-20',
-        amount: -60,
+        amount: -60000,
         payee: 'Amazon',
-        original_csv_row: 5,
+        sourceRow: 5,
+        raw: { date: '2025-10-20', amount: '-60.00', description: 'Amazon' },
       },
       candidates: [
         {
@@ -73,10 +76,11 @@ const buildAnalysis = (): ReconciliationAnalysis => ({
             id: 'ynab-2',
             date: '2025-10-19',
             amount: -60000,
-            payee_name: 'Amazon Online',
-            category_name: 'Shopping',
+            payee: 'Amazon Online',
+            categoryName: 'Shopping',
             cleared: 'uncleared',
             approved: true,
+            memo: null,
           },
           confidence: 75,
           match_reason: 'amount_and_date_fuzzy_payee',
@@ -84,18 +88,19 @@ const buildAnalysis = (): ReconciliationAnalysis => ({
         },
       ],
       confidence: 'medium',
-      confidence_score: 75,
-      match_reason: 'amount_and_date_fuzzy_payee',
-      top_confidence: 75,
+      confidenceScore: 75,
+      matchReason: 'amount_and_date_fuzzy_payee',
+      topConfidence: 75,
     },
   ],
   unmatched_bank: [
     {
       id: 'bank-3',
       date: '2025-10-25',
-      amount: 22.22,
+      amount: 22220,
       payee: 'EvoCarShare',
-      original_csv_row: 7,
+      sourceRow: 7,
+      raw: { date: '2025-10-25', amount: '22.22', description: 'EvoCarShare' },
     },
   ],
   unmatched_ynab: [
@@ -103,10 +108,11 @@ const buildAnalysis = (): ReconciliationAnalysis => ({
       id: 'ynab-3',
       date: '2025-10-26',
       amount: -15000,
-      payee_name: 'Coffee Shop',
-      category_name: 'Dining',
+      payee: 'Coffee Shop',
+      categoryName: 'Dining',
       cleared: 'cleared',
       approved: true,
+      memo: null,
     },
   ],
   balance_info: {