@dizzlkheinz/ynab-mcpb 0.16.0 → 0.17.0

package/dist/tools/categoryTools.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 ListCategoriesSchema: z.ZodObject<{
     budget_id: z.ZodString;
 }, z.core.$strict>;
@@ -25,3 +26,4 @@ export declare function handleListCategories(ynabAPI: ynab.API, params: ListCate
 export declare function handleGetCategory(ynabAPI: ynab.API, params: GetCategoryParams): Promise<CallToolResult>;
 export declare function handleUpdateCategory(ynabAPI: ynab.API, deltaCache: DeltaCache, knowledgeStore: ServerKnowledgeStore, params: UpdateCategoryParams): Promise<CallToolResult>;
 export declare function handleUpdateCategory(ynabAPI: ynab.API, params: UpdateCategoryParams): Promise<CallToolResult>;
+export declare const registerCategoryTools: ToolFactory;

package/dist/tools/categoryTools.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 ListCategoriesSchema = z
     .object({
     budget_id: z.string().min(1, 'Budget ID is required'),
@@ -199,6 +201,49 @@ export async function handleUpdateCategory(ynabAPI, deltaCacheOrParams, knowledg
         return handleCategoryError(error, 'Failed to update category');
     }
 }
+export const registerCategoryTools = (registry, context) => {
+    const { adapt, adaptWithDelta, adaptWrite } = createAdapters(context);
+    const budgetResolver = createBudgetResolver(context);
+    registry.register({
+        name: 'list_categories',
+        description: 'List all categories for a specific budget',
+        inputSchema: ListCategoriesSchema,
+        handler: adaptWithDelta(handleListCategories),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: 'YNAB: List Categories',
+            },
+        },
+    });
+    registry.register({
+        name: 'get_category',
+        description: 'Get detailed information for a specific category',
+        inputSchema: GetCategorySchema,
+        handler: adapt(handleGetCategory),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: 'YNAB: Get Category Details',
+            },
+        },
+    });
+    registry.register({
+        name: 'update_category',
+        description: 'Update the budgeted amount for a category in the current month',
+        inputSchema: UpdateCategorySchema,
+        handler: adaptWrite(handleUpdateCategory),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.WRITE_EXTERNAL_UPDATE,
+                title: 'YNAB: Update Category Budget',
+            },
+        },
+    });
+};
 function handleCategoryError(error, defaultMessage) {
     let errorMessage = defaultMessage;
     if (error instanceof Error) {

package/dist/tools/monthTools.d.ts

@@ -2,6 +2,7 @@ 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 GetMonthSchema: z.ZodObject<{
     budget_id: z.ZodString;
     month: z.ZodString;
@@ -14,3 +15,4 @@ export type ListMonthsParams = z.infer<typeof ListMonthsSchema>;
 export declare function handleGetMonth(ynabAPI: ynab.API, params: GetMonthParams): Promise<CallToolResult>;
 export declare function handleListMonths(ynabAPI: ynab.API, deltaFetcher: DeltaFetcher, params: ListMonthsParams): Promise<CallToolResult>;
 export declare function handleListMonths(ynabAPI: ynab.API, params: ListMonthsParams): Promise<CallToolResult>;
+export declare const registerMonthTools: ToolFactory;

package/dist/tools/monthTools.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 } from './deltaSupport.js';
+import { createAdapters, createBudgetResolver } from './adapters.js';
+import { ToolAnnotationPresets } from './toolCategories.js';
 export const GetMonthSchema = z
     .object({
     budget_id: z.string().min(1, 'Budget ID is required'),
@@ -106,3 +108,33 @@ export async function handleListMonths(ynabAPI, deltaFetcherOrParams, maybeParam
         };
     }, 'ynab:list_months', 'listing months');
 }
+export const registerMonthTools = (registry, context) => {
+    const { adapt, adaptWithDelta } = createAdapters(context);
+    const budgetResolver = createBudgetResolver(context);
+    registry.register({
+        name: 'get_month',
+        description: 'Get budget data for a specific month',
+        inputSchema: GetMonthSchema,
+        handler: adapt(handleGetMonth),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: 'YNAB: Get Month Details',
+            },
+        },
+    });
+    registry.register({
+        name: 'list_months',
+        description: 'List all months summary data for a budget',
+        inputSchema: ListMonthsSchema,
+        handler: adaptWithDelta(handleListMonths),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: 'YNAB: List Months',
+            },
+        },
+    });
+};

