@warmio/mcp 4.2.2 → 4.3.2

package/dist/schemas.js

@@ -1,184 +1,161 @@
-import * as z from 'zod/v4';
-const dateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, 'Expected date in YYYY-MM-DD format.');
+import { z } from 'zod';
+const dateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, 'Expected YYYY-MM-DD date.');
 const dateTimeSchema = z.string().datetime({ offset: true });
-export const emptyInputSchema = z.object({}).strict().default({});
-export const accountTypeSchema = z.enum(['depository', 'credit', 'loan', 'investment', 'other']);
-export const accountSchema = z
-    .object({
-    name: z.string(),
-    type: accountTypeSchema,
-    subtype: z.string().nullable(),
-    balance: z.number().finite(),
-    institution: z.string().nullable(),
-    mask: z.string().nullable(),
-})
-    .strict();
-export const getAccountsOutputSchema = z
-    .object({
-    accounts: z.array(accountSchema),
-})
-    .strict();
-const getTransactionsInputObjectSchema = z
-    .object({
-    limit: z
-        .int()
-        .min(1)
-        .max(1000)
-        .default(500)
-        .describe('Maximum transactions to return in this page (default 500, max 1000).'),
+export const emptyInputSchema = {};
+export const accountTypeSchema = z.enum([
+    'depository',
+    'credit',
+    'loan',
+    'investment',
+    'other',
+]);
+export const getAccountsOutputSchema = {
+    accounts: z.array(z
+        .object({
+        balance: z.number().finite(),
+        institution: z.string().nullable(),
+        mask: z.string().nullable(),
+        name: z.string(),
+        subtype: z.string().nullable(),
+        type: accountTypeSchema,
+    })
+        .strict()),
+};
+export const getTransactionsInputSchema = {
     cursor: z
         .string()
         .min(1)
         .optional()
-        .describe('Opaque pagination cursor from a previous get_transactions response.'),
+        .describe('Opaque pagination cursor from a prior get_transactions response.'),
     last_knowledge: dateTimeSchema
         .optional()
-        .describe('Incremental sync checkpoint from a prior get_transactions response. Cannot be combined with cursor.'),
+        .describe('Incremental sync checkpoint. Cannot be combined with cursor.'),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(1000)
+        .default(500)
+        .describe('Maximum transactions to return (default 500, max 1000).'),
     search: z
         .string()
         .min(1)
         .max(120)
         .optional()
-        .describe('Optional merchant or description search string. Keep it unchanged while following a cursor chain.'),
-})
-    .strict()
-    .superRefine((value, ctx) => {
-    if (value.cursor && value.last_knowledge) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ['cursor'],
-            message: '`cursor` cannot be combined with `last_knowledge`.',
-        });
-    }
-});
-export const getTransactionsInputSchema = getTransactionsInputObjectSchema;
-export const transactionSchema = z
-    .object({
-    id: z.string().nullable(),
-    date: dateSchema.nullable(),
-    amount: z.number().finite(),
-    merchant: z.string().nullable(),
-    description: z.string().nullable(),
-    category: z.string().nullable(),
-    detailed_category: z.string().nullable(),
-})
-    .strict();
-export const getTransactionsOutputSchema = z
-    .object({
+        .describe('Optional merchant or description search query.'),
+};
+export const getTransactionsOutputSchema = {
     generated_at: dateTimeSchema.nullable(),
     next_knowledge: dateTimeSchema.nullable(),
-    txns: z.array(transactionSchema),
     pagination: z
         .object({
-        limit: z.int().min(1).max(1000),
-        next_cursor: z.string().nullable(),
         has_more: z.boolean(),
+        limit: z.number().int().min(1).max(1000),
+        next_cursor: z.string().nullable(),
     })
         .strict(),
-})
-    .strict();
-export const snapshotSchema = z
-    .object({
-    date: dateSchema,
-    net_worth: z.number().finite(),
-    total_assets: z.number().finite(),
-    total_liabilities: z.number().finite(),
-})
-    .strict();
-export const recurringSchema = z
-    .object({
-    merchant: z.string(),
-    amount: z.number().finite(),
-    frequency: z.string(),
-    next_date: dateSchema.nullable(),
-    type: z.string().nullable(),
-    active: z.boolean(),
-})
-    .strict();
-export const budgetSchema = z
-    .object({
-    name: z.string(),
-    amount: z.number().finite(),
-    spent: z.number().finite(),
-    remaining: z.number().finite(),
-    percent_used: z.number().finite(),
-    period: z.string(),
-    status: z.string().nullable(),
-})
-    .strict();
-export const goalSchema = z
-    .object({
-    name: z.string(),
-    target: z.number().finite(),
-    current: z.number().finite(),
-    progress_percent: z.number().finite(),
-    target_date: dateSchema.nullable(),
-    status: z.string().nullable(),
-    category: z.string().nullable(),
-    monthly_contribution_needed: z.number().finite().nullable(),
-})
-    .strict();
-export const healthPillarsSchema = z
-    .object({
-    spend: z.number().finite().nullable(),
-    save: z.number().finite().nullable(),
-    borrow: z.number().finite().nullable(),
-    build: z.number().finite().nullable(),
-})
-    .strict();
-export const liabilitySchema = z
-    .object({
-    account_id: z.string(),
-    type: z.string(),
-    balance: z.number().finite().nullable(),
-    apr_percentage: z.number().finite().nullable(),
-    minimum_payment: z.number().finite().nullable(),
-    next_payment_due_date: dateSchema.nullable(),
-    is_overdue: z.boolean().nullable(),
-})
-    .strict();
-export const holdingSchema = z
-    .object({
-    account_id: z.string(),
-    security_name: z.string().nullable(),
-    symbol: z.string().nullable(),
-    type: z.string().nullable(),
-    quantity: z.number().finite(),
-    value: z.number().finite().nullable(),
-    cost_basis: z.number().finite().nullable(),
-})
-    .strict();
-export const categorySpendingSchema = z
-    .object({
-    category: z.string(),
-    amount: z.number().finite(),
-})
-    .strict();
-export const financialHealthSchema = z
-    .object({
-    score: z.number().finite().nullable(),
-    label: z.string().nullable(),
-    data_completeness: z.number().finite().nullable(),
-    pillars: healthPillarsSchema.nullable(),
-    message: z.string().nullable(),
-})
-    .strict();
-export const getFinancialStateOutputSchema = z
-    .object({
+    txns: z.array(z
+        .object({
+        amount: z.number().finite(),
+        category: z.string().nullable(),
+        date: dateSchema.nullable(),
+        description: z.string().nullable(),
+        detailed_category: z.string().nullable(),
+        id: z.string().nullable(),
+        merchant: z.string().nullable(),
+    })
+        .strict()),
+};
+export const getFinancialStateOutputSchema = {
+    budgets: z.array(z
+        .object({
+        amount: z.number().finite(),
+        name: z.string(),
+        percent_used: z.number().finite(),
+        period: z.string(),
+        remaining: z.number().finite(),
+        spent: z.number().finite(),
+        status: z.string().nullable(),
+    })
+        .strict()),
+    category_spending: z.array(z
+        .object({
+        amount: z.number().finite(),
+        category: z.string(),
+    })
+        .strict()),
     generated_at: dateTimeSchema,
-    snapshots: z.array(snapshotSchema),
-    recurring: z.array(recurringSchema),
-    budgets: z.array(budgetSchema),
-    goals: z.array(goalSchema),
-    health: financialHealthSchema,
-    liabilities: z.array(liabilitySchema),
-    holdings: z.array(holdingSchema),
-    category_spending: z.array(categorySpendingSchema),
-})
-    .strict();
-export const verifyKeyOutputSchema = z
-    .object({
-    valid: z.boolean(),
+    goals: z.array(z
+        .object({
+        category: z.string().nullable(),
+        current: z.number().finite(),
+        monthly_contribution_needed: z.number().finite().nullable(),
+        name: z.string(),
+        progress_percent: z.number().finite(),
+        status: z.string().nullable(),
+        target: z.number().finite(),
+        target_date: dateSchema.nullable(),
+    })
+        .strict()),
+    health: z
+        .object({
+        data_completeness: z.number().finite().nullable(),
+        label: z.string().nullable(),
+        message: z.string().nullable(),
+        pillars: z
+            .object({
+            borrow: z.number().finite().nullable(),
+            build: z.number().finite().nullable(),
+            save: z.number().finite().nullable(),
+            spend: z.number().finite().nullable(),
+        })
+            .strict()
+            .nullable(),
+        score: z.number().finite().nullable(),
+    })
+        .strict(),
+    holdings: z.array(z
+        .object({
+        account_id: z.string(),
+        cost_basis: z.number().finite().nullable(),
+        quantity: z.number().finite(),
+        security_name: z.string().nullable(),
+        symbol: z.string().nullable(),
+        type: z.string().nullable(),
+        value: z.number().finite().nullable(),
+    })
+        .strict()),
+    liabilities: z.array(z
+        .object({
+        account_id: z.string(),
+        apr_percentage: z.number().finite().nullable(),
+        balance: z.number().finite().nullable(),
+        is_overdue: z.boolean().nullable(),
+        minimum_payment: z.number().finite().nullable(),
+        next_payment_due_date: dateSchema.nullable(),
+        type: z.string(),
+    })
+        .strict()),
+    recurring: z.array(z
+        .object({
+        active: z.boolean(),
+        amount: z.number().finite(),
+        frequency: z.string(),
+        merchant: z.string(),
+        next_date: dateSchema.nullable(),
+        type: z.string().nullable(),
+    })
+        .strict()),
+    snapshots: z.array(z
+        .object({
+        date: dateSchema,
+        net_worth: z.number().finite(),
+        total_assets: z.number().finite(),
+        total_liabilities: z.number().finite(),
+    })
+        .strict()),
+};
+export const verifyKeyOutputSchema = {
     status: z.string(),
-})
-    .strict();
+    valid: z.boolean(),
+};

