actual-mcp-server 0.5.0

package/dist/src/server/httpServer_testing.js

@@ -0,0 +1,401 @@
+import { z } from 'zod';
+import { randomUUID } from 'crypto';
+import express from 'express';
+import { Server } from './streamable-http.js';
+import { StreamableHTTPServerTransport } from './streamable-http.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from './streamable-http.js';
+import logger from '../logger.js';
+// don't log at import time — only log when the server is actually started
+// console.error('Starting Streamable HTTP server...');
+// top-level logging removed so message is not printed at import-time
+// logger.info('Starting Streamable HTTP server (will be logged when startHttpServer is called)');
+export async function startHttpServer(mcp, port, httpPath) {
+    logger.info('Starting Streamable HTTP server (testing)...');
+    const app = express();
+    app.use(express.json());
+    // Map sessionId to transport
+    const transports = new Map();
+    // Tool schemas and types
+    // ToolSchema isn't typed here; we'll cast request params at runtime below
+    // Define tool schemas
+    const HelloWorldSchema = z.object({
+        name: z.string().describe("The name to greet")
+    });
+    const GetServerInfoSchema = z.object({});
+    const LongRunningTestSchema = z.object({
+        duration: z.number().optional().default(30).describe("Duration in seconds (default: 30)"),
+        steps: z.number().optional().default(10).describe("Number of progress steps (default: 10)"),
+        message: z.string().optional().describe("Optional message to include in the response")
+    });
+    const SlowTestSchema = z.object({
+        message: z.string().optional().describe("Optional message to include in the response"),
+        steps: z.number().optional().default(20).describe("Number of progress steps (default: 20)")
+    });
+    // Tool names enum
+    let ToolName;
+    (function (ToolName) {
+        ToolName["HELLO_WORLD"] = "hello_world";
+        ToolName["GET_SERVER_INFO"] = "get_server_info";
+        ToolName["LONG_RUNNING_TEST"] = "long_running_test";
+        ToolName["SLOW_TEST"] = "slow_test";
+    })(ToolName || (ToolName = {}));
+    // Function to create a new MCP server instance
+    function createServerInstance() {
+        const server = new Server({
+            name: "simple-streamable-http-mcp-server",
+            version: "1.0.0",
+        }, {
+            instructions: "A simple test MCP server implemented with Streamable HTTP transport. Supports basic tools and long-running operations with progress updates.",
+            capabilities: {
+                tools: {}
+            }
+        });
+        // Set up the list tools handler
+        server.setRequestHandler(ListToolsRequestSchema, async () => {
+            logger.debug('[TOOLS LIST] Listing available tools');
+            const tools = [
+                {
+                    name: ToolName.HELLO_WORLD,
+                    description: "A simple tool that returns a greeting",
+                    inputSchema: z.toJSONSchema(HelloWorldSchema),
+                },
+                {
+                    name: ToolName.GET_SERVER_INFO,
+                    description: "Get information about the server",
+                    inputSchema: z.toJSONSchema(GetServerInfoSchema),
+                },
+                {
+                    name: ToolName.LONG_RUNNING_TEST,
+                    description: "A test tool that demonstrates long-running operations with progress updates",
+                    inputSchema: z.toJSONSchema(LongRunningTestSchema),
+                },
+                {
+                    name: ToolName.SLOW_TEST,
+                    description: "A test tool that takes 10 minutes to complete and returns timing information",
+                    inputSchema: z.toJSONSchema(SlowTestSchema),
+                }
+            ];
+            return { tools };
+        });
+        // Set up the call tool handler
+        server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+            const req = request;
+            const params = req?.params ?? {};
+            const name = params.name;
+            const args = params.arguments;
+            logger.debug(`[TOOL CALL] Tool: ${name}, Args: ${JSON.stringify(args, null, 2)}`);
+            debug(`Tool request details: ${JSON.stringify(params, null, 2)}`);
+            if (name === ToolName.HELLO_WORLD) {
+                const validatedArgs = HelloWorldSchema.parse(args);
+                debug(`hello_world tool called with args:`, validatedArgs);
+                await new Promise(resolve => setTimeout(resolve, 200));
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Hello, ${validatedArgs.name}! Welcome to the MCP server.`
+                        }]
+                };
+            }
+            if (name === ToolName.GET_SERVER_INFO) {
+                debug(`get_server_info tool called`);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                name: "Simple Streamable HTTP MCP Server",
+                                version: "1.0.0",
+                                features: ["tools"],
+                                timestamp: new Date().toISOString()
+                            }, null, 2)
+                        }]
+                };
+            }
+            if (name === ToolName.LONG_RUNNING_TEST) {
+                const validatedArgs = LongRunningTestSchema.parse(args);
+                const { duration = 30, steps = 10, message } = validatedArgs;
+                const startTime = new Date();
+                const startTimestamp = startTime.toISOString();
+                debug(`long_running_test started at: ${startTimestamp}, duration: ${duration}s, steps: ${steps}`);
+                // Get progress token if available
+                const progressToken = params['_meta'] ? params['_meta']?.progressToken : undefined;
+                const stepDurationMs = (duration * 1000) / steps;
+                // Send progress updates
+                for (let i = 1; i <= steps; i++) {
+                    await new Promise(resolve => setTimeout(resolve, stepDurationMs));
+                    if (progressToken !== undefined) {
+                        try {
+                            logger.debug(`[PROGRESS] Sending progress update: ${i}/${steps} for token: ${progressToken}`);
+                            await server.notification({
+                                method: "notifications/progress",
+                                params: {
+                                    progress: i,
+                                    total: steps,
+                                    progressToken,
+                                },
+                            }, { relatedRequestId: (extra && typeof extra === 'object' && 'requestId' in extra ? extra['requestId'] : undefined) });
+                            logger.debug(`[PROGRESS] Successfully sent progress update: ${i}/${steps}`);
+                        }
+                        catch (error) {
+                            logger.error(`[PROGRESS ERROR] Failed to send progress notification: ${String(error)}`);
+                        }
+                    }
+                    else {
+                        debug(`No progress token provided, skipping progress update ${i}/${steps}`);
+                    }
+                }
+                const endTime = new Date();
+                const endTimestamp = endTime.toISOString();
+                const actualDurationMs = endTime.getTime() - startTime.getTime();
+                debug(`long_running_test completed at: ${endTimestamp}`);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                message: message || "Long-running test completed successfully",
+                                start: startTimestamp,
+                                finish: endTimestamp,
+                                requestedDuration: duration,
+                                actualDuration: {
+                                    milliseconds: actualDurationMs,
+                                    seconds: actualDurationMs / 1000
+                                },
+                                steps: steps
+                            }, null, 2)
+                        }]
+                };
+            }
+            if (name === ToolName.SLOW_TEST) {
+                const validatedArgs = SlowTestSchema.parse(args);
+                const { message, steps = 20 } = validatedArgs;
+                const startTime = new Date();
+                const startTimestamp = startTime.toISOString();
+                debug(`slow_test tool started at: ${startTimestamp}`);
+                // Get progress token if available
+                const progressToken = params['_meta'] ? params['_meta']?.progressToken : undefined;
+                // Wait for 10 minutes (600,000 milliseconds)
+                const tenMinutesMs = 10 * 60 * 1000;
+                const stepDurationMs = tenMinutesMs / steps;
+                // Send progress updates
+                for (let i = 1; i <= steps; i++) {
+                    await new Promise(resolve => setTimeout(resolve, stepDurationMs));
+                    if (progressToken !== undefined) {
+                        try {
+                            logger.debug(`[PROGRESS] Sending progress update: ${i}/${steps} for token: ${progressToken}`);
+                            await server.notification({
+                                method: "notifications/progress",
+                                params: {
+                                    progress: i,
+                                    total: steps,
+                                    progressToken,
+                                },
+                            }, { relatedRequestId: (extra && typeof extra === 'object' && 'requestId' in extra ? extra['requestId'] : undefined) });
+                            logger.debug(`[PROGRESS] Successfully sent progress update: ${i}/${steps}`);
+                        }
+                        catch (error) {
+                            logger.error(`[PROGRESS ERROR] Failed to send progress notification: ${String(error)}`);
+                        }
+                    }
+                    else {
+                        debug(`No progress token provided, skipping progress update ${i}/${steps}`);
+                    }
+                    // Log progress every 5 steps
+                    if (i % 5 === 0) {
+                        const elapsedMinutes = (i / steps) * 10;
+                        logger.info(`[SLOW_TEST] Progress: ${i}/${steps} steps (${elapsedMinutes.toFixed(1)} minutes elapsed)`);
+                    }
+                }
+                const endTime = new Date();
+                const endTimestamp = endTime.toISOString();
+                const durationMs = endTime.getTime() - startTime.getTime();
+                const durationMinutes = durationMs / (60 * 1000);
+                debug(`slow_test tool completed at: ${endTimestamp}`);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                message: message || "Slow test completed successfully",
+                                start: startTimestamp,
+                                finish: endTimestamp,
+                                duration: {
+                                    milliseconds: durationMs,
+                                    seconds: durationMs / 1000,
+                                    minutes: durationMinutes
+                                },
+                                steps: steps
+                            }, null, 2)
+                        }]
+                };
+            }
+            throw new Error(`Unknown tool: ${name}`);
+        });
+        return { server };
+    }
+    // Handle POST requests
+    app.post(httpPath, async (req, res) => {
+        logger.debug('Received MCP POST request');
+        logger.debug('Request method: %s', req.body?.method);
+        debug('Headers:', JSON.stringify(req.headers, null, 2));
+        debug('Body:', JSON.stringify(req.body, null, 2));
+        try {
+            // Check for existing session ID
+            const sessionId = req.headers['mcp-session-id'];
+            let transport;
+            if (sessionId && transports.has(sessionId)) {
+                // Reuse existing transport
+                transport = transports.get(sessionId);
+                logger.debug(`[SESSION] Reusing existing transport for session ${sessionId}`);
+            }
+            else if (!sessionId) {
+                // New initialization request
+                logger.debug('[SESSION] Creating new server for initialization request');
+                const { server } = createServerInstance();
+                transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => randomUUID(),
+                    enableJsonResponse: true,
+                    onsessioninitialized: (sessionId) => {
+                        transports.set(sessionId, transport);
+                    }
+                });
+                // Set up onclose handler to clean up transport when closed
+                server.onclose = async () => {
+                    const sid = transport.sessionId;
+                    if (sid && transports.has(sid)) {
+                        transports.delete(sid);
+                    }
+                };
+                // Connect the transport to the MCP server BEFORE handling the request
+                await server.connect(transport);
+                await transport.handleRequest(req, res, req.body);
+                return; // Already handled
+            }
+            else {
+                // Invalid request - session ID provided but not found
+                res.status(400).json({
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32000,
+                        message: 'Bad Request: Invalid session ID',
+                    },
+                    id: req?.body?.id,
+                });
+                return;
+            }
+            // Handle the request with existing transport
+            await transport.handleRequest(req, res, req.body);
+        }
+        catch (error) {
+            logger.error('Error handling MCP request: %s', String(error));
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32603,
+                        message: 'Internal server error',
+                    },
+                    id: req?.body?.id,
+                });
+            }
+        }
+    });
+    // Handle GET requests for SSE streams
+    app.get(httpPath, async (req, res) => {
+        logger.debug('Received MCP GET request');
+        const sessionId = req.headers['mcp-session-id'];
+        if (!sessionId || !transports.has(sessionId)) {
+            res.status(400).json({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32000,
+                    message: 'Bad Request: No valid session ID provided',
+                },
+                id: null,
+            });
+            return;
+        }
+        const lastEventId = req.headers['last-event-id'];
+        if (lastEventId) {
+            logger.debug(`Client reconnecting with Last-Event-ID: ${lastEventId}`);
+        }
+        else {
+            logger.debug(`Establishing new SSE stream for session ${sessionId}`);
+        }
+        const transport = transports.get(sessionId);
+        await transport.handleRequest(req, res);
+    });
+    // Handle DELETE requests for session termination
+    app.delete(httpPath, async (req, res) => {
+        const sessionId = req.headers['mcp-session-id'];
+        if (!sessionId || !transports.has(sessionId)) {
+            res.status(400).json({
+                jsonrpc: '2.0',
+                error: {
+                    code: -32000,
+                    message: 'Bad Request: No valid session ID provided',
+                },
+                id: null,
+            });
+            return;
+        }
+        logger.debug(`Received session termination request for session ${sessionId}`);
+        try {
+            const transport = transports.get(sessionId);
+            await transport.handleRequest(req, res, req.body);
+        }
+        catch (error) {
+            logger.error('Error handling session termination: %s', String(error));
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32603,
+                        message: 'Error handling session termination',
+                    },
+                    id: null,
+                });
+            }
+        }
+    });
+    // Health check endpoint
+    app.get('/health', (req, res) => {
+        res.json({
+            status: 'ok',
+            server: {
+                name: "simple-streamable-http-mcp-server",
+                version: "1.0.0"
+            },
+            transport: 'streamable-http',
+            activeSessions: transports.size
+        });
+    });
+    // Start server
+    app.listen(port, () => {
+        logger.info(`MCP Streamable HTTP Server listening on port ${port}`);
+        logger.info(`📨 MCP endpoint: http://localhost:${port}${httpPath}`);
+        logger.info(`❤️  Health check: http://localhost:${port}/health`);
+        logger.info(`🛠️  Available tools: hello_world, get_server_info, long_running_test, slow_test`);
+    });
+    // Handle server shutdown
+    process.on('SIGINT', async () => {
+        logger.info('Shutting down server...');
+        // Close all active transports
+        for (const [sessionId, transport] of transports) {
+            try {
+                logger.debug(`Closing transport for session ${sessionId}`);
+                await transport.close();
+                transports.delete(sessionId);
+            }
+            catch (error) {
+                logger.error(`Error closing transport for session ${sessionId}: ${String(error)}`);
+            }
+        }
+        logger.info('Server shutdown complete');
+        process.exit(0);
+    });
+}
+const debug = (...args) => {
+    if (process.env.DEBUG === 'true' || process.env.DEBUG === '1') {
+        // safely stringify args to avoid implicit any spread
+        const s = args.map(a => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ');
+        console.debug('[DEBUG]', s);
+    }
+};

package/dist/src/server/stdioServer.js

@@ -0,0 +1,52 @@
+// src/server/stdioServer.ts
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import logger from '../logger.js';
+import actualToolsManager from '../actualToolsManager.js';
+export async function startStdioServer(mcp, capabilities, implementedTools, serverDescription, serverInstructions, toolSchemas, version) {
+    const toolsList = Array.isArray(implementedTools) ? implementedTools : [];
+    const server = new Server({ name: serverDescription || 'actual-mcp-server', version: version || '0.1.0' }, { capabilities, instructions: serverInstructions });
+    // List tools handler — mirrors createServerInstance() in httpServer.ts
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        const tools = toolsList.map((name) => {
+            const schemaFromParam = toolSchemas && toolSchemas[name];
+            const schemaFromManager = actualToolsManager?.getToolSchema?.(name);
+            const schema = schemaFromParam || schemaFromManager;
+            const inputSchema = schema && typeof schema === 'object' && Object.keys(schema).length > 0
+                ? schema
+                : { type: 'object', properties: {}, additionalProperties: false };
+            const tool = actualToolsManager.getTool(name);
+            const description = tool?.description || `Tool ${name}`;
+            return { name, description, inputSchema };
+        });
+        logger.debug(`[STDIO] tools/list → ${tools.length} tools`);
+        return { tools };
+    });
+    // Call tool handler — delegates to ActualMCPConnection.executeTool()
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const req = request;
+        const params = req?.params ?? {};
+        const rawName = params.name;
+        const args = params.arguments;
+        if (typeof rawName !== 'string') {
+            throw new Error('Tool name must be a string');
+        }
+        logger.debug(`[STDIO] tools/call ${rawName}`);
+        const result = await mcp.executeTool(rawName, args ?? {});
+        return {
+            content: [{ type: 'text', text: typeof result === 'string' ? result : JSON.stringify(result) }],
+        };
+    });
+    const transport = new StdioServerTransport();
+    // server.connect() calls transport.start() internally — do NOT call transport.start() manually
+    await server.connect(transport);
+    // StdioServerTransport does NOT auto-exit when stdin closes.
+    // Add explicit handler so Claude Desktop process cleanup works correctly.
+    process.stdin.on('end', async () => {
+        logger.debug('[STDIO] stdin closed — shutting down');
+        await transport.close();
+        process.exit(0);
+    });
+    logger.debug('[STDIO] Server connected and listening on stdin/stdout');
+}

