@dizzlkheinz/ynab-mcpb 0.18.4 → 0.19.0

package/dist/index.d.ts

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import 'dotenv/config';
+import "dotenv/config";

package/dist/index.js

@@ -1,74 +1,74 @@
 #!/usr/bin/env node
-import 'dotenv/config';
-import { YNABMCPServer } from './server/YNABMCPServer.js';
-import { AuthenticationError, ConfigurationError, ValidationError } from './utils/errors.js';
+import "dotenv/config";
+import { YNABMCPServer } from "./server/YNABMCPServer.js";
+import { AuthenticationError, ConfigurationError, ValidationError, } from "./utils/errors.js";
 let serverInstance = null;
 async function gracefulShutdown(signal) {
     console.error(`Received ${signal}, initiating graceful shutdown...`);
     try {
         if (serverInstance) {
-            console.error('Cleaning up server resources...');
+            console.error("Cleaning up server resources...");
             serverInstance = null;
         }
-        console.error('Shutdown complete');
+        console.error("Shutdown complete");
         process.exit(0);
     }
     catch (error) {
-        console.error('Error during shutdown:', error);
+        console.error("Error during shutdown:", error);
         process.exit(1);
     }
 }
 function reportError(error) {
     if (error instanceof ValidationError) {
-        console.error('❌ Validation Error:', error.message);
-        console.error('Please check your inputs and try again.');
+        console.error("❌ Validation Error:", error.message);
+        console.error("Please check your inputs and try again.");
         process.exit(1);
     }
     else if (error instanceof AuthenticationError) {
-        console.error('❌ Authentication Error:', error.message);
-        console.error('Please verify your YNAB access token and try again.');
+        console.error("❌ Authentication Error:", error.message);
+        console.error("Please verify your YNAB access token and try again.");
         process.exit(1);
     }
     else if (error instanceof ConfigurationError) {
-        console.error('❌ Configuration Error:', error.message);
-        console.error('Please check your environment variables and try again.');
+        console.error("❌ Configuration Error:", error.message);
+        console.error("Please check your environment variables and try again.");
         process.exit(1);
     }
     else if (error instanceof Error) {
-        console.error('❌ Server Error:', error.message);
-        if (process.env['NODE_ENV'] === 'development') {
-            console.error('Stack trace:', error.stack);
+        console.error("❌ Server Error:", error.message);
+        if (process.env["NODE_ENV"] === "development") {
+            console.error("Stack trace:", error.stack);
         }
         process.exit(1);
     }
     else {
-        console.error('❌ Unknown error:', error);
+        console.error("❌ Unknown error:", error);
         process.exit(1);
     }
 }
 async function main() {
     try {
-        console.error('🚀 Starting YNAB MCP Server...');
+        console.error("🚀 Starting YNAB MCP Server...");
         serverInstance = new YNABMCPServer();
-        console.error('✅ Server instance created successfully');
+        console.error("✅ Server instance created successfully");
         await serverInstance.run();
-        console.error('✅ YNAB MCP Server started successfully');
+        console.error("✅ YNAB MCP Server started successfully");
     }
     catch (error) {
         reportError(error);
     }
 }
-process.on('SIGINT', () => gracefulShutdown('SIGINT'));
-process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
-process.on('uncaughtException', (error) => {
-    console.error('❌ Uncaught Exception:', error);
-    if (process.env['NODE_ENV'] === 'development') {
-        console.error('Stack trace:', error.stack);
+process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+process.on("uncaughtException", (error) => {
+    console.error("❌ Uncaught Exception:", error);
+    if (process.env["NODE_ENV"] === "development") {
+        console.error("Stack trace:", error.stack);
     }
     process.exit(1);
 });
-process.on('unhandledRejection', (reason, promise) => {
-    console.error('❌ Unhandled Promise Rejection at:', promise, 'reason:', reason);
+process.on("unhandledRejection", (reason, promise) => {
+    console.error("❌ Unhandled Promise Rejection at:", promise, "reason:", reason);
     process.exit(1);
 });
 main().catch(reportError);

package/dist/server/YNABMCPServer.d.ts

@@ -1,6 +1,6 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import * as ynab from 'ynab';
-import { ToolRegistry } from './toolRegistry.js';
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import * as ynab from "ynab";
+import { ToolRegistry } from "./toolRegistry.js";
 export declare class YNABMCPServer {
     private server;
     private ynabAPI;
@@ -30,7 +30,6 @@ export declare class YNABMCPServer {
     getDefaultBudget(): string | undefined;
     clearDefaultBudget(): void;
     getToolRegistry(): ToolRegistry;
-    getBudgetId(providedBudgetId?: string): string;
     private warmCacheForBudget;
     handleListTools(): Promise<{
         tools: {

package/dist/server/YNABMCPServer.js

@@ -1,45 +1,44 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-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, 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';
-import { loadConfig } from './config.js';
-import { createErrorHandler, ErrorHandler } from './errorHandler.js';
-import { BudgetResolver } from './budgetResolver.js';
-import { SecurityMiddleware, withSecurityWrapper } from './securityMiddleware.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 } from './toolRegistry.js';
-import { ResourceManager } from './resources.js';
-import { PromptManager } from './prompts.js';
-import { DiagnosticManager } from './diagnostics.js';
-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';
+import fs from "node:fs";
+import path from "node:path";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, CompleteRequestSchema, ErrorCode, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourceTemplatesRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, McpError, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import * as ynab from "ynab";
+import { z } from "zod";
+import { registerAccountTools } from "../tools/accountTools.js";
+import { registerBudgetTools } from "../tools/budgetTools.js";
+import { registerCategoryTools } from "../tools/categoryTools.js";
+import { DeltaFetcher } from "../tools/deltaFetcher.js";
+import { registerMonthTools } from "../tools/monthTools.js";
+import { registerPayeeTools } from "../tools/payeeTools.js";
+import { registerReconciliationTools } from "../tools/reconciliation/index.js";
+import { emptyObjectSchema } from "../tools/schemas/common.js";
+import { ToolAnnotationPresets } from "../tools/toolCategories.js";
+import { registerTransactionTools } from "../tools/transactionTools.js";
+import { registerUtilityTools } from "../tools/utilityTools.js";
+import { ValidationError, YNABErrorCode } from "../types/index.js";
+import { AuthenticationError, ValidationError as ConfigValidationError, ConfigurationError, } from "../utils/errors.js";
+import { CacheManager, cacheManager } from "./cacheManager.js";
+import { CompletionsManager } from "./completions.js";
+import { loadConfig } from "./config.js";
+import { DeltaCache } from "./deltaCache.js";
+import { DiagnosticManager } from "./diagnostics.js";
+import { createErrorHandler } from "./errorHandler.js";
+import { PromptManager } from "./prompts.js";
+import { ResourceManager } from "./resources.js";
+import { responseFormatter } from "./responseFormatter.js";
+import { SecurityMiddleware, withSecurityWrapper, } from "./securityMiddleware.js";
+import { ServerKnowledgeStore } from "./serverKnowledgeStore.js";
+import { ToolRegistry, } from "./toolRegistry.js";
 export class YNABMCPServer {
     constructor(exitOnError = true) {
         this.exitOnError = exitOnError;
         this.configInstance = loadConfig();
         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.serverVersion = this.readPackageVersion() ?? "0.0.0";
         this.server = new Server({
-            name: 'ynab-mcp-server',
+            name: "ynab-mcp-server",
             version: this.serverVersion,
         }, {
             capabilities: {
@@ -53,7 +52,6 @@ export class YNABMCPServer {
             },
         });
         this.errorHandler = createErrorHandler(responseFormatter);
-        ErrorHandler.setFormatter(responseFormatter);
         this.toolRegistry = new ToolRegistry({
             withSecurityWrapper,
             errorHandler: this.errorHandler,
@@ -61,15 +59,15 @@ export class YNABMCPServer {
             cacheHelpers: {
                 generateKey: (...segments) => {
                     const normalized = segments.map((segment) => {
-                        if (typeof segment === 'string' ||
-                            typeof segment === 'number' ||
-                            typeof segment === 'boolean' ||
+                        if (typeof segment === "string" ||
+                            typeof segment === "number" ||
+                            typeof segment === "boolean" ||
                             segment === undefined) {
                             return segment;
                         }
                         return JSON.stringify(segment);
                     });
-                    return CacheManager.generateKey('tool', ...normalized);
+                    return CacheManager.generateKey("tool", ...normalized);
                 },
                 invalidate: (key) => {
                     try {
@@ -84,18 +82,18 @@ export class YNABMCPServer {
                         cacheManager.clear();
                     }
                     catch (error) {
-                        console.error('Failed to clear cache:', error);
+                        console.error("Failed to clear cache:", error);
                     }
                 },
             },
             validateAccessToken: (token) => {
                 const expected = this.configInstance.YNAB_ACCESS_TOKEN.trim();
-                const provided = typeof token === 'string' ? token.trim() : '';
+                const provided = typeof token === "string" ? token.trim() : "";
                 if (!provided) {
-                    throw this.errorHandler.createYNABError(401, 'validating access token', new Error('Missing access token'));
+                    throw this.errorHandler.createYNABError(YNABErrorCode.UNAUTHORIZED, "validating access token", new Error("Missing access token"));
                 }
                 if (provided !== expected) {
-                    throw this.errorHandler.createYNABError(401, 'validating access token', new Error('Access token mismatch'));
+                    throw this.errorHandler.createYNABError(YNABErrorCode.UNAUTHORIZED, "validating access token", new Error("Access token mismatch"));
                 }
             },
         });
@@ -127,14 +125,16 @@ export class YNABMCPServer {
         }
         catch (error) {
             if (this.isMalformedTokenResponse(error)) {
-                throw new AuthenticationError('Unexpected response from YNAB during token validation');
+                throw new AuthenticationError("Unexpected response from YNAB during token validation");
             }
             if (error instanceof Error) {
-                if (error.message.includes('401') || error.message.includes('Unauthorized')) {
-                    throw new AuthenticationError('Invalid or expired YNAB access token');
+                if (error.message.includes("401") ||
+                    error.message.includes("Unauthorized")) {
+                    throw new AuthenticationError("Invalid or expired YNAB access token");
                 }
-                if (error.message.includes('403') || error.message.includes('Forbidden')) {
-                    throw new AuthenticationError('YNAB access token has insufficient permissions');
+                if (error.message.includes("403") ||
+                    error.message.includes("Forbidden")) {
+                    throw new AuthenticationError("YNAB access token has insufficient permissions");
                 }
                 const reason = error.message || String(error);
                 throw new AuthenticationError(`Token validation failed: ${reason}`);
@@ -146,18 +146,18 @@ export class YNABMCPServer {
         if (error instanceof SyntaxError) {
             return true;
         }
-        const message = typeof error === 'string'
+        const message = typeof error === "string"
             ? error
-            : typeof error?.message === 'string'
+            : typeof error?.message === "string"
                 ? String(error.message)
                 : null;
         if (!message) {
             return false;
         }
         const normalized = message.toLowerCase();
-        return (normalized.includes('unexpected token') ||
-            normalized.includes('unexpected end of json') ||
-            normalized.includes('<html'));
+        return (normalized.includes("unexpected token") ||
+            normalized.includes("unexpected end of json") ||
+            normalized.includes("<html"));
     }
     setupHandlers() {
         this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
@@ -192,9 +192,9 @@ export class YNABMCPServer {
             const sanitizedArgs = rawArgs
                 ? (() => {
                     const clone = { ...rawArgs };
-                    delete clone['minify'];
-                    delete clone['_minify'];
-                    delete clone['__minify'];
+                    clone["minify"] = undefined;
+                    clone["_minify"] = undefined;
+                    clone["__minify"] = undefined;
                     return clone;
                 })()
                 : undefined;
@@ -206,18 +206,19 @@ export class YNABMCPServer {
             if (minifyOverride !== undefined) {
                 executionOptions.minifyOverride = minifyOverride;
             }
-            const progressToken = request.params
-                ._meta?.progressToken;
+            const progressToken = request.params._meta?.progressToken;
             if (progressToken !== undefined && extra.sendNotification) {
                 executionOptions.sendProgress = async (params) => {
                     try {
                         await extra.sendNotification({
-                            method: 'notifications/progress',
+                            method: "notifications/progress",
                             params: {
                                 progressToken,
                                 progress: params.progress,
                                 ...(params.total !== undefined && { total: params.total }),
-                                ...(params.message !== undefined && { message: params.message }),
+                                ...(params.message !== undefined && {
+                                    message: params.message,
+                                }),
                             },
                         });
                     }
@@ -229,7 +230,9 @@ export class YNABMCPServer {
         });
         this.server.setRequestHandler(CompleteRequestSchema, async (request) => {
             const { argument, context } = request.params;
-            const completionContext = context?.arguments ? { arguments: context.arguments } : undefined;
+            const completionContext = context?.arguments
+                ? { arguments: context.arguments }
+                : undefined;
             const result = await this.completionsManager.getCompletions(argument.name, argument.value, completionContext);
             return {
                 completion: result.completion,
@@ -248,9 +251,12 @@ export class YNABMCPServer {
             getDefaultBudgetId: () => this.defaultBudgetId,
             setDefaultBudget: (budgetId) => this.setDefaultBudget(budgetId),
             cacheManager,
+            errorHandler: this.errorHandler,
             diagnosticManager: this.diagnosticManager,
         };
-        const setDefaultBudgetSchema = z.object({ budget_id: z.string().min(1) }).strict();
+        const setDefaultBudgetSchema = z
+            .object({ budget_id: z.string().min(1) })
+            .strict();
         const diagnosticInfoSchema = z
             .object({
             include_memory: z.boolean().default(true),
@@ -276,8 +282,8 @@ export class YNABMCPServer {
         registerReconciliationTools(this.toolRegistry, toolContext);
         registerUtilityTools(this.toolRegistry, toolContext);
         register({
-            name: 'set_default_budget',
-            description: 'Set the default budget for subsequent operations',
+            name: "set_default_budget",
+            description: "Set the default budget for subsequent operations",
             inputSchema: setDefaultBudgetSchema,
             handler: async ({ input }) => {
                 const { budget_id } = input;
@@ -288,7 +294,7 @@ export class YNABMCPServer {
                 return {
                     content: [
                         {
-                            type: 'text',
+                            type: "text",
                             text: responseFormatter.format({
                                 success: true,
                                 message: `Default budget set to: ${budget_id}`,
@@ -302,13 +308,13 @@ export class YNABMCPServer {
             metadata: {
                 annotations: {
                     ...ToolAnnotationPresets.WRITE_EXTERNAL_UPDATE,
-                    title: 'YNAB: Set Default Budget',
+                    title: "YNAB: Set Default Budget",
                 },
             },
         });
         register({
-            name: 'get_default_budget',
-            description: 'Get the currently set default budget',
+            name: "get_default_budget",
+            description: "Get the currently set default budget",
             inputSchema: emptyObjectSchema,
             handler: async () => {
                 try {
@@ -316,32 +322,32 @@ export class YNABMCPServer {
                     return {
                         content: [
                             {
-                                type: 'text',
+                                type: "text",
                                 text: responseFormatter.format({
                                     default_budget_id: defaultBudget ?? null,
                                     has_default: !!defaultBudget,
                                     message: defaultBudget
                                         ? `Default budget is set to: ${defaultBudget}`
-                                        : 'No default budget is currently set',
+                                        : "No default budget is currently set",
                                 }),
                             },
                         ],
                     };
                 }
                 catch (error) {
-                    return this.errorHandler.createValidationError('Error getting default budget', error instanceof Error ? error.message : 'Unknown error');
+                    return this.errorHandler.createValidationError("Error getting default budget", error instanceof Error ? error.message : "Unknown error");
                 }
             },
             metadata: {
                 annotations: {
                     ...ToolAnnotationPresets.UTILITY_LOCAL,
-                    title: 'YNAB: Get Default Budget',
+                    title: "YNAB: Get Default Budget",
                 },
             },
         });
         register({
-            name: 'diagnostic_info',
-            description: 'Get comprehensive diagnostic information about the MCP server',
+            name: "diagnostic_info",
+            description: "Get comprehensive diagnostic information about the MCP server",
             inputSchema: diagnosticInfoSchema,
             handler: async ({ input }) => {
                 return this.diagnosticManager.collectDiagnostics(input);
@@ -349,37 +355,39 @@ export class YNABMCPServer {
             metadata: {
                 annotations: {
                     ...ToolAnnotationPresets.UTILITY_LOCAL,
-                    title: 'YNAB: Diagnostic Information',
+                    title: "YNAB: Diagnostic Information",
                 },
             },
         });
         register({
-            name: 'clear_cache',
-            description: 'Clear the in-memory cache (safe, no YNAB data is modified)',
+            name: "clear_cache",
+            description: "Clear the in-memory cache (safe, no YNAB data is modified)",
             inputSchema: emptyObjectSchema,
             handler: async () => {
                 cacheManager.clear();
                 return {
-                    content: [{ type: 'text', text: responseFormatter.format({ success: true }) }],
+                    content: [
+                        { type: "text", text: responseFormatter.format({ success: true }) },
+                    ],
                 };
             },
             metadata: {
                 annotations: {
                     ...ToolAnnotationPresets.UTILITY_LOCAL,
-                    title: 'YNAB: Clear Cache',
+                    title: "YNAB: Clear Cache",
                 },
             },
         });
         register({
-            name: 'set_output_format',
-            description: 'Configure default JSON output formatting (minify or pretty spaces)',
+            name: "set_output_format",
+            description: "Configure default JSON output formatting (minify or pretty spaces)",
             inputSchema: setOutputFormatSchema,
             handler: async ({ input }) => {
                 const options = {};
-                if (typeof input.default_minify === 'boolean') {
+                if (typeof input.default_minify === "boolean") {
                     options.defaultMinify = input.default_minify;
                 }
-                if (typeof input.pretty_spaces === 'number') {
+                if (typeof input.pretty_spaces === "number") {
                     options.prettySpaces = Math.max(0, Math.min(10, Math.floor(input.pretty_spaces)));
                 }
                 responseFormatter.configure(options);
@@ -391,13 +399,17 @@ export class YNABMCPServer {
                     parts.push(`spaces=${options.prettySpaces}`);
                 }
                 const message = parts.length > 0
-                    ? `Output format configured: ${parts.join(', ')}`
-                    : 'Output format configured';
+                    ? `Output format configured: ${parts.join(", ")}`
+                    : "Output format configured";
                 return {
                     content: [
                         {
-                            type: 'text',
-                            text: responseFormatter.format({ success: true, message, options }),
+                            type: "text",
+                            text: responseFormatter.format({
+                                success: true,
+                                message,
+                                options,
+                            }),
                         },
                     ],
                 };
@@ -405,7 +417,7 @@ export class YNABMCPServer {
             metadata: {
                 annotations: {
                     ...ToolAnnotationPresets.UTILITY_LOCAL,
-                    title: 'YNAB: Set Output Format',
+                    title: "YNAB: Set Output Format",
                 },
             },
         });
@@ -414,9 +426,9 @@ export class YNABMCPServer {
         if (!args) {
             return undefined;
         }
-        for (const key of ['minify', '_minify', '__minify']) {
+        for (const key of ["minify", "_minify", "__minify"]) {
             const value = args[key];
-            if (typeof value === 'boolean') {
+            if (typeof value === "boolean") {
                 return value;
             }
         }
@@ -427,14 +439,14 @@ export class YNABMCPServer {
             await this.validateToken();
             const transport = new StdioServerTransport();
             await this.server.connect(transport);
-            console.error('YNAB MCP Server started successfully');
+            console.error("YNAB MCP Server started successfully");
         }
         catch (error) {
             if (error instanceof AuthenticationError ||
                 error instanceof ConfigurationError ||
                 error instanceof ConfigValidationError ||
                 error instanceof ValidationError ||
-                error?.name === 'ValidationError') {
+                error?.name === "ValidationError") {
                 console.error(`Server startup failed: ${error instanceof Error ? error.message : error}`);
                 if (this.exitOnError) {
                     process.exit(1);
@@ -464,23 +476,6 @@ export class YNABMCPServer {
     getToolRegistry() {
         return this.toolRegistry;
     }
-    getBudgetId(providedBudgetId) {
-        const result = BudgetResolver.resolveBudgetId(providedBudgetId, this.defaultBudgetId);
-        if (typeof result === 'string') {
-            return result;
-        }
-        const errorText = result.content?.[0]?.type === 'text' ? result.content[0].text : 'Budget resolution failed';
-        const parsedError = (() => {
-            try {
-                return JSON.parse(errorText);
-            }
-            catch {
-                return { error: { message: errorText } };
-            }
-        })();
-        const message = parsedError.error?.message || 'Budget resolution failed';
-        throw new ValidationError(message);
-    }
     async warmCacheForBudget(budgetId) {
         try {
             await Promise.all([
@@ -526,20 +521,20 @@ export class YNABMCPServer {
         }
     }
     readPackageVersion() {
-        const candidates = [path.resolve(process.cwd(), 'package.json')];
+        const candidates = [path.resolve(process.cwd(), "package.json")];
         try {
             const metaUrl = import.meta?.url;
             if (metaUrl) {
-                const maybe = path.resolve(path.dirname(new URL(metaUrl).pathname), '../../package.json');
+                const maybe = path.resolve(path.dirname(new URL(metaUrl).pathname), "../../package.json");
                 candidates.push(maybe);
             }
         }
         catch {
         }
         try {
-            const dir = typeof __dirname === 'string' ? __dirname : undefined;
+            const dir = typeof __dirname === "string" ? __dirname : undefined;
             if (dir) {
-                candidates.push(path.resolve(dir, '../../package.json'), path.resolve(dir, '../package.json'), path.resolve(dir, 'package.json'));
+                candidates.push(path.resolve(dir, "../../package.json"), path.resolve(dir, "../package.json"), path.resolve(dir, "package.json"));
             }
         }
         catch {
@@ -547,9 +542,9 @@ export class YNABMCPServer {
         for (const p of candidates) {
             try {
                 if (fs.existsSync(p)) {
-                    const raw = fs.readFileSync(p, 'utf8');
+                    const raw = fs.readFileSync(p, "utf8");
                     const pkg = JSON.parse(raw);
-                    if (pkg.version && typeof pkg.version === 'string')
+                    if (pkg.version && typeof pkg.version === "string")
                         return pkg.version;
                 }
             }

package/dist/server/budgetResolver.d.ts

@@ -1,11 +1,12 @@
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { type ErrorHandler } from "./errorHandler.js";
 export declare class BudgetResolver {
     private static readonly UUID_REGEX;
     private static readonly ALLOWED_KEYWORDS;
-    static resolveBudgetId(providedId?: string, defaultId?: string): string | CallToolResult;
-    static validateBudgetId(budgetId: string): string | CallToolResult;
-    static createMissingBudgetError(): CallToolResult;
-    static createInvalidBudgetError(details: string): CallToolResult;
+    static resolveBudgetId(providedId?: string, defaultId?: string, errorHandler?: ErrorHandler): string | CallToolResult;
+    static validateBudgetId(budgetId: string, errorHandler?: ErrorHandler): string | CallToolResult;
+    static createMissingBudgetError(errorHandler?: ErrorHandler): CallToolResult;
+    static createInvalidBudgetError(details: string, errorHandler?: ErrorHandler): CallToolResult;
     static resolveBudgetIdOrThrow(providedId?: string, defaultId?: string): string;
     static validateBudgetIdOrThrow(budgetId: string): string;
 }