@warmio/mcp 3.0.2 → 4.1.0

package/dist/install.js

@@ -1,7 +1,8 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { join, dirname, resolve } from 'path';
-import { homedir, platform } from 'os';
 import { createInterface } from 'readline';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { homedir, platform } from 'os';
+import { verifyWarmApiKey } from './server.js';
 const HOME = homedir();
 const CWD = process.cwd();
 function isRecord(value) {
@@ -17,19 +18,29 @@ function getClaudeDesktopPath() {
     return join(HOME, '.config', 'claude', 'claude_desktop_config.json');
 }
 const GLOBAL_CLIENTS = [
-    { name: 'Claude Code', configPath: join(HOME, '.claude.json'), format: 'json', alwaysInclude: true },
+    {
+        name: 'Claude Code',
+        configPath: join(HOME, '.claude.json'),
+        format: 'json',
+        alwaysInclude: true,
+    },
     { name: 'Claude Desktop', configPath: getClaudeDesktopPath(), format: 'json' },
     { name: 'Cursor', configPath: join(HOME, '.cursor', 'mcp.json'), format: 'json' },
-    { name: 'Windsurf', configPath: join(HOME, '.codeium', 'windsurf', 'mcp_config.json'), format: 'json' },
+    {
+        name: 'Windsurf',
+        configPath: join(HOME, '.codeium', 'windsurf', 'mcp_config.json'),
+        format: 'json',
+    },
     { name: 'OpenCode', configPath: join(HOME, '.config', 'opencode', 'opencode.json'), format: 'json' },
     { name: 'Codex CLI', configPath: join(HOME, '.codex', 'config.toml'), format: 'toml' },
-    { name: 'Antigravity', configPath: join(HOME, '.gemini', 'antigravity', 'mcp_config.json'), format: 'json' },
+    {
+        name: 'Antigravity',
+        configPath: join(HOME, '.gemini', 'antigravity', 'mcp_config.json'),
+        format: 'json',
+    },
     { name: 'Gemini CLI', configPath: join(HOME, '.gemini', 'settings.json'), format: 'json' },
 ];
-// Project-level MCP config files (checked in CWD)
 const PROJECT_CONFIGS = ['.mcp.json', '.cursor/mcp.json', '.vscode/mcp.json'];
-// On Windows, npx doesn't forward stdin/stdout properly for MCP's JSON-RPC protocol.
-// Using cmd /c npx ... fixes the pipe forwarding.
 const MCP_CONFIG = platform() === 'win32'
     ? { command: 'cmd', args: ['/c', 'npx', '-y', '@warmio/mcp', '--server'] }
     : { command: 'npx', args: ['-y', '@warmio/mcp', '--server'] };
@@ -49,17 +60,20 @@ function detectProjectClients() {
     return found;
 }
 function isDetected(client) {
-    if (client.alwaysInclude)
+    if (client.alwaysInclude) {
         return true;
+    }
     return existsSync(dirname(client.configPath));
 }
 function isConfigured(client) {
-    if (!existsSync(client.configPath))
+    if (!existsSync(client.configPath)) {
         return false;
+    }
     try {
         const content = readFileSync(client.configPath, 'utf-8');
-        if (client.format === 'toml')
+        if (client.format === 'toml') {
             return content.includes('[mcp_servers.warm]');
+        }
         return !!JSON.parse(content)?.mcpServers?.warm;
     }
     catch {
@@ -72,19 +86,28 @@ function configureJson(client, apiKey) {
         try {
             config = JSON.parse(readFileSync(client.configPath, 'utf-8'));
         }
-        catch { /* start fresh */ }
+        catch {
+            // Start from an empty config if the existing file is invalid.
+        }
     }
-    if (!config.mcpServers)
+    if (!config.mcpServers) {
         config.mcpServers = {};
+    }
     const servers = config.mcpServers;
     const existing = isRecord(servers.warm) ? servers.warm : undefined;
     const existingEnv = isRecord(existing?.env) ? existing.env : {};
-    // For project-level configs, preserve existing command/args if present — only inject the key.
     if (client.isProjectLevel && existing?.command) {
-        servers.warm = { ...existing, env: { ...existingEnv, WARM_API_KEY: apiKey } };
+        servers.warm = {
+            ...existing,
+            env: { ...existingEnv, WARM_API_KEY: apiKey },
+        };
     }
     else {
-        servers.warm = { ...existing, ...MCP_CONFIG, env: { ...existingEnv, WARM_API_KEY: apiKey } };
+        servers.warm = {
+            ...existing,
+            ...MCP_CONFIG,
+            env: { ...existingEnv, WARM_API_KEY: apiKey },
+        };
     }
     mkdirSync(dirname(client.configPath), { recursive: true });
     writeFileSync(client.configPath, JSON.stringify(config, null, 2) + '\n');
@@ -93,8 +116,9 @@ function configureToml(client, apiKey) {
     let content = '';
     if (existsSync(client.configPath)) {
         content = readFileSync(client.configPath, 'utf-8');
-        if (!content.endsWith('\n'))
+        if (!content.endsWith('\n')) {
             content += '\n';
+        }
     }
     const tomlCommand = platform() === 'win32' ? 'cmd' : 'npx';
     const tomlArgs = platform() === 'win32'
@@ -111,35 +135,67 @@ function configureToml(client, apiKey) {
     writeFileSync(client.configPath, nextContent.endsWith('\n') ? nextContent : `${nextContent}\n`);
 }
 function configure(client, apiKey) {
-    if (client.format === 'json')
+    if (client.format === 'json') {
         configureJson(client, apiKey);
-    else
-        configureToml(client, apiKey);
+        return;
+    }
+    configureToml(client, apiKey);
 }
-function shortPath(p) {
-    return p.replace(HOME, '~').replace(CWD, '.');
+function shortPath(filePath) {
+    return filePath.replace(HOME, '~').replace(CWD, '.');
 }
 function prompt(question) {
-    return new Promise((resolve) => {
+    return new Promise((resolvePrompt) => {
         const rl = createInterface({ input: process.stdin, output: process.stdout });
         rl.question(question, (answer) => {
             rl.close();
-            resolve(answer.trim());
+            resolvePrompt(answer.trim());
         });
     });
 }
-export async function install() {
-    const force = process.argv.includes('--force');
+function isBlockingValidationError(message) {
+    const normalized = message.toLowerCase();
+    return (normalized.includes('invalid or expired api key') ||
+        normalized.includes('pro subscription required'));
+}
+async function validateApiKey(apiKey) {
+    console.log('  Validating API key...');
+    try {
+        const result = await verifyWarmApiKey(apiKey);
+        if (!result.valid) {
+            console.log(`  Validation failed: ${result.status}`);
+            console.log('  Check https://warm.io/settings and try again.');
+            console.log('');
+            return false;
+        }
+        console.log('  API key verified.');
+        console.log('');
+        return true;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (isBlockingValidationError(message)) {
+            console.log(`  Validation failed: ${message}`);
+            console.log('');
+            return false;
+        }
+        console.log(`  Could not validate right now: ${message}`);
+        console.log('  Continuing setup with the provided key.');
+        console.log('');
+        return true;
+    }
+}
+export async function install(options = {}) {
+    const force = options.force ?? false;
+    const shouldValidateApiKey = options.validateApiKey ?? true;
     console.log('');
     console.log('  Warm MCP Server Installer');
     console.log('  -------------------------');
     console.log('');
-    // Detect global + project-level clients
     const globalClients = GLOBAL_CLIENTS.filter(isDetected);
     const projectClients = detectProjectClients();
     const allClients = [...globalClients, ...projectClients];
-    const needsSetup = allClients.filter((c) => !isConfigured(c) || force);
-    // Show all detected clients
+    const needsSetup = allClients.filter((client) => !isConfigured(client) || force);
     console.log('  MCP clients found:');
     allClients.forEach((client) => {
         const configured = isConfigured(client);
@@ -147,14 +203,12 @@ export async function install() {
         console.log(`    ${client.name.padEnd(22)} ${shortPath(client.configPath).padEnd(55)} ${status}`);
     });
     console.log('');
-    // Nothing to do
     if (needsSetup.length === 0) {
         console.log('  All clients already configured!');
         console.log('  Run with --force to update the API key.');
         console.log('');
         return;
     }
-    // Prompt for API key
     const apiKey = await prompt('  Warm API key: ');
     if (!apiKey) {
         console.log('');
@@ -162,7 +216,12 @@ export async function install() {
         console.log('');
         return;
     }
-    console.log('');
+    if (shouldValidateApiKey) {
+        const isValid = await validateApiKey(apiKey);
+        if (!isValid) {
+            return;
+        }
+    }
     console.log('  Configuring...');
     console.log('');
     needsSetup.forEach((client) => {
@@ -170,8 +229,9 @@ export async function install() {
             configure(client, apiKey);
             console.log(`    ${client.name.padEnd(22)} done`);
         }
-        catch (err) {
-            console.log(`    ${client.name.padEnd(22)} failed: ${err instanceof Error ? err.message : String(err)}`);
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.log(`    ${client.name.padEnd(22)} failed: ${message}`);
         }
     });
     console.log('');

package/dist/schemas.d.ts

@@ -0,0 +1,225 @@
+import * as z from 'zod/v4';
+export declare const emptyInputSchema: z.ZodDefault<z.ZodObject<{}, z.core.$strict>>;
+export declare const accountTypeSchema: z.ZodEnum<{
+    depository: "depository";
+    credit: "credit";
+    loan: "loan";
+    investment: "investment";
+    other: "other";
+}>;
+export declare const accountSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        depository: "depository";
+        credit: "credit";
+        loan: "loan";
+        investment: "investment";
+        other: "other";
+    }>;
+    subtype: z.ZodNullable<z.ZodString>;
+    balance: z.ZodNumber;
+    institution: z.ZodNullable<z.ZodString>;
+    mask: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const getAccountsOutputSchema: z.ZodObject<{
+    accounts: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            depository: "depository";
+            credit: "credit";
+            loan: "loan";
+            investment: "investment";
+            other: "other";
+        }>;
+        subtype: z.ZodNullable<z.ZodString>;
+        balance: z.ZodNumber;
+        institution: z.ZodNullable<z.ZodString>;
+        mask: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const getTransactionsInputSchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodInt>;
+    cursor: z.ZodOptional<z.ZodString>;
+    last_knowledge: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const transactionSchema: z.ZodObject<{
+    id: z.ZodNullable<z.ZodString>;
+    date: z.ZodNullable<z.ZodString>;
+    amount: z.ZodNumber;
+    merchant: z.ZodNullable<z.ZodString>;
+    description: z.ZodNullable<z.ZodString>;
+    category: z.ZodNullable<z.ZodString>;
+    detailed_category: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const getTransactionsOutputSchema: z.ZodObject<{
+    generated_at: z.ZodNullable<z.ZodString>;
+    next_knowledge: z.ZodNullable<z.ZodString>;
+    txns: z.ZodArray<z.ZodObject<{
+        id: z.ZodNullable<z.ZodString>;
+        date: z.ZodNullable<z.ZodString>;
+        amount: z.ZodNumber;
+        merchant: z.ZodNullable<z.ZodString>;
+        description: z.ZodNullable<z.ZodString>;
+        category: z.ZodNullable<z.ZodString>;
+        detailed_category: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    pagination: z.ZodObject<{
+        limit: z.ZodInt;
+        next_cursor: z.ZodNullable<z.ZodString>;
+        has_more: z.ZodBoolean;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const snapshotSchema: z.ZodObject<{
+    date: z.ZodString;
+    net_worth: z.ZodNumber;
+    total_assets: z.ZodNumber;
+    total_liabilities: z.ZodNumber;
+}, z.core.$strict>;
+export declare const recurringSchema: z.ZodObject<{
+    merchant: z.ZodString;
+    amount: z.ZodNumber;
+    frequency: z.ZodString;
+    next_date: z.ZodNullable<z.ZodString>;
+    type: z.ZodNullable<z.ZodString>;
+    active: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const budgetSchema: z.ZodObject<{
+    name: z.ZodString;
+    amount: z.ZodNumber;
+    spent: z.ZodNumber;
+    remaining: z.ZodNumber;
+    percent_used: z.ZodNumber;
+    period: z.ZodString;
+    status: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const goalSchema: z.ZodObject<{
+    name: z.ZodString;
+    target: z.ZodNumber;
+    current: z.ZodNumber;
+    progress_percent: z.ZodNumber;
+    target_date: z.ZodNullable<z.ZodString>;
+    status: z.ZodNullable<z.ZodString>;
+    category: z.ZodNullable<z.ZodString>;
+    monthly_contribution_needed: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const healthPillarsSchema: z.ZodObject<{
+    spend: z.ZodNullable<z.ZodNumber>;
+    save: z.ZodNullable<z.ZodNumber>;
+    borrow: z.ZodNullable<z.ZodNumber>;
+    build: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const liabilitySchema: z.ZodObject<{
+    account_id: z.ZodString;
+    type: z.ZodString;
+    balance: z.ZodNullable<z.ZodNumber>;
+    apr_percentage: z.ZodNullable<z.ZodNumber>;
+    minimum_payment: z.ZodNullable<z.ZodNumber>;
+    next_payment_due_date: z.ZodNullable<z.ZodString>;
+    is_overdue: z.ZodNullable<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const holdingSchema: z.ZodObject<{
+    account_id: z.ZodString;
+    security_name: z.ZodNullable<z.ZodString>;
+    symbol: z.ZodNullable<z.ZodString>;
+    type: z.ZodNullable<z.ZodString>;
+    quantity: z.ZodNumber;
+    value: z.ZodNullable<z.ZodNumber>;
+    cost_basis: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const categorySpendingSchema: z.ZodObject<{
+    category: z.ZodString;
+    amount: z.ZodNumber;
+}, z.core.$strict>;
+export declare const financialHealthSchema: z.ZodObject<{
+    score: z.ZodNullable<z.ZodNumber>;
+    label: z.ZodNullable<z.ZodString>;
+    data_completeness: z.ZodNullable<z.ZodNumber>;
+    pillars: z.ZodNullable<z.ZodObject<{
+        spend: z.ZodNullable<z.ZodNumber>;
+        save: z.ZodNullable<z.ZodNumber>;
+        borrow: z.ZodNullable<z.ZodNumber>;
+        build: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+    message: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const getFinancialStateOutputSchema: z.ZodObject<{
+    generated_at: z.ZodString;
+    snapshots: z.ZodArray<z.ZodObject<{
+        date: z.ZodString;
+        net_worth: z.ZodNumber;
+        total_assets: z.ZodNumber;
+        total_liabilities: z.ZodNumber;
+    }, z.core.$strict>>;
+    recurring: z.ZodArray<z.ZodObject<{
+        merchant: z.ZodString;
+        amount: z.ZodNumber;
+        frequency: z.ZodString;
+        next_date: z.ZodNullable<z.ZodString>;
+        type: z.ZodNullable<z.ZodString>;
+        active: z.ZodBoolean;
+    }, z.core.$strict>>;
+    budgets: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        amount: z.ZodNumber;
+        spent: z.ZodNumber;
+        remaining: z.ZodNumber;
+        percent_used: z.ZodNumber;
+        period: z.ZodString;
+        status: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    goals: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        target: z.ZodNumber;
+        current: z.ZodNumber;
+        progress_percent: z.ZodNumber;
+        target_date: z.ZodNullable<z.ZodString>;
+        status: z.ZodNullable<z.ZodString>;
+        category: z.ZodNullable<z.ZodString>;
+        monthly_contribution_needed: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+    health: z.ZodObject<{
+        score: z.ZodNullable<z.ZodNumber>;
+        label: z.ZodNullable<z.ZodString>;
+        data_completeness: z.ZodNullable<z.ZodNumber>;
+        pillars: z.ZodNullable<z.ZodObject<{
+            spend: z.ZodNullable<z.ZodNumber>;
+            save: z.ZodNullable<z.ZodNumber>;
+            borrow: z.ZodNullable<z.ZodNumber>;
+            build: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>>;
+        message: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    liabilities: z.ZodArray<z.ZodObject<{
+        account_id: z.ZodString;
+        type: z.ZodString;
+        balance: z.ZodNullable<z.ZodNumber>;
+        apr_percentage: z.ZodNullable<z.ZodNumber>;
+        minimum_payment: z.ZodNullable<z.ZodNumber>;
+        next_payment_due_date: z.ZodNullable<z.ZodString>;
+        is_overdue: z.ZodNullable<z.ZodBoolean>;
+    }, z.core.$strict>>;
+    holdings: z.ZodArray<z.ZodObject<{
+        account_id: z.ZodString;
+        security_name: z.ZodNullable<z.ZodString>;
+        symbol: z.ZodNullable<z.ZodString>;
+        type: z.ZodNullable<z.ZodString>;
+        quantity: z.ZodNumber;
+        value: z.ZodNullable<z.ZodNumber>;
+        cost_basis: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+    category_spending: z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        amount: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const verifyKeyOutputSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    status: z.ZodString;
+}, z.core.$strict>;
+export type Account = z.infer<typeof accountSchema>;
+export type FinancialHealth = z.infer<typeof financialHealthSchema>;
+export type GetAccountsOutput = z.infer<typeof getAccountsOutputSchema>;
+export type GetFinancialStateOutput = z.infer<typeof getFinancialStateOutputSchema>;
+export type GetTransactionsInput = z.infer<typeof getTransactionsInputSchema>;
+export type GetTransactionsOutput = z.infer<typeof getTransactionsOutputSchema>;
+export type VerifyKeyOutput = z.infer<typeof verifyKeyOutputSchema>;

package/dist/schemas.js

@@ -0,0 +1,186 @@
+import * as z from 'zod/v4';
+const dateSchema = z
+    .string()
+    .regex(/^\d{4}-\d{2}-\d{2}$/, 'Expected date in YYYY-MM-DD format.');
+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).'),
+    cursor: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Opaque pagination cursor from a previous get_transactions response.'),
+    last_knowledge: dateTimeSchema
+        .optional()
+        .describe('Incremental sync checkpoint from a prior get_transactions response. Cannot be combined with cursor.'),
+})
+    .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({
+    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(),
+    })
+        .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({
+    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(),
+    status: z.string(),
+})
+    .strict();

package/dist/server.d.ts

@@ -1,10 +1,8 @@
 /**
- * Warm MCP Server
+ * Warm MCP stdio entrypoint and compatibility exports.
  *
- * Provides financial data from the Warm API as MCP tools.
- * Reads API key from WARM_API_KEY env var or ~/.config/warm/api_key.
- *
- * Four read-only tools: get_accounts, get_transactions, get_snapshots, verify_key.
- * The AI client handles all analysis — no sandbox needed.
+ * The typed MCP contract and Warm API helpers live in `warm-server.ts`.
  */
-export {};
+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>;