package/dist/tools/payeeTools.d.ts

@@ -2,6 +2,7 @@ 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 ListPayeesSchema: z.ZodObject<{
     budget_id: z.ZodString;
     limit: z.ZodOptional<z.ZodNumber>;
@@ -15,3 +16,4 @@ export type GetPayeeParams = z.infer<typeof GetPayeeSchema>;
 export declare function handleListPayees(ynabAPI: ynab.API, deltaFetcher: DeltaFetcher, params: ListPayeesParams): Promise<CallToolResult>;
 export declare function handleListPayees(ynabAPI: ynab.API, params: ListPayeesParams): Promise<CallToolResult>;
 export declare function handleGetPayee(ynabAPI: ynab.API, params: GetPayeeParams): Promise<CallToolResult>;
+export declare const registerPayeeTools: ToolFactory;

package/dist/tools/payeeTools.js

@@ -4,6 +4,8 @@ import { responseFormatter } from '../server/responseFormatter.js';
 import { cacheManager, CACHE_TTLS, CacheManager } from '../server/cacheManager.js';
 import { CacheKeys } from '../server/cacheKeys.js';
 import { resolveDeltaFetcherArgs } from './deltaSupport.js';
+import { createAdapters, createBudgetResolver } from './adapters.js';
+import { ToolAnnotationPresets } from './toolCategories.js';
 export const ListPayeesSchema = z
     .object({
     budget_id: z.string().min(1, 'Budget ID is required'),
@@ -81,3 +83,33 @@ export async function handleGetPayee(ynabAPI, params) {
         };
     }, 'ynab:get_payee', 'getting payee details');
 }
+export const registerPayeeTools = (registry, context) => {
+    const { adapt, adaptWithDelta } = createAdapters(context);
+    const budgetResolver = createBudgetResolver(context);
+    registry.register({
+        name: 'list_payees',
+        description: 'List all payees for a specific budget',
+        inputSchema: ListPayeesSchema,
+        handler: adaptWithDelta(handleListPayees),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: 'YNAB: List Payees',
+            },
+        },
+    });
+    registry.register({
+        name: 'get_payee',
+        description: 'Get detailed information for a specific payee',
+        inputSchema: GetPayeeSchema,
+        handler: adapt(handleGetPayee),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: 'YNAB: Get Payee Details',
+            },
+        },
+    });
+};

package/dist/tools/reconciliation/index.d.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod/v4';
 import type * as ynab from 'ynab';
 import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ToolFactory } from '../../types/toolRegistration.js';
 import type { DeltaFetcher } from '../deltaFetcher.js';
 export type * from './types.js';
 export { analyzeReconciliation } from './analyzer.js';
@@ -52,3 +53,4 @@ export declare const ReconcileAccountSchema: z.ZodObject<{
 export type ReconcileAccountRequest = z.infer<typeof ReconcileAccountSchema>;
 export declare function handleReconcileAccount(ynabAPI: ynab.API, deltaFetcher: DeltaFetcher, params: ReconcileAccountRequest): Promise<CallToolResult>;
 export declare function handleReconcileAccount(ynabAPI: ynab.API, params: ReconcileAccountRequest): Promise<CallToolResult>;
+export declare const registerReconciliationTools: ToolFactory;

package/dist/tools/reconciliation/index.js

@@ -1,6 +1,9 @@
 import { promises as fs } from 'fs';
 import { z } from 'zod/v4';
 import { withToolErrorHandling } from '../../types/index.js';
+import { createAdapters, createBudgetResolver } from '../adapters.js';
+import { ToolAnnotationPresets } from '../toolCategories.js';
+import { CompareTransactionsSchema, handleCompareTransactions, } from '../compareTransactions/index.js';
 import { analyzeReconciliation } from './analyzer.js';
 import { buildReconciliationPayload } from '../reconcileAdapter.js';
 import { executeReconciliation, } from './executor.js';
@@ -303,6 +306,36 @@ export async function handleReconcileAccount(ynabAPI, deltaFetcherOrParams, mayb
         };
     }, 'ynab:reconcile_account', 'analyzing account reconciliation');
 }
