@dizzlkheinz/ynab-mcpb 0.17.1 → 0.18.1

package/dist/server/YNABMCPServer.d.ts

@@ -16,6 +16,7 @@ export declare class YNABMCPServer {
     private deltaFetcher;
     private diagnosticManager;
     private errorHandler;
+    private completionsManager;
     constructor(exitOnError?: boolean);
     validateToken(): Promise<boolean>;
     private isMalformedTokenResponse;
@@ -68,6 +69,7 @@ export declare class YNABMCPServer {
                 src: string;
                 mimeType?: string | undefined;
                 sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
             }[] | undefined;
             title?: string | undefined;
         }[];
@@ -132,6 +134,7 @@ export declare class YNABMCPServer {
                 src: string;
                 mimeType?: string | undefined;
                 sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
             }[] | undefined;
             title?: string | undefined;
         } | {
@@ -162,8 +165,8 @@ export declare class YNABMCPServer {
         })[];
         _meta?: {
             [x: string]: unknown;
+            progressToken?: string | number | undefined;
             "io.modelcontextprotocol/related-task"?: {
-                [x: string]: unknown;
                 taskId: string;
             } | undefined;
         } | undefined;
@@ -235,6 +238,7 @@ export declare class YNABMCPServer {
                 src: string;
                 mimeType?: string | undefined;
                 sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
             }[] | undefined;
             title?: string | undefined;
         } | {
@@ -265,8 +269,8 @@ export declare class YNABMCPServer {
         })[];
         _meta?: {
             [x: string]: unknown;
+            progressToken?: string | number | undefined;
             "io.modelcontextprotocol/related-task"?: {
-                [x: string]: unknown;
                 taskId: string;
             } | undefined;
         } | undefined;
@@ -311,6 +315,7 @@ export declare class YNABMCPServer {
                 src: string;
                 mimeType?: string | undefined;
                 sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
             }[] | undefined;
             title?: string | undefined;
         }[];

package/dist/server/YNABMCPServer.js

@@ -3,7 +3,7 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import fs from 'fs';
 import path from 'path';
 import { z } from 'zod';
-import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListPromptsRequestSchema, ReadResourceRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListResourceTemplatesRequestSchema, ListPromptsRequestSchema, ReadResourceRequestSchema, GetPromptRequestSchema, CompleteRequestSchema, ErrorCode, McpError, } from '@modelcontextprotocol/sdk/types.js';
 import * as ynab from 'ynab';
 import { AuthenticationError, ConfigurationError, ValidationError as ConfigValidationError, } from '../utils/errors.js';
 import { ValidationError } from '../types/index.js';
@@ -30,6 +30,7 @@ import { ServerKnowledgeStore } from './serverKnowledgeStore.js';
 import { DeltaCache } from './deltaCache.js';
 import { DeltaFetcher } from '../tools/deltaFetcher.js';
 import { ToolAnnotationPresets } from '../tools/toolCategories.js';
+import { CompletionsManager } from './completions.js';
 export class YNABMCPServer {
     constructor(exitOnError = true) {
         this.exitOnError = exitOnError;
@@ -42,9 +43,13 @@ export class YNABMCPServer {
             version: this.serverVersion,
         }, {
             capabilities: {
-                tools: { listChanged: true },
-                resources: { listChanged: true },
-                prompts: { listChanged: true },
+                tools: { listChanged: false },
+                resources: {
+                    subscribe: false,
+                    listChanged: false,
+                },
+                prompts: { listChanged: false },
+                completions: {},
             },
         });
         this.errorHandler = createErrorHandler(responseFormatter);
@@ -111,6 +116,7 @@ export class YNABMCPServer {
             serverKnowledgeStore: this.serverKnowledgeStore,
             deltaCache: this.deltaCache,
         });
+        this.completionsManager = new CompletionsManager(this.ynabAPI, cacheManager, () => this.defaultBudgetId);
         this.setupToolRegistry();
         this.setupHandlers();
     }
@@ -162,12 +168,7 @@ export class YNABMCPServer {
         });
         this.server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
             const { uri } = request.params;
-            try {
-                return await this.resourceManager.readResource(uri);
-            }
-            catch (error) {
-                return this.errorHandler.handleError(error, `reading resource: ${uri}`);
-            }
+            return await this.resourceManager.readResource(uri);
         });
         this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
             return this.promptManager.listPrompts();
