@dizzlkheinz/ynab-mcpb 0.16.0 → 0.17.0

package/dist/server/YNABMCPServer.js

@@ -11,19 +11,18 @@ import { loadConfig } from './config.js';
 import { createErrorHandler, ErrorHandler } from './errorHandler.js';
 import { BudgetResolver } from './budgetResolver.js';
 import { SecurityMiddleware, withSecurityWrapper } from './securityMiddleware.js';
-import { handleListBudgets, handleGetBudget, GetBudgetSchema } from '../tools/budgetTools.js';
-import { handleListAccounts, handleGetAccount, handleCreateAccount, ListAccountsSchema, GetAccountSchema, CreateAccountSchema, } from '../tools/accountTools.js';
-import { handleListTransactions, handleGetTransaction, handleCreateTransaction, handleCreateTransactions, handleCreateReceiptSplitTransaction, handleUpdateTransaction, handleUpdateTransactions, handleDeleteTransaction, ListTransactionsSchema, GetTransactionSchema, CreateTransactionSchema, CreateTransactionsSchema, CreateReceiptSplitTransactionSchema, UpdateTransactionSchema, UpdateTransactionsSchema, DeleteTransactionSchema, } from '../tools/transactionTools.js';
-import { handleExportTransactions, ExportTransactionsSchema } from '../tools/exportTransactions.js';
-import { handleCompareTransactions, CompareTransactionsSchema, } from '../tools/compareTransactions/index.js';
-import { handleReconcileAccount, ReconcileAccountSchema } from '../tools/reconciliation/index.js';
-import { handleListCategories, handleGetCategory, handleUpdateCategory, ListCategoriesSchema, GetCategorySchema, UpdateCategorySchema, } from '../tools/categoryTools.js';
-import { handleListPayees, handleGetPayee, ListPayeesSchema, GetPayeeSchema, } from '../tools/payeeTools.js';
-import { handleGetMonth, handleListMonths, GetMonthSchema, ListMonthsSchema, } from '../tools/monthTools.js';
-import { handleGetUser, handleConvertAmount, ConvertAmountSchema } from '../tools/utilityTools.js';
+import { registerBudgetTools } from '../tools/budgetTools.js';
+import { registerAccountTools } from '../tools/accountTools.js';
+import { registerTransactionTools } from '../tools/transactionTools.js';
+import { registerReconciliationTools } from '../tools/reconciliation/index.js';
+import { registerCategoryTools } from '../tools/categoryTools.js';
+import { registerPayeeTools } from '../tools/payeeTools.js';
+import { registerMonthTools } from '../tools/monthTools.js';
+import { registerUtilityTools } from '../tools/utilityTools.js';
+import { emptyObjectSchema } from '../tools/schemas/common.js';
 import { cacheManager, CacheManager } from './cacheManager.js';
 import { responseFormatter } from './responseFormatter.js';
-import { ToolRegistry, DefaultArgumentResolutionError, } from './toolRegistry.js';
+import { ToolRegistry } from './toolRegistry.js';
 import { ResourceManager } from './resources.js';
 import { PromptManager } from './prompts.js';
 import { DiagnosticManager } from './diagnostics.js';
@@ -31,12 +30,11 @@ import { ServerKnowledgeStore } from './serverKnowledgeStore.js';
 import { DeltaCache } from './deltaCache.js';
 import { DeltaFetcher } from '../tools/deltaFetcher.js';
 import { ToolAnnotationPresets } from '../tools/toolCategories.js';