+export const registerReconciliationTools = (registry, context) => {
+    const { adapt, adaptWithDelta } = createAdapters(context);
+    const budgetResolver = createBudgetResolver(context);
+    registry.register({
+        name: 'compare_transactions',
+        description: 'Compare bank transactions from CSV with YNAB transactions to find missing entries',
+        inputSchema: CompareTransactionsSchema,
+        handler: adapt(handleCompareTransactions),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: 'YNAB: Compare Transactions',
+            },
+        },
+    });
+    registry.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,
+        handler: adaptWithDelta(handleReconcileAccount),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.WRITE_EXTERNAL_UPDATE,
+                title: 'YNAB: Reconcile Account',
+            },
+        },
+    });
+};
 function mapCsvDateFormatToHint(format) {
     if (!format) {
         return undefined;

package/dist/tools/schemas/common.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod/v4';
+export declare const emptyObjectSchema: z.ZodObject<{}, z.core.$strict>;
+export declare const looseObjectSchema: z.ZodObject<{}, z.core.$loose>;

package/dist/tools/schemas/common.js

@@ -0,0 +1,3 @@
+import { z } from 'zod/v4';
+export const emptyObjectSchema = z.object({}).strict();
+export const looseObjectSchema = z.object({}).passthrough();

package/dist/tools/schemas/outputs/comparisonOutputs.d.ts

@@ -250,8 +250,8 @@ export declare const ExportTransactionsOutputSchema: z.ZodObject<{
     full_path: z.ZodString;
     export_directory: z.ZodString;
     export_mode: z.ZodEnum<{
-        full: "full";
         minimal: "minimal";
+        full: "full";
     }>;
     minimal_fields: z.ZodNullable<z.ZodString>;
     filename_explanation: z.ZodString;

package/dist/tools/transactionTools.d.ts

@@ -2,6 +2,7 @@ import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import * as ynab from 'ynab';
 import type { SaveTransactionsResponseData } from 'ynab/dist/models/SaveTransactionsResponseData.js';
 import { z } from 'zod/v4';
+import type { ToolFactory } from '../types/toolRegistration.js';
 import type { DeltaFetcher } from './deltaFetcher.js';
 import type { DeltaCache } from '../server/deltaCache.js';
 import type { ServerKnowledgeStore } from '../server/serverKnowledgeStore.js';
@@ -298,4 +299,5 @@ export declare function handleCreateTransactions(ynabAPI: ynab.API, deltaCache:
 export declare function handleCreateTransactions(ynabAPI: ynab.API, params: CreateTransactionsParams): Promise<CallToolResult>;
 export declare function handleUpdateTransactions(ynabAPI: ynab.API, deltaCache: DeltaCache, knowledgeStore: ServerKnowledgeStore, params: UpdateTransactionsParams): Promise<CallToolResult>;
 export declare function handleUpdateTransactions(ynabAPI: ynab.API, params: UpdateTransactionsParams): Promise<CallToolResult>;
+export declare const registerTransactionTools: ToolFactory;
 export {};

package/dist/tools/transactionTools.js

@@ -1,11 +1,14 @@
 import { z } from 'zod/v4';
 import { createHash } from 'crypto';
 import { ValidationError, withToolErrorHandling } from '../types/index.js';
+import { createAdapters, createBudgetResolver } from './adapters.js';
+import { ToolAnnotationPresets } from './toolCategories.js';
 import { responseFormatter } from '../server/responseFormatter.js';
 import { amountToMilliunits, milliunitsToAmount } from '../utils/amountUtils.js';
 import { cacheManager, CACHE_TTLS, CacheManager } from '../server/cacheManager.js';
 import { globalRequestLogger } from '../server/requestLogger.js';
 import { resolveDeltaFetcherArgs, resolveDeltaWriteArgs } from './deltaSupport.js';
+import { handleExportTransactions, ExportTransactionsSchema } from './exportTransactions.js';
 function ensureTransaction(transaction, errorMessage) {
     if (!transaction) {
         throw new Error(errorMessage);
@@ -496,6 +499,11 @@ export async function handleListTransactions(ynabAPI, deltaFetcherOrParams, mayb
         let cacheHit = false;
         let usedDelta = false;
         if (params.account_id) {
+            const accountsResult = await deltaFetcher.fetchAccounts(params.budget_id);
+            const accountExists = accountsResult.data.some((account) => account.id === params.account_id);
+            if (!accountExists) {
+                throw new Error(`Account ${params.account_id} not found in budget ${params.budget_id}`);
+            }
             const result = await deltaFetcher.fetchTransactionsByAccount(params.budget_id, params.account_id, params.since_date);
             transactions = result.data;
             cacheHit = result.wasCached;
@@ -1708,3 +1716,124 @@ function handleTransactionError(error, defaultMessage) {
         ],
     };
 }
+export const registerTransactionTools = (registry, context) => {
+    const { adapt, adaptWithDelta, adaptWrite } = createAdapters(context);
+    const budgetResolver = createBudgetResolver(context);
+    registry.register({
+        name: 'list_transactions',
+        description: 'List transactions for a budget with optional filtering',
+        inputSchema: ListTransactionsSchema,
+        handler: adaptWithDelta(handleListTransactions),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: 'YNAB: List Transactions',
+            },
+        },
+    });
+    registry.register({
+        name: 'export_transactions',
+        description: 'Export all transactions to a JSON file with descriptive filename',
+        inputSchema: ExportTransactionsSchema,
+        handler: adapt(handleExportTransactions),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: 'YNAB: Export Transactions',
+            },
+        },
+    });
+    registry.register({
+        name: 'get_transaction',
+        description: 'Get detailed information for a specific transaction',
+        inputSchema: GetTransactionSchema,
+        handler: adapt(handleGetTransaction),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: 'YNAB: Get Transaction Details',
+            },
+        },
+    });
+    registry.register({
+        name: 'create_transaction',
+        description: 'Create a new transaction in the specified budget and account',
+        inputSchema: CreateTransactionSchema,
+        handler: adaptWrite(handleCreateTransaction),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.WRITE_EXTERNAL_CREATE,
+                title: 'YNAB: Create Transaction',
+            },
+        },
+    });
+    registry.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,
+        handler: adaptWrite(handleCreateTransactions),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.WRITE_EXTERNAL_CREATE,
+                title: 'YNAB: Create Multiple Transactions',
+            },
+        },
+    });
+    registry.register({
+        name: 'create_receipt_split_transaction',
+        description: 'Create a split transaction from receipt items with proportional tax allocation',
+        inputSchema: CreateReceiptSplitTransactionSchema,
+        handler: adaptWrite(handleCreateReceiptSplitTransaction),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.WRITE_EXTERNAL_CREATE,
+                title: 'YNAB: Create Split Transaction from Receipt',
+            },
+        },
+    });
+    registry.register({
+        name: 'update_transaction',
+        description: 'Update an existing transaction',
+        inputSchema: UpdateTransactionSchema,
+        handler: adaptWrite(handleUpdateTransaction),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.WRITE_EXTERNAL_UPDATE,
+                title: 'YNAB: Update Transaction',
+            },
+        },
+    });
+    registry.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,
+        handler: adaptWrite(handleUpdateTransactions),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.WRITE_EXTERNAL_UPDATE,
+                title: 'YNAB: Update Multiple Transactions',
+            },
+        },
+    });
+    registry.register({
+        name: 'delete_transaction',
+        description: 'Delete a transaction from the specified budget',
+        inputSchema: DeleteTransactionSchema,
+        handler: adaptWrite(handleDeleteTransaction),
+        defaultArgumentResolver: budgetResolver(),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.WRITE_EXTERNAL_DELETE,
+                title: 'YNAB: Delete Transaction',
+            },
+        },
+    });
+};