@@ -182,7 +183,10 @@ export class YNABMCPServer {
                 tools: this.toolRegistry.listTools(),
             };
         });
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+            if (!this.toolRegistry.hasTool(request.params.name)) {
+                throw new McpError(ErrorCode.InvalidParams, `Unknown tool: ${request.params.name}`);
+            }
             const rawArgs = (request.params.arguments ?? undefined);
             const minifyOverride = this.extractMinifyOverride(rawArgs);
             const sanitizedArgs = rawArgs
@@ -202,8 +206,35 @@ export class YNABMCPServer {
             if (minifyOverride !== undefined) {
                 executionOptions.minifyOverride = minifyOverride;
             }
+            const progressToken = request.params
+                ._meta?.progressToken;
+            if (progressToken !== undefined && extra.sendNotification) {
+                executionOptions.sendProgress = async (params) => {
+                    try {
+                        await extra.sendNotification({
+                            method: 'notifications/progress',
+                            params: {
+                                progressToken,
+                                progress: params.progress,
+                                ...(params.total !== undefined && { total: params.total }),
+                                ...(params.message !== undefined && { message: params.message }),
+                            },
+                        });
+                    }
+                    catch {
+                    }
+                };
+            }
             return await this.toolRegistry.executeTool(executionOptions);
         });