-import { GetUserOutputSchema, ConvertAmountOutputSchema, GetDefaultBudgetOutputSchema, SetDefaultBudgetOutputSchema, ClearCacheOutputSchema, SetOutputFormatOutputSchema, DiagnosticInfoOutputSchema, GetBudgetOutputSchema, ListBudgetsOutputSchema, ListAccountsOutputSchema, GetAccountOutputSchema, GetTransactionOutputSchema, ExportTransactionsOutputSchema, CompareTransactionsOutputSchema, ListCategoriesOutputSchema, GetCategoryOutputSchema, ListPayeesOutputSchema, GetPayeeOutputSchema, GetMonthOutputSchema, ListMonthsOutputSchema, } from '../tools/schemas/outputs/index.js';
 export class YNABMCPServer {
     constructor(exitOnError = true) {
         this.exitOnError = exitOnError;
         this.configInstance = loadConfig();
-        this.defaultBudgetId = process.env['YNAB_DEFAULT_BUDGET_ID'];
+        this.defaultBudgetId = this.configInstance.YNAB_DEFAULT_BUDGET_ID;
         this.ynabAPI = new ynab.API(this.configInstance.YNAB_ACCESS_TOKEN);
         this.serverVersion = this.readPackageVersion() ?? '0.0.0';
         this.server = new Server({
@@ -211,23 +209,16 @@ export class YNABMCPServer {
         const register = (definition) => {
             this.toolRegistry.register(definition);
         };
-        const adapt = (handler) => async ({ input }) => handler(this.ynabAPI, input);
-        const adaptNoInput = (handler) => async (_payload) => handler(this.ynabAPI);
-        const adaptWithDelta = (handler) => async ({ input }) => handler(this.ynabAPI, this.deltaFetcher, input);
-        const adaptWrite = (handler) => async ({ input }) => handler(this.ynabAPI, this.deltaCache, this.serverKnowledgeStore, input);
-        const resolveBudgetId = () => {
-            return ({ rawArguments }) => {
-                const provided = typeof rawArguments['budget_id'] === 'string' && rawArguments['budget_id'].length > 0
-                    ? rawArguments['budget_id']
-                    : undefined;
-                const result = BudgetResolver.resolveBudgetId(provided, this.defaultBudgetId);
-                if (typeof result === 'string') {
-                    return { budget_id: result };
-                }
-                throw new DefaultArgumentResolutionError(result);
-            };
+        const toolContext = {
+            ynabAPI: this.ynabAPI,
+            deltaFetcher: this.deltaFetcher,
+            deltaCache: this.deltaCache,
+            serverKnowledgeStore: this.serverKnowledgeStore,
+            getDefaultBudgetId: () => this.defaultBudgetId,
+            setDefaultBudget: (budgetId) => this.setDefaultBudget(budgetId),
+            cacheManager,
+            diagnosticManager: this.diagnosticManager,
         };
-        const emptyObjectSchema = z.object({}).strict();
         const setDefaultBudgetSchema = z.object({ budget_id: z.string().min(1) }).strict();
         const diagnosticInfoSchema = z
             .object({
@@ -245,38 +236,18 @@ export class YNABMCPServer {
             pretty_spaces: z.number().int().min(0).max(10).optional(),
         })
             .strict();
-        const LooseObjectSchema = z.object({}).passthrough();
-        register({
-            name: 'list_budgets',
-            description: "List all budgets associated with the user's account",
-            inputSchema: emptyObjectSchema,
-            outputSchema: ListBudgetsOutputSchema,
-            handler: adaptWithDelta(handleListBudgets),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                    title: 'YNAB: List Budgets',
-                },
-            },
-        });
-        register({
-            name: 'get_budget',
-            description: 'Get detailed information for a specific budget',
-            inputSchema: GetBudgetSchema,
-            outputSchema: GetBudgetOutputSchema,
-            handler: adapt(handleGetBudget),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                    title: 'YNAB: Get Budget Details',
-                },
-            },
-        });
+        registerBudgetTools(this.toolRegistry, toolContext);
+        registerPayeeTools(this.toolRegistry, toolContext);
+        registerCategoryTools(this.toolRegistry, toolContext);
+        registerAccountTools(this.toolRegistry, toolContext);
+        registerMonthTools(this.toolRegistry, toolContext);
+        registerTransactionTools(this.toolRegistry, toolContext);
+        registerReconciliationTools(this.toolRegistry, toolContext);
+        registerUtilityTools(this.toolRegistry, toolContext);
         register({
             name: 'set_default_budget',
             description: 'Set the default budget for subsequent operations',
             inputSchema: setDefaultBudgetSchema,
-            outputSchema: SetDefaultBudgetOutputSchema,
             handler: async ({ input }) => {
                 const { budget_id } = input;
                 await this.ynabAPI.budgets.getBudgetById(budget_id);
@@ -308,7 +279,6 @@ export class YNABMCPServer {
             name: 'get_default_budget',
             description: 'Get the currently set default budget',
             inputSchema: emptyObjectSchema,
-            outputSchema: GetDefaultBudgetOutputSchema,
             handler: async () => {
                 try {
                     const defaultBudget = this.getDefaultBudget();
@@ -338,331 +308,10 @@ export class YNABMCPServer {
                 },
             },
         });
-        register({
-            name: 'list_accounts',
-            description: 'List all accounts for a specific budget (uses default budget if not specified)',
-            inputSchema: ListAccountsSchema,
-            outputSchema: ListAccountsOutputSchema,
-            handler: adaptWithDelta(handleListAccounts),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                    title: 'YNAB: List Accounts',
-                },
-            },
-        });
-        register({
-            name: 'get_account',
-            description: 'Get detailed information for a specific account',
-            inputSchema: GetAccountSchema,
-            outputSchema: GetAccountOutputSchema,
-            handler: adapt(handleGetAccount),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                    title: 'YNAB: Get Account Details',
-                },
-            },
-        });
-        register({
-            name: 'create_account',
-            description: 'Create a new account in the specified budget',
-            inputSchema: CreateAccountSchema,
-            outputSchema: LooseObjectSchema,
-            handler: adaptWrite(handleCreateAccount),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.WRITE_EXTERNAL_CREATE,
-                    title: 'YNAB: Create Account',
-                },
-            },
-        });
-        register({
-            name: 'list_transactions',
-            description: 'List transactions for a budget with optional filtering',
-            inputSchema: ListTransactionsSchema,
-            outputSchema: LooseObjectSchema,
-            handler: adaptWithDelta(handleListTransactions),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                    title: 'YNAB: List Transactions',
-                },
-            },
-        });
-        register({
-            name: 'export_transactions',
-            description: 'Export all transactions to a JSON file with descriptive filename',
-            inputSchema: ExportTransactionsSchema,
-            outputSchema: ExportTransactionsOutputSchema,
-            handler: adapt(handleExportTransactions),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                    title: 'YNAB: Export Transactions',
-                },
-            },
-        });
-        register({
-            name: 'compare_transactions',
-            description: 'Compare bank transactions from CSV with YNAB transactions to find missing entries',
-            inputSchema: CompareTransactionsSchema,
-            outputSchema: CompareTransactionsOutputSchema,
-            handler: adapt(handleCompareTransactions),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                    title: 'YNAB: Compare Transactions',
-                },
-            },
-        });
-        register({
-            name: 'reconcile_account',
-            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,
-            outputSchema: LooseObjectSchema,
-            handler: adaptWithDelta(handleReconcileAccount),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.WRITE_EXTERNAL_UPDATE,
-                    title: 'YNAB: Reconcile Account',
-                },
-            },
-        });
-        register({
-            name: 'get_transaction',
-            description: 'Get detailed information for a specific transaction',
-            inputSchema: GetTransactionSchema,
-            outputSchema: GetTransactionOutputSchema,
-            handler: adapt(handleGetTransaction),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                    title: 'YNAB: Get Transaction Details',
-                },
-            },
-        });
-        register({
-            name: 'create_transaction',
-            description: 'Create a new transaction in the specified budget and account',
-            inputSchema: CreateTransactionSchema,
-            outputSchema: LooseObjectSchema,
-            handler: adaptWrite(handleCreateTransaction),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.WRITE_EXTERNAL_CREATE,
-                    title: 'YNAB: Create Transaction',
-                },
-            },
-        });
-        register({
-            name: 'create_transactions',
-            description: 'Create multiple transactions in a single batch (1-100 items) with duplicate detection, dry-run validation, and automatic response size management with correlation metadata.',
-            inputSchema: CreateTransactionsSchema,
-            outputSchema: LooseObjectSchema,
-            handler: adaptWrite(handleCreateTransactions),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.WRITE_EXTERNAL_CREATE,
-                    title: 'YNAB: Create Multiple Transactions',
-                },
-            },
-        });
-        register({
-            name: 'update_transactions',
-            description: 'Update multiple transactions in a single batch (1-100 items) with dry-run validation, automatic cache invalidation, and response size management. Supports optional original_account_id and original_date metadata for efficient cache invalidation.',
-            inputSchema: UpdateTransactionsSchema,
-            outputSchema: LooseObjectSchema,
-            handler: adaptWrite(handleUpdateTransactions),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.WRITE_EXTERNAL_UPDATE,
-                    title: 'YNAB: Update Multiple Transactions',
-                },
-            },
-        });
-        register({
-            name: 'create_receipt_split_transaction',
-            description: 'Create a split transaction from receipt items with proportional tax allocation',
-            inputSchema: CreateReceiptSplitTransactionSchema,
-            outputSchema: LooseObjectSchema,
-            handler: adaptWrite(handleCreateReceiptSplitTransaction),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.WRITE_EXTERNAL_CREATE,
-                    title: 'YNAB: Create Split Transaction from Receipt',
-                },
-            },
-        });
-        register({
-            name: 'update_transaction',
-            description: 'Update an existing transaction',
-            inputSchema: UpdateTransactionSchema,
-            outputSchema: LooseObjectSchema,
-            handler: adaptWrite(handleUpdateTransaction),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.WRITE_EXTERNAL_UPDATE,
-                    title: 'YNAB: Update Transaction',
-                },
-            },
-        });
-        register({
-            name: 'delete_transaction',
-            description: 'Delete a transaction from the specified budget',
-            inputSchema: DeleteTransactionSchema,
-            outputSchema: LooseObjectSchema,
-            handler: adaptWrite(handleDeleteTransaction),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.WRITE_EXTERNAL_DELETE,
-                    title: 'YNAB: Delete Transaction',
-                },
-            },
-        });
-        register({
-            name: 'list_categories',
-            description: 'List all categories for a specific budget',
-            inputSchema: ListCategoriesSchema,
-            outputSchema: ListCategoriesOutputSchema,
-            handler: adaptWithDelta(handleListCategories),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                    title: 'YNAB: List Categories',
-                },
-            },
-        });
-        register({
-            name: 'get_category',
-            description: 'Get detailed information for a specific category',
-            inputSchema: GetCategorySchema,
-            outputSchema: GetCategoryOutputSchema,
-            handler: adapt(handleGetCategory),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                    title: 'YNAB: Get Category Details',
-                },
-            },
-        });
-        register({
-            name: 'update_category',
-            description: 'Update the budgeted amount for a category in the current month',
-            inputSchema: UpdateCategorySchema,
-            outputSchema: LooseObjectSchema,
-            handler: adaptWrite(handleUpdateCategory),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.WRITE_EXTERNAL_UPDATE,
-                    title: 'YNAB: Update Category Budget',
-                },
-            },
-        });
-        register({
-            name: 'list_payees',
-            description: 'List all payees for a specific budget',
-            inputSchema: ListPayeesSchema,
-            outputSchema: ListPayeesOutputSchema,
-            handler: adaptWithDelta(handleListPayees),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                    title: 'YNAB: List Payees',
-                },
-            },
-        });
-        register({
-            name: 'get_payee',
-            description: 'Get detailed information for a specific payee',
-            inputSchema: GetPayeeSchema,
-            outputSchema: GetPayeeOutputSchema,
-            handler: adapt(handleGetPayee),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                    title: 'YNAB: Get Payee Details',
-                },
-            },
-        });
-        register({
-            name: 'get_month',
-            description: 'Get budget data for a specific month',
-            inputSchema: GetMonthSchema,
-            outputSchema: GetMonthOutputSchema,
-            handler: adapt(handleGetMonth),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                    title: 'YNAB: Get Month Budget Data',
-                },
-            },
-        });
-        register({
-            name: 'list_months',
-            description: 'List all months summary data for a budget',
-            inputSchema: ListMonthsSchema,
-            outputSchema: ListMonthsOutputSchema,
-            handler: adaptWithDelta(handleListMonths),
-            defaultArgumentResolver: resolveBudgetId(),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                    title: 'YNAB: List Months',
-                },
-            },
-        });
-        register({
-            name: 'get_user',
-            description: 'Get information about the authenticated user',
-            inputSchema: emptyObjectSchema,
-            outputSchema: GetUserOutputSchema,
-            handler: adaptNoInput(handleGetUser),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
-                    title: 'YNAB: Get User Information',
-                },
-            },
-        });
-        register({
-            name: 'convert_amount',
-            description: 'Convert between dollars and milliunits with integer arithmetic for precision',
-            inputSchema: ConvertAmountSchema,
-            outputSchema: ConvertAmountOutputSchema,
-            handler: async ({ input }) => handleConvertAmount(input),
-            metadata: {
-                annotations: {
-                    ...ToolAnnotationPresets.UTILITY_LOCAL,
-                    title: 'YNAB: Convert Amount',
-                },
-            },
-        });
         register({
             name: 'diagnostic_info',
             description: 'Get comprehensive diagnostic information about the MCP server',
             inputSchema: diagnosticInfoSchema,
-            outputSchema: DiagnosticInfoOutputSchema,
             handler: async ({ input }) => {
                 return this.diagnosticManager.collectDiagnostics(input);
             },
@@ -677,7 +326,6 @@ export class YNABMCPServer {
             name: 'clear_cache',
             description: 'Clear the in-memory cache (safe, no YNAB data is modified)',
             inputSchema: emptyObjectSchema,
-            outputSchema: ClearCacheOutputSchema,
             handler: async () => {
                 cacheManager.clear();
                 return {
@@ -695,7 +343,6 @@ export class YNABMCPServer {
             name: 'set_output_format',
             description: 'Configure default JSON output formatting (minify or pretty spaces)',
             inputSchema: setOutputFormatSchema,
-            outputSchema: SetOutputFormatOutputSchema,
             handler: async ({ input }) => {
                 const options = {};
                 if (typeof input.default_minify === 'boolean') {

package/dist/server/config.d.ts

@@ -2,6 +2,7 @@ import 'dotenv/config';
 import { z } from 'zod';
 declare const envSchema: z.ZodObject<{
     YNAB_ACCESS_TOKEN: z.ZodString;
+    YNAB_DEFAULT_BUDGET_ID: z.ZodOptional<z.ZodString>;
     MCP_PORT: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     LOG_LEVEL: z.ZodDefault<z.ZodEnum<{
         error: "error";
@@ -17,6 +18,7 @@ export declare function loadConfig(env?: NodeJS.ProcessEnv): AppConfig;
 export declare const config: {
     YNAB_ACCESS_TOKEN: string;
     LOG_LEVEL: "error" | "warn" | "info" | "debug" | "trace" | "fatal";
+    YNAB_DEFAULT_BUDGET_ID?: string | undefined;
     MCP_PORT?: number | undefined;
 };
 export {};

package/dist/server/config.js

@@ -4,6 +4,7 @@ import { fromZodError } from 'zod-validation-error';
 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/dist/tools/accountTools.d.ts

@@ -4,6 +4,7 @@ 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';
 export declare const ListAccountsSchema: z.ZodObject<{
     budget_id: z.ZodString;
     limit: z.ZodOptional<z.ZodNumber>;
@@ -35,3 +36,4 @@ export declare function handleListAccounts(ynabAPI: ynab.API, params: ListAccoun
 export declare function handleGetAccount(ynabAPI: ynab.API, params: GetAccountParams): 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

@@ -5,6 +5,8 @@ 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';
 export const ListAccountsSchema = z
     .object({
     budget_id: z.string().min(1, 'Budget ID is required'),
@@ -174,3 +176,46 @@ export async function handleCreateAccount(ynabAPI, deltaCacheOrParams, knowledge
         };
     }, 'ynab:create_account', 'creating account');
 }
+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',
+        inputSchema: ListAccountsSchema,
+        handler: adaptWithDelta(handleListAccounts),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: 'YNAB: List Accounts',
+            },
+        },
+    });
+    registry.register({
+        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',
+            },
+        },
+    });
+    registry.register({
+        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',
+            },
+        },
+    });
+};

package/dist/tools/adapters.d.ts

@@ -0,0 +1,12 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ToolExecutionPayload, DefaultArgumentResolver } from '../server/toolRegistry.js';
+import type { ToolContext, Handler, DeltaHandler, WriteHandler, NoInputHandler } from '../types/toolRegistration.js';
+export declare function createAdapters(context: ToolContext): {
+    adapt: <TInput extends Record<string, unknown>>(handler: Handler<TInput>) => ({ input }: ToolExecutionPayload<TInput>) => Promise<CallToolResult>;
+    adaptNoInput: (handler: NoInputHandler) => (_payload: ToolExecutionPayload<Record<string, unknown>>) => Promise<CallToolResult>;
+    adaptWithDelta: <TInput extends Record<string, unknown>>(handler: DeltaHandler<TInput>) => ({ input }: ToolExecutionPayload<TInput>) => Promise<CallToolResult>;
+    adaptWrite: <TInput extends Record<string, unknown>>(handler: WriteHandler<TInput>) => ({ input }: ToolExecutionPayload<TInput>) => Promise<CallToolResult>;
+};
+export declare function createBudgetResolver(context: ToolContext): <TInput extends {
+    budget_id?: string | undefined;
+}>() => DefaultArgumentResolver<TInput>;

package/dist/tools/adapters.js

@@ -0,0 +1,25 @@
+import { BudgetResolver } from '../server/budgetResolver.js';
+import { DefaultArgumentResolutionError } from '../server/toolRegistry.js';
+export function createAdapters(context) {
+    const { ynabAPI, deltaFetcher, deltaCache, serverKnowledgeStore } = context;
+    return {
+        adapt: (handler) => async ({ input }) => handler(ynabAPI, input),
+        adaptNoInput: (handler) => async (_payload) => handler(ynabAPI),
+        adaptWithDelta: (handler) => async ({ input }) => handler(ynabAPI, deltaFetcher, input),
+        adaptWrite: (handler) => async ({ input }) => handler(ynabAPI, deltaCache, serverKnowledgeStore, input),
+    };
+}
+export function createBudgetResolver(context) {
+    return () => {
+        return ({ rawArguments }) => {
+            const provided = typeof rawArguments['budget_id'] === 'string' && rawArguments['budget_id'].length > 0
+                ? rawArguments['budget_id']
+                : undefined;
+            const result = BudgetResolver.resolveBudgetId(provided, context.getDefaultBudgetId());
+            if (typeof result === 'string') {
+                return { budget_id: result };
+            }
+            throw new DefaultArgumentResolutionError(result);
+        };
+    };
+}

package/dist/tools/budgetTools.d.ts

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

package/dist/tools/budgetTools.js

@@ -2,6 +2,9 @@ import { z } from 'zod/v4';
 import { withToolErrorHandling } from '../types/index.js';
 import { responseFormatter } from '../server/responseFormatter.js';
 import { resolveDeltaFetcherArgs } from './deltaSupport.js';
+import { createAdapters } from './adapters.js';
+import { ToolAnnotationPresets } from './toolCategories.js';
+import { emptyObjectSchema } from './schemas/common.js';
 export const GetBudgetSchema = z
     .object({
     budget_id: z.string().min(1, 'Budget ID is required'),
@@ -66,3 +69,30 @@ export async function handleGetBudget(ynabAPI, params) {
         };
     }, 'ynab:get_budget', 'getting budget details');
 }
+export const registerBudgetTools = (registry, context) => {
+    const { adapt, adaptWithDelta } = createAdapters(context);
+    registry.register({
+        name: 'list_budgets',
+        description: "List all budgets associated with the user's account",
+        inputSchema: emptyObjectSchema,
+        handler: adaptWithDelta(handleListBudgets),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: 'YNAB: List Budgets',
+            },
+        },
+    });
+    registry.register({
+        name: 'get_budget',
+        description: 'Get detailed information for a specific budget',
+        inputSchema: GetBudgetSchema,
+        handler: adapt(handleGetBudget),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: 'YNAB: Get Budget Details',
+            },
+        },
+    });
+};