package/dist/tools/utilityTools.d.ts

@@ -1,10 +1,12 @@
 import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import * as ynab from 'ynab';
 import { z } from 'zod/v4';
+import type { ToolFactory } from '../types/toolRegistration.js';
 export declare const ConvertAmountSchema: z.ZodObject<{
     amount: z.ZodNumber;
     to_milliunits: z.ZodBoolean;
 }, z.core.$strict>;
 export type ConvertAmountParams = z.infer<typeof ConvertAmountSchema>;
 export declare function handleGetUser(ynabAPI: ynab.API): Promise<CallToolResult>;
-export declare function handleConvertAmount(params: ConvertAmountParams): Promise<CallToolResult>;
+export declare function handleConvertAmount(_ynabAPI: ynab.API, params: ConvertAmountParams): Promise<CallToolResult>;
+export declare const registerUtilityTools: ToolFactory;

package/dist/tools/utilityTools.js

@@ -1,6 +1,9 @@
 import { z } from 'zod/v4';
-import { withToolErrorHandling } from '../types/index.js';
 import { responseFormatter } from '../server/responseFormatter.js';
+import { withToolErrorHandling } from '../types/index.js';
+import { createAdapters } from './adapters.js';
+import { emptyObjectSchema } from './schemas/common.js';
+import { ToolAnnotationPresets } from './toolCategories.js';
 export const ConvertAmountSchema = z
     .object({
     amount: z.number().finite(),
@@ -24,7 +27,7 @@ export async function handleGetUser(ynabAPI) {
         };
     }, 'ynab:get_user', 'getting user information');
 }