package/dist/server.d.ts

@@ -1,8 +1,15 @@
-/**
- * Warm MCP stdio entrypoint and shared exports.
- *
- * The typed MCP contract and Warm API helpers live in `warm-server.ts`.
- */
-import { API_URL, WARM_SERVER_INFO, apiRequest, createWarmApiClient, createWarmServer, getConfiguredApiKey, verifyWarmApiKey } from './warm-server.js';
-export { API_URL, WARM_SERVER_INFO, apiRequest, createWarmApiClient, createWarmServer, getConfiguredApiKey, verifyWarmApiKey, };
-export declare function startStdioServer(): Promise<import("@modelcontextprotocol/sdk/server/mcp.js").McpServer>;
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type Implementation } from '@modelcontextprotocol/sdk/types.js';
+import { createWarmApiClient, type WarmApiClientOptions, getConfiguredApiKey, verifyWarmApiKey, apiRequest } from './warm-api-client.js';
+export { apiRequest, createWarmApiClient, getConfiguredApiKey, verifyWarmApiKey };
+export type { WarmApiClientOptions } from './warm-api-client.js';
+export interface WarmServerOptions extends WarmApiClientOptions {
+    serverInfo?: Implementation;
+}
+export declare const API_URL: string;
+export declare const WARM_SERVER_INFO: {
+    name: string;
+    version: string;
+};
+export declare function registerWarmTools(server: McpServer, options?: WarmApiClientOptions): void;
+export declare function createWarmServer(options?: WarmServerOptions): McpServer;

