@dizzlkheinz/ynab-mcpb 0.16.1 → 0.17.1

package/src/server/__tests__/toolRegistration.test.ts

@@ -0,0 +1,236 @@
+/**
+ * Unit tests for tool registration verification.
+ *
+ * Verifies that all expected tools are registered through the factory pattern
+ * and that tool metadata (annotations, schemas) are properly configured.
+ */
+import { describe, expect, it, vi } from 'vitest';
+
+// Mock config before importing YNABMCPServer
+vi.mock('../config.js', () => ({
+  loadConfig: () => ({
+    YNAB_ACCESS_TOKEN: 'test-token-for-registration-tests',
+    YNAB_DEFAULT_BUDGET_ID: undefined,
+    LOG_LEVEL: 'info',
+  }),
+  config: {
+    YNAB_ACCESS_TOKEN: 'test-token-for-registration-tests',
+    YNAB_DEFAULT_BUDGET_ID: undefined,
+    LOG_LEVEL: 'info',
+  },
+}));
+
+import { YNABMCPServer } from '../YNABMCPServer.js';
+
+const DEFAULT_BUDGET_ID = '11111111-1111-1111-1111-111111111111';
+
+/**
+ * Expected tool names organized by domain.
+ * This serves as the authoritative list of all 30 registered tools.
+ */
+const EXPECTED_TOOLS_BY_DOMAIN = {
+  budget: ['list_budgets', 'get_budget'],
+  account: ['list_accounts', 'get_account', 'create_account'],
+  transaction: [
+    'list_transactions',
+    'export_transactions',
+    'get_transaction',
+    'create_transaction',
+    'create_transactions',
+    'update_transaction',
+    'update_transactions',
+    'delete_transaction',
+    'create_receipt_split_transaction',
+  ],
+  category: ['list_categories', 'get_category', 'update_category'],
+  payee: ['list_payees', 'get_payee'],
+  month: ['get_month', 'list_months'],
+  reconciliation: ['compare_transactions', 'reconcile_account'],
+  utility: ['get_user'],
+  server: [
+    'set_default_budget',
+    'get_default_budget',
+    'clear_cache',
+    'diagnostic_info',
+    'set_output_format',
+  ],
+} as const;
+
+/** Flat list of all expected tool names */
+const ALL_EXPECTED_TOOLS = Object.values(EXPECTED_TOOLS_BY_DOMAIN).flat();
+
+/** Expected total tool count */
+const EXPECTED_TOOL_COUNT = 29;
+
+describe('Tool Registration', () => {
+  // Config is mocked at module level, no env setup needed
+
+  describe('Tool Count Verification', () => {
+    it('registers exactly 30 tools', () => {
+      const server = new YNABMCPServer(false);
+      const tools = server.getToolRegistry().listTools();
+      expect(tools).toHaveLength(EXPECTED_TOOL_COUNT);
+    });
+
+    it('registers all expected tools with correct names', () => {
+      const server = new YNABMCPServer(false);
+      const tools = server.getToolRegistry().listTools();
+      const toolNames = tools.map((t) => t.name).sort();
+      const expectedNames = [...ALL_EXPECTED_TOOLS].sort();
+
+      expect(toolNames).toEqual(expectedNames);
+    });
+  });
+
+  describe('Domain Tool Registration', () => {
+    it.each([
+      ['budget', EXPECTED_TOOLS_BY_DOMAIN.budget],
+      ['account', EXPECTED_TOOLS_BY_DOMAIN.account],
+      ['transaction', EXPECTED_TOOLS_BY_DOMAIN.transaction],
+      ['category', EXPECTED_TOOLS_BY_DOMAIN.category],
+      ['payee', EXPECTED_TOOLS_BY_DOMAIN.payee],
+      ['month', EXPECTED_TOOLS_BY_DOMAIN.month],
+      ['reconciliation', EXPECTED_TOOLS_BY_DOMAIN.reconciliation],
+      ['utility', EXPECTED_TOOLS_BY_DOMAIN.utility],
+      ['server', EXPECTED_TOOLS_BY_DOMAIN.server],
+    ])('registers all %s domain tools', (domain: string, expectedTools: readonly string[]) => {
+      const server = new YNABMCPServer(false);
+      const tools = server.getToolRegistry().listTools();
+      const toolNames = tools.map((t) => t.name);
+
+      for (const toolName of expectedTools) {
+        expect(toolNames, `Missing ${domain} tool: ${toolName}`).toContain(toolName);
+      }
+    });
+  });
+
+  describe('Tool Metadata Verification', () => {
+    it('has descriptions for all tools', () => {
+      const server = new YNABMCPServer(false);
+      const tools = server.getToolRegistry().listTools();
+
+      for (const tool of tools) {
+        expect(tool.description, `${tool.name} missing description`).toBeDefined();
+        expect(tool.description.length, `${tool.name} has empty description`).toBeGreaterThan(0);
+      }
+    });
+
+    it('has input schemas for all tools', () => {
+      const server = new YNABMCPServer(false);
+      const tools = server.getToolRegistry().listTools();
+
+      for (const tool of tools) {
+        expect(tool.inputSchema, `${tool.name} missing inputSchema`).toBeDefined();
+        expect(tool.inputSchema.type, `${tool.name} inputSchema not object type`).toBe('object');
+      }
+    });
+
+    it('has annotations for all tools', () => {
+      const server = new YNABMCPServer(false);
+      const tools = server.getToolRegistry().listTools();
+
+      for (const tool of tools) {
+        expect(tool.annotations, `${tool.name} missing annotations`).toBeDefined();
+        expect(tool.annotations, `${tool.name} missing title`).toHaveProperty('title');
+        expect(tool.annotations, `${tool.name} missing readOnlyHint`).toHaveProperty(
+          'readOnlyHint',
+        );
+        expect(tool.annotations, `${tool.name} missing openWorldHint`).toHaveProperty(
+          'openWorldHint',
+        );
+      }
+    });
+
+    it('has YNAB prefix in all tool titles', () => {
+      const server = new YNABMCPServer(false);
+      const tools = server.getToolRegistry().listTools();
+
+      for (const tool of tools) {
+        expect(tool.annotations?.title, `${tool.name} title should start with "YNAB:"`).toMatch(
+          /^YNAB:/,
+        );
+      }
+    });
+  });
+
+  describe('No Duplicate Tools', () => {
+    it('does not have duplicate tool names', () => {
+      const server = new YNABMCPServer(false);
+      const tools = server.getToolRegistry().listTools();
+      const toolNames = tools.map((t) => t.name);
+      const uniqueNames = new Set(toolNames);
+
+      expect(uniqueNames.size).toBe(toolNames.length);
+    });
+  });
+
+  describe('Factory Registration Completeness', () => {
+    it('does not have unexpected tools registered', () => {
+      const server = new YNABMCPServer(false);
+      const tools = server.getToolRegistry().listTools();
+      const toolNames = tools.map((t) => t.name);
+
+      const unexpectedTools = toolNames.filter((name) => !ALL_EXPECTED_TOOLS.includes(name));
+      expect(unexpectedTools, 'Unexpected tools found').toEqual([]);
+    });
+
+    it('does not have missing expected tools', () => {
+      const server = new YNABMCPServer(false);
+      const tools = server.getToolRegistry().listTools();
+      const toolNames = tools.map((t) => t.name);
+
+      const missingTools = ALL_EXPECTED_TOOLS.filter((name) => !toolNames.includes(name));
+      expect(missingTools, 'Missing expected tools').toEqual([]);
+    });
+  });
+
+  describe('Default Argument Resolution', () => {
+    it('applies defaultArgumentResolver when budget_id is omitted', () => {
+      const server = new YNABMCPServer(false);
+      server.setDefaultBudget(DEFAULT_BUDGET_ID);
+
+      const listAccounts = server
+        .getToolRegistry()
+        .getToolDefinitions()
+        .find((tool) => tool.name === 'list_accounts');
+
+      expect(listAccounts?.defaultArgumentResolver).toBeDefined();
+
+      const resolved = listAccounts?.defaultArgumentResolver?.({
+        name: 'list_accounts',
+        accessToken: 'token',
+        rawArguments: {},
+      });
+
+      expect(resolved).toEqual({ budget_id: DEFAULT_BUDGET_ID });
+    });
+
+    it('budget-dependent tools have defaultArgumentResolver', () => {
+      const server = new YNABMCPServer(false);
+      const definitions = server.getToolRegistry().getToolDefinitions();
+
+      // Tools that require budget_id should have resolvers
+      const budgetDependentTools = [
+        'list_accounts',
+        'get_account',
+        'create_account',
+        'list_transactions',
+        'get_transaction',
+        'list_categories',
+        'get_category',
+        'list_payees',
+        'get_payee',
+        'get_month',
+        'list_months',
+      ];
+
+      for (const toolName of budgetDependentTools) {
+        const tool = definitions.find((t) => t.name === toolName);
+        expect(
+          tool?.defaultArgumentResolver,
+          `${toolName} should have defaultArgumentResolver`,
+        ).toBeDefined();
+      }
+    });
+  });
+});