-export async function handleConvertAmount(params) {
+export async function handleConvertAmount(_ynabAPI, params) {
     return await withToolErrorHandling(async () => {
         const { amount, to_milliunits } = params;
         let result;
@@ -54,3 +57,30 @@ export async function handleConvertAmount(params) {
         };
     }, 'ynab:convert_amount', 'converting amount');
 }
+export const registerUtilityTools = (registry, context) => {
+    const { adapt, adaptNoInput } = createAdapters(context);
+    registry.register({
+        name: 'get_user',
+        description: 'Get information about the authenticated user',
+        inputSchema: emptyObjectSchema,
+        handler: adaptNoInput(handleGetUser),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.READ_ONLY_EXTERNAL,
+                title: 'YNAB: Get User Information',
+            },
+        },
+    });
+    registry.register({
+        name: 'convert_amount',
+        description: 'Convert between dollars and milliunits with integer arithmetic for precision',
+        inputSchema: ConvertAmountSchema,
+        handler: adapt(handleConvertAmount),
+        metadata: {
+            annotations: {
+                ...ToolAnnotationPresets.UTILITY_LOCAL,
+                title: 'YNAB: Convert Amount',
+            },
+        },
+    });
+};

package/dist/types/index.d.ts

@@ -18,3 +18,4 @@ export { RequestLogger, globalRequestLogger, type LogEntry, type LoggerConfig, }
 export { SecurityMiddleware, withSecurityWrapper, type SecurityContext, } from '../server/securityMiddleware.js';
 export type { MCPToolAnnotations } from './toolAnnotations.js';
 export type { ToolDefinition } from '../server/toolRegistry.js';
