@dizzlkheinz/ynab-mcpb 0.16.1 → 0.17.1

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',
+            },
+        },
+    });
+};

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/schemas/outputs/index.d.ts

@@ -1,5 +1,5 @@
-export { GetUserOutputSchema, type GetUserOutput, ConvertAmountOutputSchema, type ConvertAmountOutput, GetDefaultBudgetOutputSchema, type GetDefaultBudgetOutput, SetDefaultBudgetOutputSchema, type SetDefaultBudgetOutput, ClearCacheOutputSchema, type ClearCacheOutput, SetOutputFormatOutputSchema, type SetOutputFormatOutput, DiagnosticInfoOutputSchema, type DiagnosticInfoOutput, GetBudgetOutputSchema, type GetBudgetOutput, } from './utilityOutputs.js';
-export { UserSchema, ConversionSchema, DateFormatSchema, CurrencyFormatSchema, BudgetDetailSchema, ServerInfoSchema, MemoryInfoSchema, EnvironmentInfoSchema, CacheInfoSchema, DeltaInfoSchema, } from './utilityOutputs.js';
+export { GetUserOutputSchema, type GetUserOutput, GetDefaultBudgetOutputSchema, type GetDefaultBudgetOutput, SetDefaultBudgetOutputSchema, type SetDefaultBudgetOutput, ClearCacheOutputSchema, type ClearCacheOutput, SetOutputFormatOutputSchema, type SetOutputFormatOutput, DiagnosticInfoOutputSchema, type DiagnosticInfoOutput, GetBudgetOutputSchema, type GetBudgetOutput, } from './utilityOutputs.js';
+export { UserSchema, DateFormatSchema, CurrencyFormatSchema, BudgetDetailSchema, ServerInfoSchema, MemoryInfoSchema, EnvironmentInfoSchema, CacheInfoSchema, DeltaInfoSchema, } from './utilityOutputs.js';
 export { ListBudgetsOutputSchema, type ListBudgetsOutput, BudgetSummarySchema, type BudgetSummary, } from './budgetOutputs.js';
 export { ListAccountsOutputSchema, type ListAccountsOutput, GetAccountOutputSchema, type GetAccountOutput, AccountSchema, type Account, } from './accountOutputs.js';
 export { ListTransactionsOutputSchema, type ListTransactionsOutput, GetTransactionOutputSchema, type GetTransactionOutput, TransactionSchema, type Transaction, TransactionPreviewSchema, type TransactionPreview, } from './transactionOutputs.js';

package/dist/tools/schemas/outputs/index.js

@@ -1,5 +1,5 @@
-export { GetUserOutputSchema, ConvertAmountOutputSchema, GetDefaultBudgetOutputSchema, SetDefaultBudgetOutputSchema, ClearCacheOutputSchema, SetOutputFormatOutputSchema, DiagnosticInfoOutputSchema, GetBudgetOutputSchema, } from './utilityOutputs.js';
-export { UserSchema, ConversionSchema, DateFormatSchema, CurrencyFormatSchema, BudgetDetailSchema, ServerInfoSchema, MemoryInfoSchema, EnvironmentInfoSchema, CacheInfoSchema, DeltaInfoSchema, } from './utilityOutputs.js';
+export { GetUserOutputSchema, GetDefaultBudgetOutputSchema, SetDefaultBudgetOutputSchema, ClearCacheOutputSchema, SetOutputFormatOutputSchema, DiagnosticInfoOutputSchema, GetBudgetOutputSchema, } from './utilityOutputs.js';
+export { UserSchema, DateFormatSchema, CurrencyFormatSchema, BudgetDetailSchema, ServerInfoSchema, MemoryInfoSchema, EnvironmentInfoSchema, CacheInfoSchema, DeltaInfoSchema, } from './utilityOutputs.js';
 export { ListBudgetsOutputSchema, BudgetSummarySchema, } from './budgetOutputs.js';
 export { ListAccountsOutputSchema, GetAccountOutputSchema, AccountSchema, } from './accountOutputs.js';
 export { ListTransactionsOutputSchema, GetTransactionOutputSchema, TransactionSchema, TransactionPreviewSchema, } from './transactionOutputs.js';

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

@@ -8,21 +8,6 @@ export declare const GetUserOutputSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type GetUserOutput = z.infer<typeof GetUserOutputSchema>;
-export declare const ConversionSchema: z.ZodObject<{
-    original_amount: z.ZodNumber;
-    converted_amount: z.ZodNumber;
-    to_milliunits: z.ZodBoolean;
-    description: z.ZodString;
-}, z.core.$strip>;
-export declare const ConvertAmountOutputSchema: z.ZodObject<{
-    conversion: z.ZodObject<{
-        original_amount: z.ZodNumber;
-        converted_amount: z.ZodNumber;
-        to_milliunits: z.ZodBoolean;
-        description: z.ZodString;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type ConvertAmountOutput = z.infer<typeof ConvertAmountOutputSchema>;
 export declare const GetDefaultBudgetOutputSchema: z.ZodObject<{
     default_budget_id: z.ZodNullable<z.ZodString>;
     has_default: z.ZodBoolean;

package/dist/tools/schemas/outputs/utilityOutputs.js

@@ -6,15 +6,6 @@ export const UserSchema = z.object({
 export const GetUserOutputSchema = z.object({
     user: UserSchema,
 });
-export const ConversionSchema = z.object({
-    original_amount: z.number(),
-    converted_amount: z.number(),
-    to_milliunits: z.boolean(),
-    description: z.string(),
-});
-export const ConvertAmountOutputSchema = z.object({
-    conversion: ConversionSchema,
-});
 export const GetDefaultBudgetOutputSchema = z.object({
     default_budget_id: z.string().nullable(),
     has_default: z.boolean(),

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