package/dist/server.js

@@ -1,14 +1,107 @@
-/**
- * Warm MCP stdio entrypoint and shared exports.
- *
- * The typed MCP contract and Warm API helpers live in `warm-server.ts`.
- */
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { API_URL, WARM_SERVER_INFO, apiRequest, createWarmApiClient, createWarmServer, getConfiguredApiKey, verifyWarmApiKey, } from './warm-server.js';
-export { API_URL, WARM_SERVER_INFO, apiRequest, createWarmApiClient, createWarmServer, getConfiguredApiKey, verifyWarmApiKey, };
-export async function startStdioServer() {
-    const server = createWarmServer();
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
+import * as fs from 'node:fs';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { toJsonSchemaCompat } from '@modelcontextprotocol/sdk/server/zod-json-schema-compat.js';
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import { createWarmApiClient, getConfiguredApiKey, verifyWarmApiKey, apiRequest, } from './warm-api-client.js';
+import { emptyInputSchema, getTransactionsInputSchema, } from './schemas.js';
+export { apiRequest, createWarmApiClient, getConfiguredApiKey, verifyWarmApiKey };
+export const API_URL = process.env.WARM_API_URL || 'https://warm.io';
+function getPackageVersion() {
+    try {
+        const packageJson = fs.readFileSync(new URL('../package.json', import.meta.url), 'utf-8');
+        const parsed = JSON.parse(packageJson);
+        return parsed.version || '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+export const WARM_SERVER_INFO = {
+    name: 'warm',
+    version: getPackageVersion(),
+};
+function createStructuredToolResult(structuredContent) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(structuredContent, null, 2),
+            },
+        ],
+        structuredContent,
+    };
+}
+export function registerWarmTools(server, options = {}) {
+    const client = createWarmApiClient(options);
+    const tools = [
+        {
+            description: 'Read-only list of connected financial accounts with balances, subtypes, institutions, and masks when available.',
+            handler: async () => await client.getAccounts(),
+            inputShape: emptyInputSchema,
+            name: 'get_accounts',
+        },
+        {
+            description: 'Read-only transaction export with strict opaque cursor pagination and optional last_knowledge incremental sync.',
+            handler: async (args) => {
+                const transactionArgs = {
+                    cursor: typeof args.cursor === 'string' ? args.cursor : undefined,
+                    last_knowledge: typeof args.last_knowledge === 'string' ? args.last_knowledge : undefined,
+                    limit: typeof args.limit === 'number' ? args.limit : 500,
+                    search: typeof args.search === 'string' ? args.search : undefined,
+                };
+                if (transactionArgs.cursor && transactionArgs.last_knowledge) {
+                    throw new Error('`cursor` cannot be combined with `last_knowledge`.');
+                }
+                return await client.getTransactions(transactionArgs);
+            },
+            inputShape: getTransactionsInputSchema,
+            name: 'get_transactions',
+        },
+        {
+            description: 'Read-only broad financial state bundle with snapshots, recurring payments, budgets, goals, financial health, liabilities, holdings, and category spending.',
+            handler: async () => await client.getFinancialState(),
+            inputShape: emptyInputSchema,
+            name: 'get_financial_state',
+        },
+        {
+            description: 'Read-only API key validation for the configured Warm account.',
+            handler: async () => await client.verifyKey(),
+            inputShape: emptyInputSchema,
+            name: 'verify_key',
+        },
+    ];
+    server.server.registerCapabilities({
+        tools: {
+            listChanged: true,
+        },
+    });
+    server.server.setRequestHandler(ListToolsRequestSchema, () => ({
+        tools: tools.map((tool) => ({
+            description: tool.description,
+            inputSchema: toJsonSchemaCompat(z.object(tool.inputShape).strict(), {
+                pipeStrategy: 'input',
+                strictUnions: true,
+            }),
+            name: tool.name,
+        })),
+    }));
+    server.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const tool = tools.find((candidate) => candidate.name === request.params.name);
+        if (!tool) {
+            throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
+        }
+        const argsSchema = z.object(tool.inputShape).strict();
+        const parseResult = await argsSchema.safeParseAsync(request.params.arguments ?? {});
+        if (!parseResult.success) {
+            throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for tool ${request.params.name}: ${parseResult.error.message}`);
+        }
+        return createStructuredToolResult(await tool.handler(parseResult.data));
+    });
+}
+export function createWarmServer(options = {}) {
+    const { serverInfo, ...clientOptions } = options;
+    const server = new McpServer(serverInfo || WARM_SERVER_INFO);
+    registerWarmTools(server, clientOptions);
     return server;
 }

package/dist/stdio.d.ts

@@ -0,0 +1,29 @@
+import type { Readable, Writable } from 'node:stream';
+import type { Transport, TransportSendOptions } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+export declare class AdaptiveStdioTransport implements Transport {
+    private readonly stdin;
+    private readonly stdout;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: <T extends JSONRPCMessage>(message: T) => void;
+    private buffer;
+    private clientFraming;
+    private closed;
+    private started;
+    constructor(stdin?: Readable, stdout?: Writable);
+    start(): Promise<void>;
+    close(): Promise<void>;
+    send(message: JSONRPCMessage, _options?: TransportSendOptions): Promise<void>;
+    private readonly handleData;
+    private readonly handleError;
+    private readonly handleEnd;
+    private processBuffer;
+    private trimLeadingNewlines;
+    private readMessage;
+    private detectFraming;
+    private readJsonLineMessage;
+    private readContentLengthMessage;
+    private findHeaderBoundary;
+    private parseContentLength;
+}