+export type { ToolContext, ToolFactory, BudgetIdResolverFactory } from './toolRegistration.js';

package/dist/types/toolRegistration.d.ts

@@ -0,0 +1,27 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import * as ynab from 'ynab';
+import type { ToolRegistry, ToolExecutionPayload, DefaultArgumentResolver } from '../server/toolRegistry.js';
+import type { DeltaFetcher } from '../tools/deltaFetcher.js';
+import type { DeltaCache } from '../server/deltaCache.js';
+import type { ServerKnowledgeStore } from '../server/serverKnowledgeStore.js';
+import type { DiagnosticManager } from '../server/diagnostics.js';
+import type { CacheManager } from '../server/cacheManager.js';
+export interface ToolContext {
+    ynabAPI: ynab.API;
+    deltaFetcher: DeltaFetcher;
+    deltaCache: DeltaCache;
+    serverKnowledgeStore: ServerKnowledgeStore;
+    getDefaultBudgetId: () => string | undefined;
+    setDefaultBudget: (budgetId: string) => void;
+    cacheManager: CacheManager;
+    diagnosticManager?: DiagnosticManager;
+}
+export type ToolFactory = (registry: ToolRegistry, context: ToolContext) => void;
+export type Adapter<TInput extends Record<string, unknown>> = (payload: ToolExecutionPayload<TInput>) => Promise<CallToolResult>;
+export type Handler<TInput extends Record<string, unknown>> = (api: ynab.API, params: TInput) => Promise<CallToolResult>;
+export type DeltaHandler<TInput extends Record<string, unknown>> = (api: ynab.API, deltaFetcher: DeltaFetcher, params: TInput) => Promise<CallToolResult>;
+export type WriteHandler<TInput extends Record<string, unknown>> = (api: ynab.API, deltaCache: DeltaCache, serverKnowledgeStore: ServerKnowledgeStore, params: TInput) => Promise<CallToolResult>;
+export type NoInputHandler = (api: ynab.API) => Promise<CallToolResult>;
+export type BudgetIdResolverFactory = <TInput extends {
+    budget_id?: string | undefined;
+}>() => DefaultArgumentResolver<TInput>;

package/dist/types/toolRegistration.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dizzlkheinz/ynab-mcpb",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Model Context Protocol server for YNAB (You Need A Budget) integration",
   "main": "dist/index.js",
   "type": "module",
@@ -66,7 +66,7 @@
   "author": "",
   "license": "AGPL-3.0",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.22.0",
+    "@modelcontextprotocol/sdk": "^1.24.3",
     "chrono-node": "^2.9.0",
     "csv-parse": "^6.1.0",
     "d3-array": "^3.2.4",

package/scripts/run-domain-integration-tests.js

@@ -22,10 +22,13 @@ const env = {
 };
 
 const vitestArgs = ['vitest', 'run', '--project', 'integration:domain', ...passthroughArgs];
-const runner = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+const runner = 'npx';
+const useShell = process.platform === 'win32';
+
 const child = spawn(runner, vitestArgs, {
   stdio: 'inherit',
   env,
+  shell: useShell,
 });
 
 child.on('close', (code) => {

package/src/__tests__/workflows.e2e.test.ts

@@ -1065,13 +1065,7 @@ describeE2E('YNAB MCP Server - End-to-End Workflows', () => {
           expect(tool.description).toBeDefined();
           expect(tool.inputSchema).toBeDefined();
 
-          // Verify that all tools define outputSchema (as guaranteed by CHANGELOG.md and docs/reference/TOOLS.md)
-          // Note: Some utility tools like diagnostic_info or clear_cache may not define structured outputs,
-          // but most data-retrieval and CRUD tools should have output schemas.
-          expect(
-            tool.outputSchema,
-            `Tool '${tool.name}' should define an outputSchema`,
-          ).toBeDefined();
+          // Output schemas are optional; tools may omit them.
         }
       });
     });