package/src/server/config.ts

@@ -5,6 +5,7 @@ import { ValidationError } from '../utils/errors.js';
 
 const envSchema = z.object({
   YNAB_ACCESS_TOKEN: z.string().trim().min(1, 'YNAB_ACCESS_TOKEN must be a non-empty string'),
+  YNAB_DEFAULT_BUDGET_ID: z.string().uuid('YNAB_DEFAULT_BUDGET_ID must be a valid UUID').optional(),
   MCP_PORT: z.coerce.number().int().positive().optional(),
   LOG_LEVEL: z.enum(['trace', 'debug', 'info', 'warn', 'error', 'fatal']).default('info'),
 });

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

@@ -0,0 +1,113 @@
+import { describe, expect, it, vi } from 'vitest';
+import { DefaultArgumentResolutionError } from '../../server/toolRegistry.js';
+import type { ToolContext } from '../../types/toolRegistration.js';
+import { createAdapters, createBudgetResolver } from '../adapters.js';
+
+const createMockContext = (overrides: Partial<ToolContext> = {}): ToolContext => {
+  return {
+    ynabAPI: (overrides.ynabAPI ?? ({ budgets: {} } as unknown as any)) as ToolContext['ynabAPI'],
+    deltaFetcher: overrides.deltaFetcher ?? ({} as any),
+    deltaCache: overrides.deltaCache ?? ({} as any),
+    serverKnowledgeStore: overrides.serverKnowledgeStore ?? ({} as any),
+    getDefaultBudgetId:
+      overrides.getDefaultBudgetId ?? vi.fn(() => '123e4567-e89b-12d3-a456-426614174000'),
+    setDefaultBudget: overrides.setDefaultBudget ?? vi.fn(),
+    cacheManager: overrides.cacheManager ?? ({} as any),
+    diagnosticManager: overrides.diagnosticManager,
+  } satisfies ToolContext;
+};
+
+describe('createAdapters', () => {
+  it('adapt passes api and params to handler', async () => {
+    const context = createMockContext();
+    const { adapt } = createAdapters(context);
+    const handler = vi.fn().mockResolvedValue({ content: [] });
+
+    const adapted = adapt(handler);
+    await adapted({ input: { foo: 'bar' }, context: {} as any });
+
+    expect(handler).toHaveBeenCalledWith(context.ynabAPI, { foo: 'bar' });
+  });
+
+  it('adaptNoInput passes api without params', async () => {
+    const context = createMockContext();
+    const { adaptNoInput } = createAdapters(context);
+    const handler = vi.fn().mockResolvedValue({ content: [] });
+
+    const adapted = adaptNoInput(handler);
+    await adapted({ input: {}, context: {} as any });
+
+    expect(handler).toHaveBeenCalledWith(context.ynabAPI);
+  });
+
+  it('adaptWithDelta passes deltaFetcher to handler', async () => {
+    const deltaFetcher = { fetch: vi.fn() } as any;
+    const context = createMockContext({ deltaFetcher });
+    const { adaptWithDelta } = createAdapters(context);
+    const handler = vi.fn().mockResolvedValue({ content: [] });
+
+    const adapted = adaptWithDelta(handler);
+    await adapted({ input: { a: 1 }, context: {} as any });
+
+    expect(handler).toHaveBeenCalledWith(context.ynabAPI, deltaFetcher, { a: 1 });
+  });
+
+  it('adaptWrite passes cache and knowledge store to handler', async () => {
+    const deltaCache = { invalidate: vi.fn() } as any;
+    const serverKnowledgeStore = { update: vi.fn() } as any;
+    const context = createMockContext({ deltaCache, serverKnowledgeStore });
+    const { adaptWrite } = createAdapters(context);
+    const handler = vi.fn().mockResolvedValue({ content: [] });
+
+    const adapted = adaptWrite(handler);
+    await adapted({ input: { a: 2 }, context: {} as any });
+
+    expect(handler).toHaveBeenCalledWith(context.ynabAPI, deltaCache, serverKnowledgeStore, {
+      a: 2,
+    });
+  });
+});
+
+describe('createBudgetResolver', () => {
+  it('returns provided budget_id when supplied', () => {
+    const context = createMockContext({ getDefaultBudgetId: () => 'default-budget' });
+    const resolverFactory = createBudgetResolver(context);
+    const resolver = resolverFactory<{ budget_id?: string }>();
+
+    const result = resolver({
+      name: 'tool',
+      accessToken: 'token',
+      rawArguments: { budget_id: '123e4567-e89b-12d3-a456-426614174000' },
+    });
+
+    expect(result).toEqual({ budget_id: '123e4567-e89b-12d3-a456-426614174000' });
+  });
+
+  it('falls back to default budget id when not provided', () => {
+    const context = createMockContext({
+      getDefaultBudgetId: () => '89abcdef-0123-4567-89ab-cdef01234567',
+    });
+    const resolver = createBudgetResolver(context)<{ budget_id?: string }>();
+
+    const result = resolver({
+      name: 'tool',
+      accessToken: 'token',
+      rawArguments: {},
+    });
+
+    expect(result).toEqual({ budget_id: '89abcdef-0123-4567-89ab-cdef01234567' });
+  });
+
+  it('throws DefaultArgumentResolutionError when no budget id available', () => {
+    const context = createMockContext({ getDefaultBudgetId: () => undefined });
+    const resolver = createBudgetResolver(context)<{ budget_id?: string }>();
+
+    expect(() =>
+      resolver({
+        name: 'tool',
+        accessToken: 'token',
+        rawArguments: {},
+      }),
+    ).toThrow(DefaultArgumentResolutionError);
+  });
+});

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

