@dizzlkheinz/ynab-mcpb 0.17.0 → 0.18.0

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

@@ -24,6 +24,11 @@ export declare function withSecurityWrapper<T extends Record<string, unknown>>(t
     content: ({
         type: "text";
         text: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
         _meta?: {
             [x: string]: unknown;
         } | undefined;
@@ -31,6 +36,11 @@ export declare function withSecurityWrapper<T extends Record<string, unknown>>(t
         type: "image";
         data: string;
         mimeType: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
         _meta?: {
             [x: string]: unknown;
         } | undefined;
@@ -38,47 +48,67 @@ export declare function withSecurityWrapper<T extends Record<string, unknown>>(t
         type: "audio";
         data: string;
         mimeType: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
         _meta?: {
             [x: string]: unknown;
         } | undefined;
     } | {
-        type: "resource_link";
-        name: string;
         uri: string;
+        name: string;
+        type: "resource_link";
+        description?: string | undefined;
+        mimeType?: string | undefined;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
         _meta?: {
             [x: string]: unknown;
         } | undefined;
-        mimeType?: string | undefined | undefined;
         icons?: {
             src: string;
-            mimeType?: string | undefined | undefined;
+            mimeType?: string | undefined;
             sizes?: string[] | undefined;
+            theme?: "light" | "dark" | undefined;
         }[] | undefined;
-        title?: string | undefined | undefined;
-        description?: string | undefined | undefined;
+        title?: string | undefined;
     } | {
         type: "resource";
         resource: {
             uri: string;
             text: string;
+            mimeType?: string | undefined;
             _meta?: {
                 [x: string]: unknown;
             } | undefined;
-            mimeType?: string | undefined | undefined;
         } | {
             uri: string;
             blob: string;
+            mimeType?: string | undefined;
             _meta?: {
                 [x: string]: unknown;
             } | undefined;
-            mimeType?: string | undefined | undefined;
         };
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
         _meta?: {
             [x: string]: unknown;
         } | undefined;
     })[];
     _meta?: {
         [x: string]: unknown;
+        progressToken?: string | number | undefined;
+        "io.modelcontextprotocol/related-task"?: {
+            taskId: string;
+        } | undefined;
     } | undefined;
     structuredContent?: {
         [x: string]: unknown;

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;

package/dist/tools/reconciliation/executor.js

@@ -79,7 +79,7 @@ function isWithinStatementWindow(dateStr, window) {
     return true;
 }
 export async function executeReconciliation(options) {
-    const { analysis, params, ynabAPI, budgetId, accountId, initialAccount, currencyCode } = options;
+    const { analysis, params, ynabAPI, budgetId, accountId, initialAccount, currencyCode, sendProgress, } = options;
     const actions_taken = [];
     const summary = {
         bank_transactions_count: analysis.summary.bank_transactions_count,
@@ -92,6 +92,23 @@ export async function executeReconciliation(options) {
         dates_adjusted: 0,
         dry_run: params.dry_run,
     };
+    const matchesNeedingUpdate = analysis.auto_matches.filter((match) => {
+        const flags = computeUpdateFlags(match, params);
+        return flags.needsClearedUpdate || flags.needsDateUpdate;
+    });
+    const totalOperations = (params.auto_create_transactions ? analysis.unmatched_bank.length : 0) +
+        matchesNeedingUpdate.length +
+        (params.auto_unclear_missing ? analysis.unmatched_ynab.length : 0);
+    let completedOperations = 0;
+    const reportProgress = async (message) => {
+        if (sendProgress && totalOperations > 0) {
+            await sendProgress({
+                progress: completedOperations,
+                total: totalOperations,
+                message,
+            });
+        }
+    };
     let afterAccount = { ...initialAccount };
     let accountSnapshotDirty = false;
     const statementTargetMilli = resolveStatementBalanceMilli(analysis.balance_info, params.statement_balance);
@@ -193,6 +210,8 @@ export async function executeReconciliation(options) {
                     recordCreateAction(recordArgs);
                     accountSnapshotDirty = true;
                     applyClearedDelta(entry.amountMilli);
+                    completedOperations += 1;
+                    await reportProgress(`Created ${completedOperations} of ${totalOperations} transactions`);
                     const trigger = options.chunkIndex
                         ? `creating ${entry.bankTransaction.payee ?? 'missing transaction'} (chunk ${options.chunkIndex})`
                         : `creating ${entry.bankTransaction.payee ?? 'missing transaction'}`;
@@ -343,6 +362,8 @@ export async function executeReconciliation(options) {
                     try {
                         await processBulkChunk(chunk, chunkIndex);
                         bulkOperationDetails.bulk_successes += 1;
+                        completedOperations += chunk.length;
+                        await reportProgress(`Created ${completedOperations} of ${totalOperations} transactions`);
                     }
                     catch (error) {
                         const ynabError = normalizeYnabError(error);
@@ -445,6 +466,8 @@ export async function executeReconciliation(options) {
                         });
                     }
                     accountSnapshotDirty = true;
+                    completedOperations += updatedTransactions.length;
+                    await reportProgress(`Updated ${completedOperations} of ${totalOperations} transactions`);
                 }
                 catch (error) {
                     const ynabError = normalizeYnabError(error);
@@ -533,6 +556,8 @@ export async function executeReconciliation(options) {
                         });
                     }
                     accountSnapshotDirty = true;
+                    completedOperations += updatedTransactions.length;
+                    await reportProgress(`Marked ${completedOperations} of ${totalOperations} transactions uncleared`);
                 }
                 catch (error) {
                     const ynabError = normalizeYnabError(error);

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 { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ProgressCallback } from '../../server/toolRegistry.js';
 import type { ToolFactory } from '../../types/toolRegistration.js';
 import type { DeltaFetcher } from '../deltaFetcher.js';
 export type * from './types.js';
@@ -51,6 +52,6 @@ export declare const ReconcileAccountSchema: z.ZodObject<{
     force_full_refresh: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, z.core.$strip>;
 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, deltaFetcher: DeltaFetcher, params: ReconcileAccountRequest, sendProgress?: ProgressCallback): Promise<CallToolResult>;
 export declare function handleReconcileAccount(ynabAPI: ynab.API, params: ReconcileAccountRequest): Promise<CallToolResult>;
 export declare const registerReconciliationTools: ToolFactory;

package/dist/tools/reconciliation/index.js

@@ -88,7 +88,7 @@ export const ReconcileAccountSchema = z
     message: 'Either csv_file_path or csv_data must be provided',
     path: ['csv_data'],
 });
-export async function handleReconcileAccount(ynabAPI, deltaFetcherOrParams, maybeParams) {
+export async function handleReconcileAccount(ynabAPI, deltaFetcherOrParams, maybeParams, sendProgress) {
     const { deltaFetcher, params } = resolveDeltaFetcherArgs(ynabAPI, deltaFetcherOrParams, maybeParams);
     const forceFullRefresh = params.force_full_refresh ?? true;
     return await withToolErrorHandling(async () => {
@@ -274,6 +274,7 @@ export async function handleReconcileAccount(ynabAPI, deltaFetcherOrParams, mayb
                 accountId: params.account_id,
                 initialAccount,
                 currencyCode,
+                ...(sendProgress !== undefined && { sendProgress }),
             });
         }
         const csvFormatForPayload = mapCsvFormatForPayload(params.csv_format);
@@ -307,7 +308,7 @@ export async function handleReconcileAccount(ynabAPI, deltaFetcherOrParams, mayb
     }, 'ynab:reconcile_account', 'analyzing account reconciliation');
 }
 export const registerReconciliationTools = (registry, context) => {
-    const { adapt, adaptWithDelta } = createAdapters(context);
+    const { adapt, adaptWithDeltaAndProgress } = createAdapters(context);
     const budgetResolver = createBudgetResolver(context);
     registry.register({
         name: 'compare_transactions',
@@ -326,7 +327,7 @@ export const registerReconciliationTools = (registry, context) => {
         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),
+        handler: adaptWithDeltaAndProgress(handleReconcileAccount),
         defaultArgumentResolver: budgetResolver(),
         metadata: {
             annotations: {

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/utilityTools.d.ts

@@ -1,12 +1,5 @@
 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(_ynabAPI: ynab.API, params: ConvertAmountParams): Promise<CallToolResult>;
 export declare const registerUtilityTools: ToolFactory;

package/dist/tools/utilityTools.js

@@ -1,15 +1,8 @@
-import { z } from 'zod/v4';
 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(),
-    to_milliunits: z.boolean(),
-})
-    .strict();
 export async function handleGetUser(ynabAPI) {
     return await withToolErrorHandling(async () => {
         const response = await ynabAPI.user.getUser();
@@ -27,38 +20,8 @@ export async function handleGetUser(ynabAPI) {
         };
     }, 'ynab:get_user', 'getting user information');
 }
-export async function handleConvertAmount(_ynabAPI, params) {
-    return await withToolErrorHandling(async () => {
-        const { amount, to_milliunits } = params;
-        let result;
-        let description;
-        if (to_milliunits) {
-            result = Math.round(amount * 1000);
-            description = `$${amount.toFixed(2)} = ${result} milliunits`;
-        }
-        else {
-            result = amount / 1000;
-            description = `${amount} milliunits = $${result.toFixed(2)}`;
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: responseFormatter.format({
-                        conversion: {
-                            original_amount: amount,
-                            converted_amount: result,
-                            to_milliunits,
-                            description,
-                        },
-                    }),
-                },
-            ],
-        };
-    }, 'ynab:convert_amount', 'converting amount');
-}
 export const registerUtilityTools = (registry, context) => {
-    const { adapt, adaptNoInput } = createAdapters(context);
+    const { adaptNoInput } = createAdapters(context);
     registry.register({
         name: 'get_user',
         description: 'Get information about the authenticated user',
@@ -71,16 +34,4 @@ export const registerUtilityTools = (registry, context) => {
             },
         },
     });
-    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/docs/maintainers/npm-publishing.md

@@ -0,0 +1,27 @@
+# npm publishing (maintainers)
+
+This repo publishes the package `@dizzlkheinz/ynab-mcpb` to the public npm registry via GitHub Actions (`.github/workflows/publish.yml`).
+
+## Trusted publishing (OIDC)
+
+This package is configured as a **Trusted Publisher** on npm (OIDC). With that enabled, the publish workflow does **not** need an npm token and can still work even if the package is set to “disallow tokens”.
+
+Note: `npm whoami` will still fail in CI under OIDC; authentication happens only during `npm publish`.
+
+## Common failure: `npm ERR! need auth`
+
+This error means the runner has no valid auth for `https://registry.npmjs.org/`.
+
+Checklist:
+
+- The Trusted Publisher entry matches exactly (repo, workflow filename `publish.yml`, and environment `npm-publish`).
+- The workflow has `permissions: id-token: write`.
+- You’re using a recent npm CLI (the workflow uses Node `24`).
+- For first-time scoped publishes, the workflow uses `npm publish --access public`.
+
+## Local manual publish (optional)
+
+```bash
+npm adduser
+npm publish --access public
+```