@warmio/mcp 4.2.2 → 4.3.1

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,75 @@
-/**
- * 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 { createWarmApiClient, getConfiguredApiKey, verifyWarmApiKey, apiRequest, } from './warm-api-client.js';
+import { emptyInputSchema, getAccountsOutputSchema, getFinancialStateOutputSchema, getTransactionsInputSchema, getTransactionsOutputSchema, verifyKeyOutputSchema, } 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(),
+};
+const READ_ONLY_TOOL_ANNOTATIONS = {
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    readOnlyHint: true,
+};
+function createStructuredToolResult(structuredContent) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(structuredContent, null, 2),
+            },
+        ],
+        structuredContent,
+    };
+}
+export function registerWarmTools(server, options = {}) {
+    const client = createWarmApiClient(options);
+    server.registerTool('get_accounts', {
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        description: 'Read-only list of connected financial accounts with balances, subtypes, institutions, and masks when available.',
+        inputSchema: emptyInputSchema,
+        outputSchema: getAccountsOutputSchema,
+    }, async () => createStructuredToolResult(await client.getAccounts()));
+    server.registerTool('get_transactions', {
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        description: 'Read-only transaction export with strict opaque cursor pagination and optional last_knowledge incremental sync.',
+        inputSchema: getTransactionsInputSchema,
+        outputSchema: getTransactionsOutputSchema,
+    }, async (args) => {
+        if (args.cursor && args.last_knowledge) {
+            throw new Error('`cursor` cannot be combined with `last_knowledge`.');
+        }
+        return createStructuredToolResult(await client.getTransactions(args));
+    });
+    server.registerTool('get_financial_state', {
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        description: 'Read-only broad financial state bundle with snapshots, recurring payments, budgets, goals, financial health, liabilities, holdings, and category spending.',
+        inputSchema: emptyInputSchema,
+        outputSchema: getFinancialStateOutputSchema,
+    }, async () => createStructuredToolResult(await client.getFinancialState()));
+    server.registerTool('verify_key', {
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        description: 'Read-only API key validation for the configured Warm account.',
+        inputSchema: emptyInputSchema,
+        outputSchema: verifyKeyOutputSchema,
+    }, async () => createStructuredToolResult(await client.verifyKey()));
+}
+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;
+}

package/dist/stdio.js

@@ -0,0 +1,200 @@
+import process from 'node:process';
+const CONTENT_LENGTH_HEADER = 'content-length:';
+export class AdaptiveStdioTransport {
+    stdin;
+    stdout;
+    onclose;
+    onerror;
+    onmessage;
+    buffer = Buffer.alloc(0);
+    clientFraming = null;
+    closed = false;
+    started = false;
+    constructor(stdin = process.stdin, stdout = process.stdout) {
+        this.stdin = stdin;
+        this.stdout = stdout;
+    }
+    async start() {
+        if (this.started) {
+            throw new Error('AdaptiveStdioTransport already started');
+        }
+        this.started = true;
+        this.stdin.on('data', this.handleData);
+        this.stdin.on('error', this.handleError);
+        this.stdin.on('end', this.handleEnd);
+        this.stdin.resume();
+    }
+    async close() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.stdin.off('data', this.handleData);
+        this.stdin.off('error', this.handleError);
+        this.stdin.off('end', this.handleEnd);
+        this.stdin.pause();
+        this.buffer = Buffer.alloc(0);
+        this.onclose?.();
+    }
+    async send(message, _options) {
+        const json = JSON.stringify(message);
+        const framing = this.clientFraming ?? 'content-length';
+        const payload = framing === 'jsonl'
+            ? `${json}\n`
+            : `Content-Length: ${Buffer.byteLength(json, 'utf8')}\r\n\r\n${json}`;
+        await new Promise((resolve) => {
+            if (this.stdout.write(payload)) {
+                resolve();
+                return;
+            }
+            this.stdout.once('drain', resolve);
+        });
+    }
+    handleData = (chunk) => {
+        const incoming = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        this.buffer = this.buffer.length === 0 ? incoming : Buffer.concat([this.buffer, incoming]);
+        this.processBuffer();
+    };
+    handleError = (error) => {
+        this.onerror?.(error);
+    };
+    handleEnd = () => {
+        void this.close();
+    };
+    processBuffer() {
+        while (true) {
+            try {
+                this.trimLeadingNewlines();
+                const parsed = this.readMessage();
+                if (parsed === null) {
+                    return;
+                }
+                this.clientFraming ??= parsed.framing;
+                this.onmessage?.(parsed.message);
+            }
+            catch (error) {
+                this.onerror?.(error instanceof Error ? error : new Error(String(error)));
+                this.buffer = Buffer.alloc(0);
+                return;
+            }
+        }
+    }
+    trimLeadingNewlines() {
+        while (this.buffer.length > 0) {
+            if (this.buffer[0] === 0x0a) {
+                this.buffer = this.buffer.subarray(1);
+                continue;
+            }
+            if (this.buffer.length > 1 && this.buffer[0] === 0x0d && this.buffer[1] === 0x0a) {
+                this.buffer = this.buffer.subarray(2);
+                continue;
+            }
+            return;
+        }
+    }
+    readMessage() {
+        const framing = this.clientFraming ?? this.detectFraming();
+        if (framing === null) {
+            return null;
+        }
+        return framing === 'content-length'
+            ? this.readContentLengthMessage()
+            : this.readJsonLineMessage();
+    }
+    detectFraming() {
+        if (this.buffer.length === 0) {
+            return null;
+        }
+        const preview = this.buffer
+            .subarray(0, Math.min(this.buffer.length, 32))
+            .toString('utf8')
+            .toLowerCase();
+        if (preview.startsWith(CONTENT_LENGTH_HEADER)) {
+            return 'content-length';
+        }
+        if (preview.startsWith('{') || preview.startsWith('[')) {
+            return 'jsonl';
+        }
+        const newlineIndex = this.buffer.indexOf(0x0a);
+        if (newlineIndex === -1) {
+            return null;
+        }
+        const firstLine = this.buffer.toString('utf8', 0, newlineIndex).replace(/\r$/, '').trimStart();
+        if (firstLine.toLowerCase().startsWith(CONTENT_LENGTH_HEADER)) {
+            return 'content-length';
+        }
+        if (firstLine.startsWith('{') || firstLine.startsWith('[')) {
+            return 'jsonl';
+        }
+        throw new Error(`Unsupported MCP stdio framing: ${JSON.stringify(firstLine.slice(0, 80))}`);
+    }
+    readJsonLineMessage() {
+        const newlineIndex = this.buffer.indexOf(0x0a);
+        if (newlineIndex === -1) {
+            return null;
+        }
+        const rawLine = this.buffer.toString('utf8', 0, newlineIndex).replace(/\r$/, '');
+        this.buffer = this.buffer.subarray(newlineIndex + 1);
+        if (rawLine.trim() === '') {
+            return this.readMessage();
+        }
+        return {
+            framing: 'jsonl',
+            message: JSON.parse(rawLine),
+        };
+    }
+    readContentLengthMessage() {
+        const headerBoundary = this.findHeaderBoundary();
+        if (headerBoundary === null) {
+            return null;
+        }
+        const { bodyStart, headerEnd } = headerBoundary;
+        const headerText = this.buffer.toString('utf8', 0, headerEnd);
+        const contentLength = this.parseContentLength(headerText);
+        if (this.buffer.length < bodyStart + contentLength) {
+            return null;
+        }
+        const bodyText = this.buffer.toString('utf8', bodyStart, bodyStart + contentLength);
+        this.buffer = this.buffer.subarray(bodyStart + contentLength);
+        return {
+            framing: 'content-length',
+            message: JSON.parse(bodyText),
+        };
+    }
+    findHeaderBoundary() {
+        const crlfBoundary = this.buffer.indexOf('\r\n\r\n');
+        if (crlfBoundary !== -1) {
+            return {
+                bodyStart: crlfBoundary + 4,
+                headerEnd: crlfBoundary,
+            };
+        }
+        const lfBoundary = this.buffer.indexOf('\n\n');
+        if (lfBoundary !== -1) {
+            return {
+                bodyStart: lfBoundary + 2,
+                headerEnd: lfBoundary,
+            };
+        }
+        return null;
+    }
+    parseContentLength(headerText) {
+        const headers = headerText.split(/\r?\n/);
+        for (const header of headers) {
+            const separatorIndex = header.indexOf(':');
+            if (separatorIndex === -1) {
+                continue;
+            }
+            const name = header.slice(0, separatorIndex).trim().toLowerCase();
+            if (name !== 'content-length') {
+                continue;
+            }
+            const value = Number.parseInt(header.slice(separatorIndex + 1).trim(), 10);
+            if (!Number.isFinite(value) || value < 0) {
+                throw new Error(`Invalid Content-Length header: ${header}`);
+            }
+            return value;
+        }
+        throw new Error('Missing Content-Length header');
+    }
+}