package/dist/src/server/streamable-http.js

@@ -0,0 +1,148 @@
+// Minimal TypeScript shim for the absent `streamable-http` package.
+// Implements only the surface used by src/server/httpServer.ts.
+import crypto from 'crypto';
+export const ListToolsRequestSchema = Symbol('ListToolsRequestSchema');
+export const CallToolRequestSchema = Symbol('CallToolRequestSchema');
+export const ToolSchema = {};
+export class Server {
+    meta;
+    options;
+    handlers;
+    transports;
+    onclose;
+    constructor(meta = {}, options = {}) {
+        this.meta = meta;
+        this.options = options;
+        this.handlers = new Map();
+        this.transports = new Set();
+    }
+    setRequestHandler(schema, handler) {
+        this.handlers.set(schema, handler);
+    }
+    async connect(transport) {
+        this.transports.add(transport);
+        // Attach reference for test shims (loose typing intentionally preserved here)
+        try {
+            transport.server = this;
+        }
+        catch { }
+    }
+    async notification(payload, opts) {
+        for (const t of this.transports) {
+            if (typeof t.pushNotification === 'function') {
+                try {
+                    await t.pushNotification(payload);
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+    }
+    // allow handlers to be invoked by transports (shim convenience)
+    async invokeHandler(schema, req, extra) {
+        const handler = this.handlers.get(schema);
+        if (!handler)
+            throw new Error('Handler not registered');
+        return handler(req, extra);
+    }
+}
+export class StreamableHTTPServerTransport {
+    opts;
+    sessionId;
+    server;
+    closed = false;
+    constructor(opts = {}) {
+        this.opts = opts;
+        this.sessionId = null;
+        this.server = null;
+    }
+    async pushNotification(_payload) {
+        // noop
+    }
+    async handleRequest(req, res, bodyFromCaller) {
+        const payload = (bodyFromCaller && Object.keys(bodyFromCaller).length ? bodyFromCaller : (req.body ?? {}));
+        const method = payload.method;
+        // Always include session ID in response headers if we have one
+        if (this.sessionId) {
+            res.setHeader('MCP-Session-Id', this.sessionId);
+        }
+        if (method === 'initialize') {
+            this.sessionId =
+                typeof this.opts.sessionIdGenerator === 'function'
+                    ? this.opts.sessionIdGenerator()
+                    : crypto.randomUUID?.() ?? `local-${Math.random().toString(36).slice(2, 10)}`;
+            if (typeof this.opts.onsessioninitialized === 'function') {
+                try {
+                    this.opts.onsessioninitialized(this.sessionId);
+                }
+                catch { }
+            }
+            // Provide a robust initialize result with safe defaults so MCP clients
+            // that validate serverInstructions / capabilities / tools won't error.
+            const result = {
+                protocolVersion: '2025-06-18',
+                identifier: 'actual-mcp-server',
+                // capabilities expected to be an object like { tools: { ... } }
+                capabilities: this.server?.options?.capabilities ?? { tools: {} },
+                // some clients expect serverInstructions to exist (object or string)
+                serverInstructions: this.server?.options?.serverInstructions ?? '',
+                // advertise known tools when available
+                tools: this.server?.options?.implementedTools ?? [],
+            };
+            // Set the MCP-Session-Id header so clients can make subsequent requests
+            res.setHeader('MCP-Session-Id', this.sessionId);
+            res.json({ jsonrpc: '2.0', id: payload.id ?? null, result });
+            return;
+        }
+        if (method === 'tools/list') {
+            if (!this.server) {
+                res.status(500).json({ jsonrpc: '2.0', id: payload.id ?? null, error: { message: 'Server not connected' } });
+                return;
+            }
+            try {
+                const r = await this.server.invokeHandler(ListToolsRequestSchema, { params: {} });
+                res.json({ jsonrpc: '2.0', id: payload.id ?? null, result: r });
+                return;
+            }
+            catch (e) {
+                res.status(500).json({ jsonrpc: '2.0', id: payload.id ?? null, error: { message: String(e) } });
+                return;
+            }
+        }
+        if (method === 'tools/call' && payload.params && payload.params.name) {
+            if (!this.server) {
+                res.status(500).json({ jsonrpc: '2.0', id: payload.id ?? null, error: { message: 'Server not connected' } });
+                return;
+            }
+            try {
+                const params = payload.params;
+                const r = await this.server.invokeHandler(CallToolRequestSchema, { params: { name: params.name, arguments: params.arguments ?? {} } }, {});
+                res.json({ jsonrpc: '2.0', id: payload.id ?? null, result: r });
+                return;
+            }
+            catch (e) {
+                res.status(500).json({ jsonrpc: '2.0', id: payload.id ?? null, error: { message: String(e) } });
+                return;
+            }
+        }
+        if (method === 'ping') {
+            if (payload.id !== undefined)
+                res.json({ jsonrpc: '2.0', id: payload.id, result: {} });
+            else
+                res.status(200).end();
+            return;
+        }
+        if (typeof method === 'string' && method.startsWith('notifications/')) {
+            res.status(200).end();
+            return;
+        }
+        res.status(404).json({ jsonrpc: '2.0', id: payload.id ?? null, error: { code: -32601, message: 'Method not found' } });
+    }
+    async close() {
+        this.closed = true;
+        if (this.server && typeof this.server.removeTransport === 'function') {
+            this.server.removeTransport(this);
+        }
+    }
+}

package/dist/src/tests/actualToolsTests.js

@@ -0,0 +1,70 @@
+// src/tests/actualToolsTests.ts
+import logger from '../logger.js';
+import actualToolsManager from '../actualToolsManager.js';
+// Test data mapping for each tool
+const getTestArgs = (toolName) => {
+    switch (toolName) {
+        case 'actual.accounts.create':
+            return { name: 'Test Account', balance: 1000 };
+        case 'actual.accounts.update':
+            return { id: 'test-account-id', fields: { name: 'Updated Test Account' } };
+        case 'actual.accounts.get.balance':
+            return { id: 'test-account-id' };
+        case 'actual.transactions.create':
+            return { accountId: 'test-account-id', amount: 100, payee: 'Test Payee', date: '2025-11-08' };
+        case 'actual.transactions.get':
+            return { accountId: 'test-account-id', startDate: '2025-11-01', endDate: '2025-11-08' };
+        case 'actual.transactions.import':
+            return { accountId: 'test-account-id', txs: [{ amount: 50, payee: 'Import Test', date: '2025-11-08' }] };
+        case 'actual.categories.create':
+            // Try different field names that might be expected
+            return { name: 'Test Category', group_id: 'fc3825fd-b982-4b72-b768-5b30844cf832', groupId: 'fc3825fd-b982-4b72-b768-5b30844cf832' };
+        case 'actual.payees.create':
+            return { name: 'Test Payee' };
+        case 'actual.budgets.setAmount':
+            // Use an existing category ID (Food category from the budget data)
+            return { month: '2025-11', categoryId: '541836f1-e756-4473-a5d0-6c1d3f06c7fa', amount: 500 };
+        case 'actual.budgets.getMonth':
+            return { month: '2025-11' };
+        // These tools don't require parameters
+        case 'actual.accounts.list':
+        case 'actual.categories.get':
+        case 'actual.payees.get':
+        case 'actual.budgets.getMonths':
+        default:
+            return {};
+    }
+};
+export async function testAllTools() {
+    await actualToolsManager.initialize();
+    const toolNames = actualToolsManager.getToolNames();
+    const results = [];
+    for (const name of toolNames) {
+        try {
+            logger.info(`⚙️  Testing tool: ${name}`);
+            const testArgs = getTestArgs(name);
+            const result = await actualToolsManager.callTool(name, testArgs);
+            logger.info(`✅ Tool ${name} output: ${JSON.stringify(result, null, 2)}`);
+            results.push({ name, success: true });
+        }
+        catch (err) {
+            const message = err && typeof err?.message === 'string' ? err.message : String(err);
+            logger.error(`❌ Tool ${name} test failed: ${message}`);
+            results.push({ name, success: false, error: message });
+        }
+    }
+    // Summary
+    const successful = results.filter(r => r.success).length;
+    const failed = results.filter(r => !r.success).length;
+    logger.info(`\n📊 Test Summary: ${successful} passed, ${failed} failed`);
+    if (failed > 0) {
+        logger.error(`❌ Failed tools:`);
+        results.filter(r => !r.success).forEach(r => {
+            logger.error(`  - ${r.name}: ${r.error}`);
+        });
+        throw new Error(`${failed} tool tests failed`);
+    }
+    else {
+        logger.info(`🎉 All ${successful} tools passed!`);
+    }
+}