@@ -9,6 +9,7 @@ import {
   handleUpdateTransactions,
   CreateTransactionsSchema,
 } from '../transactionTools.js';
+import { waitFor } from '../../__tests__/testUtils.js';
 
 const isSkip = ['true', '1', 'yes', 'y', 'on'].includes(
   (process.env['SKIP_E2E_TESTS'] || '').toLowerCase().trim(),
@@ -325,9 +326,22 @@ describeIntegration('Transaction Tools Integration', () => {
           ],
         });
 
-        const afterList = await fetchBudgetTransactions();
-        const transactions =
-          afterList.transactions || afterList.preview_transactions || afterList.transaction_preview;
+        let transactions: any[] | undefined;
+        await waitFor(
+          async () => {
+            const afterList = await fetchBudgetTransactions();
+            transactions =
+              afterList.transactions ||
+              afterList.preview_transactions ||
+              afterList.transaction_preview;
+            return (
+              (transactions as any[])?.some((transaction) => transaction.memo === memo) ?? false
+            );
+          },
+          10000,
+          500,
+        );
+
         expect(transactions).toBeDefined();
         expect((transactions as any[]).some((transaction) => transaction.memo === memo)).toBe(true);
       },
@@ -576,6 +590,19 @@ describeIntegration('Transaction Tools Integration', () => {
         expect(updateResponse.results[1].correlation_key).toBe(transactionIds[1]);
 
         // Verify changes persisted
+        await waitFor(
+          async () => {
+            const getResult1 = await handleGetTransaction(ynabAPI, {
+              budget_id: testBudgetId,
+              transaction_id: transactionIds[0],
+            });
+            const transaction1 = parseToolResult(getResult1).transaction;
+            return transaction1.amount === -7.5 && transaction1.memo === 'Updated memo 1';
+          },
+          10000,
+          500,
+        );
+
         const getResult1 = await handleGetTransaction(ynabAPI, {
           budget_id: testBudgetId,
           transaction_id: transactionIds[0],
@@ -584,6 +611,19 @@ describeIntegration('Transaction Tools Integration', () => {
         expect(transaction1.amount).toBe(-7.5);
         expect(transaction1.memo).toBe('Updated memo 1');
 
+        await waitFor(
+          async () => {
+            const getResult2 = await handleGetTransaction(ynabAPI, {
+              budget_id: testBudgetId,
+              transaction_id: transactionIds[1],
+            });
+            const transaction2 = parseToolResult(getResult2).transaction;
+            return transaction2.memo === 'Updated memo 2' && transaction2.cleared === 'cleared';
+          },
+          10000,
+          500,
+        );
+
         const getResult2 = await handleGetTransaction(ynabAPI, {
           budget_id: testBudgetId,
           transaction_id: transactionIds[1],
@@ -635,6 +675,19 @@ describeIntegration('Transaction Tools Integration', () => {
         expect(updateResponse.summary.updated).toBe(1);
 
         // Verify change
+        await waitFor(
+          async () => {
+            const getResult = await handleGetTransaction(ynabAPI, {
+              budget_id: testBudgetId,
+              transaction_id: transactionId,
+            });
+            const transaction = parseToolResult(getResult).transaction;
+            return transaction.memo === 'Updated without metadata';
+          },
+          10000,
+          500,
+        );
+
         const getResult = await handleGetTransaction(ynabAPI, {
           budget_id: testBudgetId,
           transaction_id: transactionId,
@@ -749,6 +802,13 @@ describeIntegration('Transaction Tools Integration', () => {
         });
 
         const updateResponse = parseToolResult(updateResult);
+
+        if (updateResponse.error) {
+          throw new Error(
+            `Tool execution failed unexpectedly: ${JSON.stringify(updateResponse.error)}`,
+          );
+        }
+
         expect(updateResponse.summary.total_requested).toBe(2);
         expect(updateResponse.summary.updated).toBe(1);
         expect(updateResponse.summary.failed).toBeGreaterThan(0);

package/src/tools/__tests__/utilityTools.integration.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect, beforeAll } from 'vitest';
 import * as ynab from 'ynab';
-import { handleGetUser, handleConvertAmount } from '../utilityTools.js';
+import { handleGetUser } from '../utilityTools.js';
 import { skipOnRateLimit } from '../../__tests__/testUtils.js';
 
 /**
@@ -41,88 +41,4 @@ describeIntegration('Utility Tools Integration Tests', () => {
       },
     );
   });
-
-  describe('handleConvertAmount', () => {
-    it(
-      'should convert various dollar amounts to milliunits',
-      { meta: { tier: 'domain', domain: 'utility' } },
-      async () => {
-        const testCases = [
-          { dollars: 1.0, expectedMilliunits: 1000 },
-          { dollars: 0.01, expectedMilliunits: 10 },
-          { dollars: 10.5, expectedMilliunits: 10500 },
-          { dollars: 999.99, expectedMilliunits: 999990 },
-          { dollars: 0, expectedMilliunits: 0 },
-          { dollars: -5.25, expectedMilliunits: -5250 },
-        ];
-
-        for (const testCase of testCases) {
-          const result = await handleConvertAmount({
-            amount: testCase.dollars,
-            to_milliunits: true,
-          });
-          const response = JSON.parse(result.content[0].text);
-
-          expect(response.conversion.converted_amount).toBe(testCase.expectedMilliunits);
-          expect(response.conversion.to_milliunits).toBe(true);
-          expect(response.conversion.description).toContain(`$${testCase.dollars.toFixed(2)}`);
-          expect(response.conversion.description).toContain(
-            `${testCase.expectedMilliunits} milliunits`,
-          );
-        }
-      },
-    );
-
-    it(
-      'should convert various milliunit amounts to dollars',
-      { meta: { tier: 'domain', domain: 'utility' } },
-      async () => {
-        const testCases = [
-          { milliunits: 1000, expectedDollars: 1.0 },
-          { milliunits: 10, expectedDollars: 0.01 },
-          { milliunits: 10500, expectedDollars: 10.5 },
-          { milliunits: 999990, expectedDollars: 999.99 },
-          { milliunits: 0, expectedDollars: 0 },
-          { milliunits: -5250, expectedDollars: -5.25 },
-        ];
-
-        for (const testCase of testCases) {
-          const result = await handleConvertAmount({
-            amount: testCase.milliunits,
-            to_milliunits: false,
-          });
-          const response = JSON.parse(result.content[0].text);
-
-          expect(response.conversion.converted_amount).toBe(testCase.expectedDollars);
-          expect(response.conversion.to_milliunits).toBe(false);
-          expect(response.conversion.description).toContain(`${testCase.milliunits} milliunits`);
-          expect(response.conversion.description).toContain(
-            `$${testCase.expectedDollars.toFixed(2)}`,
-          );
-        }
-      },
-    );
-
-    it(
-      'should handle precision edge cases',
-      { meta: { tier: 'domain', domain: 'utility' } },
-      async () => {
-        // Test floating-point precision issues
-        const precisionTests = [
-          { amount: 0.1 + 0.2, to_milliunits: true }, // Should handle 0.30000000000000004
-          { amount: 1.005, to_milliunits: true }, // Should round correctly
-          { amount: 999.999, to_milliunits: true }, // Should handle near-integer values
-        ];
-
-        for (const test of precisionTests) {
-          const result = await handleConvertAmount(test);
-          const response = JSON.parse(result.content[0].text);
-
-          expect(response.conversion).toHaveProperty('converted_amount');
-          expect(typeof response.conversion.converted_amount).toBe('number');
-          expect(Number.isInteger(response.conversion.converted_amount)).toBe(true);
-        }
-      },
-    );
-  });
 });

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

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import * as ynab from 'ynab';
-import { handleGetUser, handleConvertAmount, ConvertAmountSchema } from '../utilityTools.js';
+import { handleGetUser } from '../utilityTools.js';
 
 // Mock the YNAB API
 const mockYnabAPI = {
@@ -80,126 +80,4 @@ describe('Utility Tools', () => {
       expect(result.content[0].text).toContain('Failed to get user information');
     });
   });
-
-  describe('handleConvertAmount', () => {
-    it('should convert dollars to milliunits correctly', async () => {
-      const params = { amount: 10.5, to_milliunits: true };
-
-      const result = await handleConvertAmount(params);
-      const response = JSON.parse(result.content[0].text);
-
-      expect(response.conversion.original_amount).toBe(10.5);
-      expect(response.conversion.converted_amount).toBe(10500);
-      expect(response.conversion.to_milliunits).toBe(true);
-      expect(response.conversion.description).toBe('$10.50 = 10500 milliunits');
-    });
-
-    it('should convert milliunits to dollars correctly', async () => {
-      const params = { amount: 10500, to_milliunits: false };
-
-      const result = await handleConvertAmount(params);
-      const response = JSON.parse(result.content[0].text);
-
-      expect(response.conversion.original_amount).toBe(10500);
-      expect(response.conversion.converted_amount).toBe(10.5);
-      expect(response.conversion.to_milliunits).toBe(false);
-      expect(response.conversion.description).toBe('10500 milliunits = $10.50');
-    });
-
-    it('should handle zero amounts', async () => {
-      const params = { amount: 0, to_milliunits: true };
-
-      const result = await handleConvertAmount(params);
-      const response = JSON.parse(result.content[0].text);
-
-      expect(response.conversion.original_amount).toBe(0);
-      expect(response.conversion.converted_amount).toBe(0);
-      expect(response.conversion.description).toBe('$0.00 = 0 milliunits');
-    });
-
-    it('should handle negative amounts', async () => {
-      const params = { amount: -5.25, to_milliunits: true };
-
-      const result = await handleConvertAmount(params);
-      const response = JSON.parse(result.content[0].text);
-
-      expect(response.conversion.original_amount).toBe(-5.25);
-      expect(response.conversion.converted_amount).toBe(-5250);
-      expect(response.conversion.description).toBe('$-5.25 = -5250 milliunits');
-    });
-
-    it('should handle floating-point precision correctly', async () => {
-      const params = { amount: 0.01, to_milliunits: true };
-
-      const result = await handleConvertAmount(params);
-      const response = JSON.parse(result.content[0].text);
-
-      expect(response.conversion.converted_amount).toBe(10);
-    });
-
-    it('should handle large amounts', async () => {
-      const params = { amount: 999999.99, to_milliunits: true };
-
-      const result = await handleConvertAmount(params);
-      const response = JSON.parse(result.content[0].text);
-
-      expect(response.conversion.converted_amount).toBe(999999990);
-    });
-
-    it('should round to nearest milliunit when converting from dollars', async () => {
-      const params = { amount: 10.5555, to_milliunits: true };
-
-      const result = await handleConvertAmount(params);
-      const response = JSON.parse(result.content[0].text);
-
-      expect(response.conversion.converted_amount).toBe(10556); // Rounded from 10555.5
-    });
-  });
-
-  describe('ConvertAmountSchema validation', () => {
-    it('should validate correct parameters', () => {
-      const validParams = { amount: 10.5, to_milliunits: true };
-      const result = ConvertAmountSchema.safeParse(validParams);
-
-      expect(result.success).toBe(true);
-      if (result.success) {
-        expect(result.data).toEqual(validParams);
-      }
-    });
-
-    it('should reject non-finite numbers', () => {
-      const invalidParams = { amount: Infinity, to_milliunits: true };
-      const result = ConvertAmountSchema.safeParse(invalidParams);
-
-      expect(result.success).toBe(false);
-    });
-
-    it('should reject NaN values', () => {
-      const invalidParams = { amount: NaN, to_milliunits: true };
-      const result = ConvertAmountSchema.safeParse(invalidParams);
-
-      expect(result.success).toBe(false);
-    });
-
-    it('should reject missing amount parameter', () => {
-      const invalidParams = { to_milliunits: true };
-      const result = ConvertAmountSchema.safeParse(invalidParams);
-
-      expect(result.success).toBe(false);
-    });
-
-    it('should reject missing to_milliunits parameter', () => {
-      const invalidParams = { amount: 10.5 };
-      const result = ConvertAmountSchema.safeParse(invalidParams);
-
-      expect(result.success).toBe(false);
-    });
-
-    it('should reject non-boolean to_milliunits parameter', () => {
-      const invalidParams = { amount: 10.5, to_milliunits: 'true' };
-      const result = ConvertAmountSchema.safeParse(invalidParams);
-
-      expect(result.success).toBe(false);
-    });
-  });
 });