@dizzlkheinz/ynab-mcpb 0.17.0 → 0.18.0

package/src/tools/reconciliation/__tests__/executor.progress.test.ts

@@ -0,0 +1,462 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type * as ynab from 'ynab';
+import type { ProgressCallback } from '../../../server/toolRegistry.js';
+import type { ReconciliationAnalysis, TransactionMatch, BankTransaction } from '../types.js';
+import type { ReconcileAccountRequest } from '../index.js';
+import { executeReconciliation, type ExecutionOptions } from '../executor.js';
+
+/**
+ * Unit tests for progress notification functionality in reconciliation executor
+ */
+describe('Reconciliation Progress Notifications', () => {
+  let mockYnabAPI: Partial<ynab.API>;
+  let mockProgressCallback: ProgressCallback;
+  let progressCalls: { progress: number; total?: number; message?: string }[];
+
+  const createMockTransaction = (
+    overrides: Partial<ynab.TransactionDetail> = {},
+  ): ynab.TransactionDetail => ({
+    id: 'txn-1',
+    date: '2024-01-15',
+    amount: -25000,
+    memo: 'Test transaction',
+    cleared: 'uncleared' as ynab.TransactionClearedStatus,
+    approved: true,
+    flag_color: null,
+    flag_name: null,
+    account_id: 'acc-1',
+    account_name: 'Test Account',
+    payee_id: 'payee-1',
+    payee_name: 'Test Payee',
+    category_id: 'cat-1',
+    category_name: 'Test Category',
+    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,
+    subtransactions: [],
+    ...overrides,
+  });
+
+  const createBankTransaction = (overrides: Partial<BankTransaction> = {}): BankTransaction => ({
+    date: '2024-01-15',
+    amount: -25000,
+    payee: 'Test Payee',
+    memo: 'Bank memo',
+    ...overrides,
+  });
+
+  const createMatch = (
+    bankTxn: BankTransaction,
+    ynabTxn: ynab.TransactionDetail,
+    score = 0.95,
+  ): TransactionMatch => ({
+    bankTransaction: bankTxn,
+    ynabTransaction: ynabTxn,
+    score,
+    matchType: 'exact',
+    matchDetails: {
+      amount_match: true,
+      date_match: true,
+      payee_similarity: 1.0,
+    },
+  });
+
+  beforeEach(() => {
+    progressCalls = [];
+    mockProgressCallback = vi.fn().mockImplementation(async (params) => {
+      progressCalls.push(params);
+    });
+
+    mockYnabAPI = {
+      transactions: {
+        createTransaction: vi.fn().mockResolvedValue({
+          data: { transaction: createMockTransaction() },
+        }),
+        createTransactions: vi.fn().mockResolvedValue({
+          data: {
+            transactions: [createMockTransaction()],
+            duplicate_import_ids: [],
+          },
+        }),
+        updateTransactions: vi.fn().mockResolvedValue({
+          data: { transactions: [createMockTransaction({ cleared: 'cleared' })] },
+        }),
+      } as unknown as ynab.TransactionsApi,
+      accounts: {
+        getAccountById: vi.fn().mockResolvedValue({
+          data: {
+            account: {
+              balance: 100000,
+              cleared_balance: 100000,
+              uncleared_balance: 0,
+            },
+          },
+        }),
+      } as unknown as ynab.AccountsApi,
+    };
+  });
+
+  describe('progress callback invocation', () => {
+    it('should call progress callback during bulk transaction creation', async () => {
+      const unmatchedBank: BankTransaction[] = [
+        createBankTransaction({ payee: 'Payee 1', amount: -10000 }),
+        createBankTransaction({ payee: 'Payee 2', amount: -20000 }),
+        createBankTransaction({ payee: 'Payee 3', amount: -30000 }),
+      ];
+
+      const analysis: ReconciliationAnalysis = {
+        summary: {
+          bank_transactions_count: 3,
+          ynab_transactions_count: 0,
+          matches: 0,
+          unmatched_bank: 3,
+          unmatched_ynab: 0,
+          match_rate: 0,
+          statement_date_range: '2024-01-01 to 2024-01-31',
+        },
+        auto_matches: [],
+        unmatched_bank: unmatchedBank,
+        unmatched_ynab: [],
+        balance_info: {
+          current_cleared: 100000,
+          target_statement: 40000,
+        },
+      };
+
+      const params: ReconcileAccountRequest = {
+        account_id: 'acc-1',
+        csv_data: 'date,amount,payee\n2024-01-15,-10,Payee 1',
+        dry_run: false,
+        auto_create_transactions: true,
+      };
+
+      const options: ExecutionOptions = {
+        ynabAPI: mockYnabAPI as ynab.API,
+        analysis,
+        params,
+        budgetId: 'budget-1',
+        accountId: 'acc-1',
+        initialAccount: { balance: 100000, cleared_balance: 100000, uncleared_balance: 0 },
+        currencyCode: 'USD',
+        sendProgress: mockProgressCallback,
+      };
+
+      await executeReconciliation(options);
+
+      expect(mockProgressCallback).toHaveBeenCalled();
+      expect(progressCalls.length).toBeGreaterThan(0);
+
+      // Verify progress structure
+      for (const call of progressCalls) {
+        expect(call).toHaveProperty('progress');
+        expect(call).toHaveProperty('total');
+        expect(call).toHaveProperty('message');
+        expect(typeof call.progress).toBe('number');
+        expect(typeof call.total).toBe('number');
+      }
+    });
+
+    it('should report progress during sequential fallback', async () => {
+      const unmatchedBank: BankTransaction[] = [
+        createBankTransaction({ payee: 'Single Payee', amount: -10000 }),
+      ];
+
+      const analysis: ReconciliationAnalysis = {
+        summary: {
+          bank_transactions_count: 1,
+          ynab_transactions_count: 0,
+          matches: 0,
+          unmatched_bank: 1,
+          unmatched_ynab: 0,
+          match_rate: 0,
+          statement_date_range: '2024-01-01 to 2024-01-31',
+        },
+        auto_matches: [],
+        unmatched_bank: unmatchedBank,
+        unmatched_ynab: [],
+        balance_info: {
+          current_cleared: 100000,
+          target_statement: 90000,
+        },
+      };
+
+      const params: ReconcileAccountRequest = {
+        account_id: 'acc-1',
+        csv_data: 'date,amount,payee\n2024-01-15,-10,Single Payee',
+        dry_run: false,
+        auto_create_transactions: true,
+      };
+
+      const options: ExecutionOptions = {
+        ynabAPI: mockYnabAPI as ynab.API,
+        analysis,
+        params,
+        budgetId: 'budget-1',
+        accountId: 'acc-1',
+        initialAccount: { balance: 100000, cleared_balance: 100000, uncleared_balance: 0 },
+        currencyCode: 'USD',
+        sendProgress: mockProgressCallback,
+      };
+
+      await executeReconciliation(options);
+
+      // With only 1 transaction, it goes through sequential path
+      expect(mockProgressCallback).toHaveBeenCalled();
+    });
+
+    it('should not call progress callback when not provided', async () => {
+      const analysis: ReconciliationAnalysis = {
+        summary: {
+          bank_transactions_count: 1,
+          ynab_transactions_count: 0,
+          matches: 0,
+          unmatched_bank: 1,
+          unmatched_ynab: 0,
+          match_rate: 0,
+          statement_date_range: '2024-01-01 to 2024-01-31',
+        },
+        auto_matches: [],
+        unmatched_bank: [createBankTransaction()],
+        unmatched_ynab: [],
+        balance_info: {
+          current_cleared: 100000,
+          target_statement: 75000,
+        },
+      };
+
+      const params: ReconcileAccountRequest = {
+        account_id: 'acc-1',
+        csv_data: 'date,amount,payee\n2024-01-15,-25,Test',
+        dry_run: false,
+        auto_create_transactions: true,
+      };
+
+      const options: ExecutionOptions = {
+        ynabAPI: mockYnabAPI as ynab.API,
+        analysis,
+        params,
+        budgetId: 'budget-1',
+        accountId: 'acc-1',
+        initialAccount: { balance: 100000, cleared_balance: 100000, uncleared_balance: 0 },
+        currencyCode: 'USD',
+        // No sendProgress callback
+      };
+
+      // Should not throw when no callback provided
+      await expect(executeReconciliation(options)).resolves.toBeDefined();
+    });
+
+    it('should report progress during transaction updates', async () => {
+      const ynabTxn = createMockTransaction({ cleared: 'uncleared' });
+      const bankTxn = createBankTransaction();
+      const match = createMatch(bankTxn, ynabTxn);
+
+      const analysis: ReconciliationAnalysis = {
+        summary: {
+          bank_transactions_count: 1,
+          ynab_transactions_count: 1,
+          matches: 1,
+          unmatched_bank: 0,
+          unmatched_ynab: 0,
+          match_rate: 1,
+          statement_date_range: '2024-01-01 to 2024-01-31',
+        },
+        auto_matches: [match],
+        unmatched_bank: [],
+        unmatched_ynab: [],
+        balance_info: {
+          current_cleared: 75000,
+          target_statement: 100000,
+        },
+      };
+
+      const params: ReconcileAccountRequest = {
+        account_id: 'acc-1',
+        csv_data: 'date,amount,payee\n2024-01-15,-25,Test',
+        dry_run: false,
+        auto_update_cleared_status: true,
+      };
+
+      const options: ExecutionOptions = {
+        ynabAPI: mockYnabAPI as ynab.API,
+        analysis,
+        params,
+        budgetId: 'budget-1',
+        accountId: 'acc-1',
+        initialAccount: { balance: 100000, cleared_balance: 75000, uncleared_balance: 25000 },
+        currencyCode: 'USD',
+        sendProgress: mockProgressCallback,
+      };
+
+      await executeReconciliation(options);
+
+      expect(mockProgressCallback).toHaveBeenCalled();
+    });
+  });
+
+  describe('progress calculation accuracy', () => {
+    it('should exclude skipped matches from total count', async () => {
+      // Create a match that won't need updating (already cleared, same date)
+      const clearedTxn = createMockTransaction({ cleared: 'cleared' });
+      const bankTxn = createBankTransaction();
+      const matchNoUpdate = createMatch(bankTxn, clearedTxn);
+
+      // Create a match that will need updating
+      const unclearedTxn = createMockTransaction({ cleared: 'uncleared', id: 'txn-2' });
+      const bankTxn2 = createBankTransaction({ payee: 'Payee 2' });
+      const matchNeedsUpdate = createMatch(bankTxn2, unclearedTxn);
+
+      const analysis: ReconciliationAnalysis = {
+        summary: {
+          bank_transactions_count: 2,
+          ynab_transactions_count: 2,
+          matches: 2,
+          unmatched_bank: 0,
+          unmatched_ynab: 0,
+          match_rate: 1,
+          statement_date_range: '2024-01-01 to 2024-01-31',
+        },
+        auto_matches: [matchNoUpdate, matchNeedsUpdate],
+        unmatched_bank: [],
+        unmatched_ynab: [],
+        balance_info: {
+          current_cleared: 75000,
+          target_statement: 100000,
+        },
+      };
+
+      const params: ReconcileAccountRequest = {
+        account_id: 'acc-1',
+        csv_data: 'date,amount,payee\n2024-01-15,-25,Test',
+        dry_run: false,
+        auto_update_cleared_status: true,
+      };
+
+      const options: ExecutionOptions = {
+        ynabAPI: mockYnabAPI as ynab.API,
+        analysis,
+        params,
+        budgetId: 'budget-1',
+        accountId: 'acc-1',
+        initialAccount: { balance: 100000, cleared_balance: 75000, uncleared_balance: 25000 },
+        currencyCode: 'USD',
+        sendProgress: mockProgressCallback,
+      };
+
+      await executeReconciliation(options);
+
+      // The total should only count the match that needs updating (1), not both (2)
+      if (progressCalls.length > 0) {
+        const lastCall = progressCalls[progressCalls.length - 1]!;
+        // Total should be 1 (only the uncleared transaction needs updating)
+        expect(lastCall.total).toBe(1);
+      }
+    });
+
+    it('should include all operation types in total count', async () => {
+      const unmatchedBank = [createBankTransaction({ payee: 'New Payee' })];
+      const unclearedTxn = createMockTransaction({ cleared: 'uncleared' });
+      const matchNeedsUpdate = createMatch(createBankTransaction(), unclearedTxn);
+      const unmatchedYnab = [createMockTransaction({ id: 'unmatched-ynab', cleared: 'cleared' })];
+
+      const analysis: ReconciliationAnalysis = {
+        summary: {
+          bank_transactions_count: 2,
+          ynab_transactions_count: 2,
+          matches: 1,
+          unmatched_bank: 1,
+          unmatched_ynab: 1,
+          match_rate: 0.5,
+          statement_date_range: '2024-01-01 to 2024-01-31',
+        },
+        auto_matches: [matchNeedsUpdate],
+        unmatched_bank: unmatchedBank,
+        unmatched_ynab: unmatchedYnab,
+        balance_info: {
+          current_cleared: 75000,
+          target_statement: 50000,
+        },
+      };
+
+      const params: ReconcileAccountRequest = {
+        account_id: 'acc-1',
+        csv_data: 'date,amount,payee\n2024-01-15,-25,Test',
+        dry_run: false,
+        auto_create_transactions: true,
+        auto_update_cleared_status: true,
+        auto_unclear_missing: true,
+      };
+
+      const options: ExecutionOptions = {
+        ynabAPI: mockYnabAPI as ynab.API,
+        analysis,
+        params,
+        budgetId: 'budget-1',
+        accountId: 'acc-1',
+        initialAccount: { balance: 100000, cleared_balance: 75000, uncleared_balance: 25000 },
+        currencyCode: 'USD',
+        sendProgress: mockProgressCallback,
+      };
+
+      await executeReconciliation(options);
+
+      // Total should be: 1 (create) + 1 (update match) + 1 (unclear) = 3
+      if (progressCalls.length > 0) {
+        const anyCall = progressCalls.find((c) => c.total !== undefined);
+        expect(anyCall?.total).toBe(3);
+      }
+    });
+  });
+
+  describe('dry run behavior', () => {
+    it('should not call progress callback during dry run', async () => {
+      const analysis: ReconciliationAnalysis = {
+        summary: {
+          bank_transactions_count: 1,
+          ynab_transactions_count: 0,
+          matches: 0,
+          unmatched_bank: 1,
+          unmatched_ynab: 0,
+          match_rate: 0,
+          statement_date_range: '2024-01-01 to 2024-01-31',
+        },
+        auto_matches: [],
+        unmatched_bank: [createBankTransaction()],
+        unmatched_ynab: [],
+        balance_info: {
+          current_cleared: 100000,
+          target_statement: 75000,
+        },
+      };
+
+      const params: ReconcileAccountRequest = {
+        account_id: 'acc-1',
+        csv_data: 'date,amount,payee\n2024-01-15,-25,Test',
+        dry_run: true, // Dry run mode
+        auto_create_transactions: true,
+      };
+
+      const options: ExecutionOptions = {
+        ynabAPI: mockYnabAPI as ynab.API,
+        analysis,
+        params,
+        budgetId: 'budget-1',
+        accountId: 'acc-1',
+        initialAccount: { balance: 100000, cleared_balance: 100000, uncleared_balance: 0 },
+        currencyCode: 'USD',
+        sendProgress: mockProgressCallback,
+      };
+
+      await executeReconciliation(options);
+
+      // In dry run, no actual operations happen, so no progress should be reported
+      // (Progress is only reported after successful API calls)
+      expect(mockYnabAPI.transactions?.createTransaction).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/tools/reconciliation/executor.ts

@@ -2,6 +2,7 @@ import { createHash } from 'crypto';
 import type * as ynab from 'ynab';
 import type { SaveTransaction } from 'ynab/dist/models/SaveTransaction.js';
 import { YNABAPIError, YNABErrorCode } from '../../server/errorHandler.js';
+import type { ProgressCallback } from '../../server/toolRegistry.js';
 import { toMilli, toMoneyValue, addMilli } from '../../utils/money.js';
 import type { ReconciliationAnalysis, TransactionMatch, BankTransaction } from './types.js';
 import type { ReconcileAccountRequest } from './index.js';
@@ -25,6 +26,11 @@ export interface ExecutionOptions {
   accountId: string;
   initialAccount: AccountSnapshot;
   currencyCode: string;
+  /**
+   * Optional progress callback for emitting MCP progress notifications.
+   * When provided, progress updates are sent during bulk operations.
+   */
+  sendProgress?: ProgressCallback;
 }
 
 export interface ExecutionActionRecord {
@@ -197,7 +203,16 @@ function isWithinStatementWindow(dateStr: string, window: StatementWindow): bool
 }
 
 export async function executeReconciliation(options: ExecutionOptions): Promise<ExecutionResult> {
-  const { analysis, params, ynabAPI, budgetId, accountId, initialAccount, currencyCode } = options;
+  const {
+    analysis,
+    params,
+    ynabAPI,
+    budgetId,
+    accountId,
+    initialAccount,
+    currencyCode,
+    sendProgress,
+  } = options;
   const actions_taken: ExecutionActionRecord[] = [];
 
   const summary: ExecutionSummary = {
@@ -212,6 +227,29 @@ export async function executeReconciliation(options: ExecutionOptions): Promise<
     dry_run: params.dry_run,
   };
 
+  // Progress tracking for MCP notifications
+  // Pre-filter matches to only count those that will actually be updated
+  // This ensures accurate progress percentages (skipped matches don't inflate total)
+  const matchesNeedingUpdate = analysis.auto_matches.filter((match) => {
+    const flags = computeUpdateFlags(match, params);
+    return flags.needsClearedUpdate || flags.needsDateUpdate;
+  });
+  const totalOperations =
+    (params.auto_create_transactions ? analysis.unmatched_bank.length : 0) +
+    matchesNeedingUpdate.length +
+    (params.auto_unclear_missing ? analysis.unmatched_ynab.length : 0);
+  let completedOperations = 0;
+
+  const reportProgress = async (message: string): Promise<void> => {
+    if (sendProgress && totalOperations > 0) {
+      await sendProgress({
+        progress: completedOperations,
+        total: totalOperations,
+        message,
+      });
+    }
+  };
+
   let afterAccount: AccountSnapshot = { ...initialAccount };
   let accountSnapshotDirty = false;
   const statementTargetMilli = resolveStatementBalanceMilli(
@@ -336,6 +374,9 @@ export async function executeReconciliation(options: ExecutionOptions): Promise<
           recordCreateAction(recordArgs);
           accountSnapshotDirty = true;
           applyClearedDelta(entry.amountMilli);
+          // Report progress for sequential/fallback operations
+          completedOperations += 1;
+          await reportProgress(`Created ${completedOperations} of ${totalOperations} transactions`);
           const trigger = options.chunkIndex
             ? `creating ${entry.bankTransaction.payee ?? 'missing transaction'} (chunk ${options.chunkIndex})`
             : `creating ${entry.bankTransaction.payee ?? 'missing transaction'}`;
@@ -496,6 +537,11 @@ export async function executeReconciliation(options: ExecutionOptions): Promise<
           try {
             await processBulkChunk(chunk, chunkIndex);
             bulkOperationDetails.bulk_successes += 1;
+            // Report progress after successful chunk processing
+            completedOperations += chunk.length;
+            await reportProgress(
+              `Created ${completedOperations} of ${totalOperations} transactions`,
+            );
           } catch (error) {
             const ynabError = normalizeYnabError(error);
             const failureReason = ynabError.message || 'unknown error';
@@ -619,6 +665,9 @@ export async function executeReconciliation(options: ExecutionOptions): Promise<
             });
           }
           accountSnapshotDirty = true;
+          // Report progress after successful batch update
+          completedOperations += updatedTransactions.length;
+          await reportProgress(`Updated ${completedOperations} of ${totalOperations} transactions`);
         } catch (error) {
           const ynabError = normalizeYnabError(error);
           const failureReason = ynabError.message || 'Unknown error occurred';
@@ -724,6 +773,11 @@ export async function executeReconciliation(options: ExecutionOptions): Promise<
             });
           }
           accountSnapshotDirty = true;
+          // Report progress after successful unclear batch
+          completedOperations += updatedTransactions.length;
+          await reportProgress(
+            `Marked ${completedOperations} of ${totalOperations} transactions uncleared`,
+          );
         } catch (error) {
           const ynabError = normalizeYnabError(error);
           const failureReason = ynabError.message || 'Unknown error occurred';

package/src/tools/reconciliation/index.ts

@@ -6,7 +6,8 @@
 import { promises as fs } from 'fs';
 import { z } from 'zod/v4';
 import type * as ynab from 'ynab';
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ProgressCallback } from '../../server/toolRegistry.js';
 import { withToolErrorHandling } from '../../types/index.js';
 import type { ToolFactory } from '../../types/toolRegistration.js';
 import { createAdapters, createBudgetResolver } from '../adapters.js';
@@ -151,6 +152,7 @@ export async function handleReconcileAccount(
   ynabAPI: ynab.API,
   deltaFetcher: DeltaFetcher,
   params: ReconcileAccountRequest,
+  sendProgress?: ProgressCallback,
 ): Promise<CallToolResult>;
 export async function handleReconcileAccount(
   ynabAPI: ynab.API,
@@ -160,6 +162,7 @@ export async function handleReconcileAccount(
   ynabAPI: ynab.API,
   deltaFetcherOrParams: DeltaFetcher | ReconcileAccountRequest,
   maybeParams?: ReconcileAccountRequest,
+  sendProgress?: ProgressCallback,
 ): Promise<CallToolResult> {
   const { deltaFetcher, params } = resolveDeltaFetcherArgs(
     ynabAPI,
@@ -419,6 +422,7 @@ export async function handleReconcileAccount(
           accountId: params.account_id,
           initialAccount,
           currencyCode,
+          ...(sendProgress !== undefined && { sendProgress }),
         });
       }
 
@@ -468,7 +472,7 @@ export async function handleReconcileAccount(
  * Registers reconciliation-domain tools (compare + reconcile) with the registry.
  */
 export const registerReconciliationTools: ToolFactory = (registry, context) => {
-  const { adapt, adaptWithDelta } = createAdapters(context);
+  const { adapt, adaptWithDeltaAndProgress } = createAdapters(context);
   const budgetResolver = createBudgetResolver(context);
 
   registry.register({
@@ -491,7 +495,7 @@ export const registerReconciliationTools: ToolFactory = (registry, context) => {
     description:
       'Guided reconciliation workflow with human narrative, insight detection, and optional execution (create/update/unclear). Set include_structured_data=true to also get full JSON output (large).',
     inputSchema: ReconcileAccountSchema,
-    handler: adaptWithDelta(handleReconcileAccount),
+    handler: adaptWithDeltaAndProgress(handleReconcileAccount),
     defaultArgumentResolver: budgetResolver<z.infer<typeof ReconcileAccountSchema>>(),
     metadata: {
       annotations: {

package/src/tools/schemas/outputs/index.ts

@@ -25,8 +25,6 @@
 export {
   GetUserOutputSchema,
   type GetUserOutput,
-  ConvertAmountOutputSchema,
-  type ConvertAmountOutput,
   GetDefaultBudgetOutputSchema,
   type GetDefaultBudgetOutput,
   SetDefaultBudgetOutputSchema,
@@ -44,7 +42,6 @@ export {
 // Nested schemas that may be useful independently
 export {
   UserSchema,
-  ConversionSchema,
   DateFormatSchema,
   CurrencyFormatSchema,
   BudgetDetailSchema,

package/src/tools/schemas/outputs/utilityOutputs.ts

@@ -2,8 +2,8 @@
  * @fileoverview Output schemas for utility tools
  *
  * This file contains comprehensive Zod schemas for validating the output
- * of utility tools including user info, amount conversion, budget defaults,
- * cache management, output formatting, and diagnostic information.
+ * of utility tools including user info, budget defaults, cache management,
+ * output formatting, and diagnostic information.
  *
  * All schemas include TypeScript type inference for type-safe usage throughout
  * the codebase. Reference the corresponding handler implementations for
@@ -46,47 +46,6 @@ export const GetUserOutputSchema = z.object({
 
 export type GetUserOutput = z.infer<typeof GetUserOutputSchema>;
 
-// ============================================================================
-// CONVERT AMOUNT OUTPUT
-// ============================================================================
-
-/**
- * Schema for amount conversion details
- *
- * Contains the conversion result between dollars and YNAB milliunits.
- */
-export const ConversionSchema = z.object({
-  original_amount: z.number(),
-  converted_amount: z.number(),
-  to_milliunits: z.boolean(),
-  description: z.string(),
-});
-
-/**
- * Output schema for convert_amount tool
- *
- * Converts between dollars and YNAB milliunits (1 dollar = 1000 milliunits).
- *
- * @see src/tools/utilityTools.ts:51-90 - Handler implementation
- *
- * @example
- * ```typescript
- * const output: ConvertAmountOutput = {
- *   conversion: {
- *     original_amount: 25.50,
- *     converted_amount: 25500,
- *     to_milliunits: true,
- *     description: "$25.50 converted to 25500 milliunits"
- *   }
- * };
- * ```
- */
-export const ConvertAmountOutputSchema = z.object({
-  conversion: ConversionSchema,
-});
-
-export type ConvertAmountOutput = z.infer<typeof ConvertAmountOutputSchema>;
-
 // ============================================================================
 // GET DEFAULT BUDGET OUTPUT
 // ============================================================================