+        this.server.setRequestHandler(CompleteRequestSchema, async (request) => {
+            const { argument, context } = request.params;
+            const completionContext = context?.arguments ? { arguments: context.arguments } : undefined;
+            const result = await this.completionsManager.getCompletions(argument.name, argument.value, completionContext);
+            return {
+                completion: result.completion,
+            };
+        });
     }
     setupToolRegistry() {
         const register = (definition) => {

package/dist/server/cacheManager.js

@@ -79,14 +79,15 @@ export class CacheManager {
         else {
             const providedTtl = ttlOrOptions?.ttl;
             ttl = providedTtl !== undefined ? providedTtl : this.defaultTTL;
-            if (ttlOrOptions && 'staleWhileRevalidate' in ttlOrOptions) {
+            const hasStaleWhileRevalidate = ttlOrOptions !== undefined && 'staleWhileRevalidate' in ttlOrOptions;
+            if (hasStaleWhileRevalidate) {
                 staleWhileRevalidate = ttlOrOptions.staleWhileRevalidate;
+                if (staleWhileRevalidate === undefined && this.defaultStaleWindow > 0) {
+                    staleWhileRevalidate = this.defaultStaleWindow;
+                }
             }
             else {
-                staleWhileRevalidate = ttlOrOptions?.staleWhileRevalidate;
-            }
-            if (staleWhileRevalidate === undefined && this.defaultStaleWindow > 0) {
-                staleWhileRevalidate = this.defaultStaleWindow;
+                staleWhileRevalidate = undefined;
             }
         }
         const entry = {

package/dist/server/completions.d.ts

@@ -0,0 +1,25 @@
+import type * as ynab from 'ynab';
+import type { CacheManager } from './cacheManager.js';
+export interface CompletionResult {
+    completion: {
+        values: string[];
+        total?: number;
+        hasMore?: boolean;
+    };
+}
+interface CompletionContext {
+    arguments?: Record<string, string> | undefined;
+}
+export declare class CompletionsManager {
+    private readonly ynabAPI;
+    private readonly cacheManager;
+    private readonly getDefaultBudgetId;
+    constructor(ynabAPI: ynab.API, cacheManager: CacheManager, getDefaultBudgetId: () => string | undefined);
+    getCompletions(argumentName: string, value: string, context?: CompletionContext): Promise<CompletionResult>;
+    private completeBudgets;
+    private completeAccounts;
+    private completeCategories;
+    private completePayees;
+    private filterAndFormat;
+}
+export {};

package/dist/server/completions.js

@@ -0,0 +1,160 @@
+import { CACHE_TTLS } from './cacheManager.js';
+const MAX_COMPLETIONS = 100;
+export class CompletionsManager {
+    constructor(ynabAPI, cacheManager, getDefaultBudgetId) {
+        this.ynabAPI = ynabAPI;
+        this.cacheManager = cacheManager;
+        this.getDefaultBudgetId = getDefaultBudgetId;
+    }
+    async getCompletions(argumentName, value, context) {
+        const normalizedName = argumentName.toLowerCase();
+        switch (normalizedName) {
+            case 'budget_id':
+                return this.completeBudgets(value);
+            case 'account_id':
+            case 'account_name':
+                return this.completeAccounts(value, context);
+            case 'category':
+            case 'category_id':
+                return this.completeCategories(value, context);
+            case 'payee':
+            case 'payee_id':
+                return this.completePayees(value, context);
+            default:
+                return { completion: { values: [], total: 0, hasMore: false } };
+        }
+    }
+    async completeBudgets(value) {
+        const budgets = await this.cacheManager.wrap('completions:budgets', {
+            ttl: CACHE_TTLS.BUDGETS,
+            loader: async () => {
+                const response = await this.ynabAPI.budgets.getBudgets();
+                return response.data.budgets.map((b) => ({
+                    id: b.id,
+                    name: b.name,
+                }));
+            },
+        });
+        return this.filterAndFormat(budgets, value, (b) => [b.name, b.id]);
+    }
+    async completeAccounts(value, context) {
+        const budgetId = context?.arguments?.['budget_id'] ?? this.getDefaultBudgetId();
+        if (!budgetId) {
+            return { completion: { values: [], total: 0, hasMore: false } };
+        }
+        const accounts = await this.cacheManager.wrap(`completions:accounts:${budgetId}`, {
+            ttl: CACHE_TTLS.ACCOUNTS,
+            loader: async () => {
+                const response = await this.ynabAPI.accounts.getAccounts(budgetId);
+                return response.data.accounts
+                    .filter((a) => !a.deleted && !a.closed)
+                    .map((a) => ({
+                    id: a.id,
+                    name: a.name,
+                }));
+            },
+        });
+        return this.filterAndFormat(accounts, value, (a) => [a.name, a.id]);
+    }
+    async completeCategories(value, context) {
+        const budgetId = context?.arguments?.['budget_id'] ?? this.getDefaultBudgetId();
+        if (!budgetId) {
+            return { completion: { values: [], total: 0, hasMore: false } };
+        }
+        const categories = await this.cacheManager.wrap(`completions:categories:${budgetId}`, {
+            ttl: CACHE_TTLS.CATEGORIES,
+            loader: async () => {
+                const response = await this.ynabAPI.categories.getCategories(budgetId);
+                const result = [];
+                for (const group of response.data.category_groups) {
+                    if (group.hidden || group.deleted)
+                        continue;
+                    for (const cat of group.categories) {
+                        if (cat.hidden || cat.deleted)
+                            continue;
+                        result.push({
+                            id: cat.id,
+                            name: cat.name,
+                            group: group.name,
+                        });
+                    }
+                }
+                return result;
+            },
+        });
+        return this.filterAndFormat(categories, value, (c) => [c.name, `${c.group}: ${c.name}`, c.id]);
+    }
+    async completePayees(value, context) {
+        const budgetId = context?.arguments?.['budget_id'] ?? this.getDefaultBudgetId();
+        if (!budgetId) {
+            return { completion: { values: [], total: 0, hasMore: false } };
+        }
+        const payees = await this.cacheManager.wrap(`completions:payees:${budgetId}`, {
+            ttl: CACHE_TTLS.PAYEES,
+            loader: async () => {
+                const response = await this.ynabAPI.payees.getPayees(budgetId);
+                return response.data.payees
+                    .filter((p) => !p.deleted)
+                    .map((p) => ({
+                    id: p.id,
+                    name: p.name,
+                }));
+            },
+        });
+        return this.filterAndFormat(payees, value, (p) => [p.name, p.id]);
+    }
+    filterAndFormat(items, value, getSearchableValues) {
+        const lowerValue = value.toLowerCase();
+        const itemCache = new Map();
+        const getCachedValues = (item) => {
+            let cached = itemCache.get(item);
+            if (!cached) {
+                const values = getSearchableValues(item);
+                cached = { values, lowerValues: values.map((v) => v.toLowerCase()) };
+                itemCache.set(item, cached);
+            }
+            return cached;
+        };
+        const matches = items.filter((item) => {
+            const { lowerValues } = getCachedValues(item);
+            return lowerValues.some((v) => v.includes(lowerValue));
+        });
+        matches.sort((a, b) => {
+            const aCache = getCachedValues(a);
+            const bCache = getCachedValues(b);
+            const aStartsWith = aCache.lowerValues.some((v) => v.startsWith(lowerValue));
+            const bStartsWith = bCache.lowerValues.some((v) => v.startsWith(lowerValue));
+            if (aStartsWith && !bStartsWith)
+                return -1;
+            if (!aStartsWith && bStartsWith)
+                return 1;
+            return (aCache.values[0] ?? '').localeCompare(bCache.values[0] ?? '');
+        });
+        const uniqueValues = new Set();
+        for (const item of matches) {
+            const { values, lowerValues } = getCachedValues(item);
+            let selectedValue;
+            for (let i = 0; i < values.length; i++) {
+                if (lowerValues[i]?.includes(lowerValue)) {
+                    if (selectedValue === undefined || i < values.indexOf(selectedValue)) {
+                        selectedValue = values[i];
+                    }
+                    break;
+                }
+            }
+            if (selectedValue) {
+                uniqueValues.add(selectedValue);
+            }
+            if (uniqueValues.size >= MAX_COMPLETIONS)
+                break;
+        }
+        const resultValues = Array.from(uniqueValues).slice(0, MAX_COMPLETIONS);
+        return {
+            completion: {
+                values: resultValues,
+                total: matches.length,
+                hasMore: matches.length > MAX_COMPLETIONS,
+            },
+        };
+    }
+}

package/dist/server/config.d.ts

@@ -5,10 +5,10 @@ declare const envSchema: z.ZodObject<{
     YNAB_DEFAULT_BUDGET_ID: z.ZodOptional<z.ZodString>;
     MCP_PORT: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
     LOG_LEVEL: z.ZodDefault<z.ZodEnum<{
+        debug: "debug";
         error: "error";
         warn: "warn";
         info: "info";
-        debug: "debug";
         trace: "trace";
         fatal: "fatal";
     }>>;
@@ -17,7 +17,7 @@ export type AppConfig = z.infer<typeof envSchema>;
 export declare function loadConfig(env?: NodeJS.ProcessEnv): AppConfig;
 export declare const config: {
     YNAB_ACCESS_TOKEN: string;
-    LOG_LEVEL: "error" | "warn" | "info" | "debug" | "trace" | "fatal";
+    LOG_LEVEL: "debug" | "error" | "warn" | "info" | "trace" | "fatal";
     YNAB_DEFAULT_BUDGET_ID?: string | undefined;
     MCP_PORT?: number | undefined;
 };

package/dist/server/errorHandler.js

@@ -44,6 +44,7 @@ export class ErrorHandler {
             }
         }
         return {
+            isError: true,
             content: [
                 {
                     type: 'text',

package/dist/server/rateLimiter.js

@@ -78,5 +78,7 @@ export class RateLimitError extends Error {
     }
 }
 export const globalRateLimiter = new RateLimiter({
-    enableLogging: process.env['NODE_ENV'] !== 'production',
+    enableLogging: process.env['RATE_LIMIT_LOGGING'] === 'true' ||
+        process.env['LOG_LEVEL'] === 'debug' ||
+        process.env['VERBOSE_TESTS'] === 'true',
 });

package/dist/server/resources.d.ts

@@ -37,6 +37,7 @@ export declare class ResourceManager {
     readResource(uri: string): Promise<{
         contents: ResourceContents[];
     }>;
+    private executeResourceHandler;
     private matchTemplate;
     private validateTemplateDefinition;
 }

package/dist/server/resources.js

@@ -1,4 +1,6 @@
+import { ErrorCode, McpError, } from '@modelcontextprotocol/sdk/types.js';
 import { CacheManager, CACHE_TTLS } from './cacheManager.js';
+const RESOURCE_NOT_FOUND_ERROR_CODE = -32002;
 const defaultResourceHandlers = {
     'ynab://budgets': async (uri, { ynabAPI, responseFormatter, cacheManager }) => {
         const cacheKey = CacheManager.generateKey('resources', 'budgets', 'list');
@@ -79,8 +81,9 @@ const defaultResourceTemplates = [
         mimeType: 'application/json',
         handler: async (uri, params, { ynabAPI, responseFormatter, cacheManager }) => {
             const budget_id = params['budget_id'];
-            if (!budget_id)
-                throw new Error('Missing budget_id parameter');
+            if (!budget_id) {
+                throw new McpError(ErrorCode.InvalidParams, 'Missing budget_id parameter');
+            }
             const cacheKey = CacheManager.generateKey('resources', 'budgets', 'get', budget_id);
             return cacheManager.wrap(cacheKey, {
                 ttl: CACHE_TTLS.BUDGETS,
@@ -110,8 +113,9 @@ const defaultResourceTemplates = [
         mimeType: 'application/json',
         handler: async (uri, params, { ynabAPI, responseFormatter, cacheManager }) => {
             const budget_id = params['budget_id'];
-            if (!budget_id)
-                throw new Error('Missing budget_id parameter');
+            if (!budget_id) {
+                throw new McpError(ErrorCode.InvalidParams, 'Missing budget_id parameter');
+            }
             const cacheKey = CacheManager.generateKey('resources', 'accounts', 'list', budget_id);
             return cacheManager.wrap(cacheKey, {
                 ttl: CACHE_TTLS.ACCOUNTS,
@@ -142,10 +146,12 @@ const defaultResourceTemplates = [
         handler: async (uri, params, { ynabAPI, responseFormatter, cacheManager }) => {
             const budget_id = params['budget_id'];
             const account_id = params['account_id'];
-            if (!budget_id)
-                throw new Error('Missing budget_id parameter');
-            if (!account_id)
-                throw new Error('Missing account_id parameter');
+            if (!budget_id) {
+                throw new McpError(ErrorCode.InvalidParams, 'Missing budget_id parameter');
+            }
+            if (!account_id) {
+                throw new McpError(ErrorCode.InvalidParams, 'Missing account_id parameter');
+            }
             const cacheKey = CacheManager.generateKey('resources', 'accounts', 'get', budget_id, account_id);
             return cacheManager.wrap(cacheKey, {
                 ttl: CACHE_TTLS.ACCOUNTS,
@@ -208,20 +214,31 @@ export class ResourceManager {
     async readResource(uri) {
         const handler = this.resourceHandlers[uri];
         if (handler) {
-            return { contents: await handler(uri, this.dependencies) };
+            return {
+                contents: await this.executeResourceHandler(() => handler(uri, this.dependencies), `resource ${uri}`),
+            };
         }
         for (const template of this.resourceTemplates) {
             const params = this.matchTemplate(template.uriTemplate, uri);
             if (params) {
-                try {
-                    return { contents: await template.handler(uri, params, this.dependencies) };
-                }
-                catch (error) {
-                    throw new Error(`Failed to resolve template resource ${uri}: ${error instanceof Error ? error.message : String(error)}`);
-                }
+                return {
+                    contents: await this.executeResourceHandler(() => template.handler(uri, params, this.dependencies), `resource ${uri}`),
+                };
+            }
+        }
+        throw new McpError(RESOURCE_NOT_FOUND_ERROR_CODE, `Resource not found: ${uri}`);
+    }
+    async executeResourceHandler(handler, label) {
+        try {
+            return await handler();
+        }
+        catch (error) {
+            if (error instanceof McpError) {
+                throw error;
             }
+            const message = error instanceof Error ? error.message : String(error);
+            throw new McpError(ErrorCode.InternalError, `Failed to read ${label}: ${message}`);
         }
-        throw new Error(`Unknown resource: ${uri}`);
     }
     matchTemplate(template, uri) {
         if (!/^[a-z0-9:/\-_{}]+$/i.test(template)) {

package/dist/server/securityMiddleware.d.ts

@@ -74,6 +74,7 @@ export declare function withSecurityWrapper<T extends Record<string, unknown>>(t
             src: string;
             mimeType?: string | undefined;
             sizes?: string[] | undefined;
+            theme?: "light" | "dark" | undefined;
         }[] | undefined;
         title?: string | undefined;
     } | {
@@ -104,8 +105,8 @@ export declare function withSecurityWrapper<T extends Record<string, unknown>>(t
     })[];
     _meta?: {
         [x: string]: unknown;
+        progressToken?: string | number | undefined;
         "io.modelcontextprotocol/related-task"?: {
-            [x: string]: unknown;
             taskId: string;
         } | undefined;
     } | undefined;

package/dist/server/securityMiddleware.js

@@ -58,6 +58,7 @@ export class SecurityMiddleware {
     }
     static createRateLimitErrorResponse(error) {
         return {
+            isError: true,
             content: [
                 {
                     type: 'text',

package/dist/server/toolRegistry.d.ts

@@ -32,12 +32,18 @@ export interface ToolMetadataOptions {
     inputJsonSchema?: Record<string, unknown>;
     annotations?: MCPToolAnnotations;
 }
+export type ProgressCallback = (params: {
+    progress: number;
+    total?: number;
+    message?: string;
+}) => Promise<void>;
 export interface ToolExecutionContext {
     accessToken: string;
     name: string;
     operation: string;
     rawArguments: Record<string, unknown>;
     cache?: ToolRegistryCacheHelpers;
+    sendProgress?: ProgressCallback;
 }
 export interface ToolExecutionPayload<TInput extends Record<string, unknown>> {
     input: TInput;
@@ -59,6 +65,7 @@ export interface ToolExecutionOptions {
     accessToken: string;
     arguments?: Record<string, unknown>;
     minifyOverride?: boolean;
+    sendProgress?: ProgressCallback;
 }
 export interface ToolRegistryDependencies {
     withSecurityWrapper: SecurityWrapperFactory;
@@ -74,11 +81,13 @@ export declare class ToolRegistry {
     constructor(deps: ToolRegistryDependencies);
     register<TInput extends Record<string, unknown>, TOutput extends Record<string, unknown>>(definition: ToolDefinition<TInput, TOutput>): void;
     listTools(): Tool[];
+    hasTool(name: string): boolean;
     getToolDefinitions(): ToolDefinition[];
     executeTool(options: ToolExecutionOptions): Promise<CallToolResult>;
     private isCallToolResult;
     private normalizeSecurityError;
     private extractMinifyOverride;
+    private static readonly MCP_TOOL_NAME_REGEX;
     private assertValidDefinition;
     private generateJsonSchema;
     private validateOutput;

package/dist/server/toolRegistry.js

@@ -51,6 +51,9 @@ export class ToolRegistry {
             return result;
         });
     }
+    hasTool(name) {
+        return this.tools.has(name);
+    }
     getToolDefinitions() {
         return Array.from(this.tools.values()).map((tool) => {
             const definition = {
@@ -128,6 +131,9 @@ export class ToolRegistry {
                         if (this.deps.cacheHelpers) {
                             context.cache = this.deps.cacheHelpers;
                         }
+                        if (options.sendProgress) {
+                            context.sendProgress = options.sendProgress;
+                        }
                         const handlerResult = await tool.handler({
                             input: validated,
                             context,
@@ -189,6 +195,10 @@ export class ToolRegistry {
         if (!definition.name || typeof definition.name !== 'string') {
             throw new Error('Tool definition requires a non-empty name');
         }
+        if (!ToolRegistry.MCP_TOOL_NAME_REGEX.test(definition.name)) {
+            throw new Error(`Tool name '${definition.name}' violates MCP guidelines: ` +
+                `must be 1-128 chars using only [a-zA-Z0-9_.-]`);
+        }
         if (!definition.description || typeof definition.description !== 'string') {
             throw new Error(`Tool '${definition.name}' requires a description`);
         }
@@ -268,3 +278,4 @@ export class ToolRegistry {
         return output;
     }
 }
+ToolRegistry.MCP_TOOL_NAME_REGEX = /^[a-zA-Z0-9_.-]{1,128}$/;

package/dist/tools/adapters.d.ts

@@ -1,10 +1,12 @@
 import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import type { ToolExecutionPayload, DefaultArgumentResolver } from '../server/toolRegistry.js';
+import type { ToolExecutionPayload, DefaultArgumentResolver, ProgressCallback } from '../server/toolRegistry.js';
 import type { ToolContext, Handler, DeltaHandler, WriteHandler, NoInputHandler } from '../types/toolRegistration.js';
+import type { DeltaFetcher } from './deltaFetcher.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>;
+    adaptWithDeltaAndProgress: <TInput extends Record<string, unknown>>(handler: (api: import("ynab").API, deltaFetcher: DeltaFetcher, params: TInput, sendProgress?: ProgressCallback) => Promise<CallToolResult>) => ({ input, context }: 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 {

package/dist/tools/adapters.js

@@ -6,6 +6,7 @@ export function createAdapters(context) {
         adapt: (handler) => async ({ input }) => handler(ynabAPI, input),
         adaptNoInput: (handler) => async (_payload) => handler(ynabAPI),
         adaptWithDelta: (handler) => async ({ input }) => handler(ynabAPI, deltaFetcher, input),
+        adaptWithDeltaAndProgress: (handler) => async ({ input, context }) => handler(ynabAPI, deltaFetcher, input, context.sendProgress),
         adaptWrite: (handler) => async ({ input }) => handler(ynabAPI, deltaCache, serverKnowledgeStore, input),
     };
 }

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

@@ -1,4 +1,5 @@
 import type * as ynab from 'ynab';
+import type { ProgressCallback } from '../../server/toolRegistry.js';
 import type { ReconciliationAnalysis } from './types.js';
 import type { ReconcileAccountRequest } from './index.js';
 export interface AccountSnapshot {
@@ -14,6 +15,7 @@ export interface ExecutionOptions {
     accountId: string;
     initialAccount: AccountSnapshot;
     currencyCode: string;
+    sendProgress?: ProgressCallback;
 }
 export interface ExecutionActionRecord {
     type: string;