@warmio/mcp 4.3.1 → 4.3.2

package/README.md

@@ -7,13 +7,17 @@ This package starts in local `stdio` mode by default and also supports optional
 ## Install
 
 ```bash
-npx @warmio/mcp
+npx -y @warmio/mcp@latest
 ```
 
 The installer detects supported MCP clients, prompts for your Warm API key, and writes the local
 `stdio` server config automatically. The key is stored once in your local Warm profile instead of
 being duplicated into every MCP client config.
 
+Use `@latest` when you want the newest published package. Bare `npx @warmio/mcp` can reuse a
+cached or local copy and leave you on an older version. If you want a deterministic install,
+replace `@latest` with an exact version such as `@warmio/mcp@4.3.2`.
+
 When launched without arguments in a non-interactive context, the binary automatically starts the
 `stdio` server instead of the installer. This keeps MCP clients that invoke the package directly
 from falling into the interactive setup flow.
@@ -34,12 +38,15 @@ stay secret-free:
   "mcpServers": {
     "warm": {
       "command": "npx",
-      "args": ["-y", "@warmio/mcp", "--server"]
+      "args": ["-y", "@warmio/mcp@latest", "--server"]
     }
   }
 }
 ```
 
+If you already have a client config that uses bare `@warmio/mcp`, update it to `@warmio/mcp@latest`
+or an exact version and restart the client.
+
 Optional auth overrides:
 
 - `WARM_API_KEY`
@@ -52,7 +59,7 @@ On Windows, prefer:
   "mcpServers": {
     "warm": {
       "command": "cmd",
-      "args": ["/c", "npx", "-y", "@warmio/mcp", "--server"]
+      "args": ["/c", "npx", "-y", "@warmio/mcp@latest", "--server"]
     }
   }
 }
@@ -63,7 +70,7 @@ On Windows, prefer:
 If your MCP client supports Streamable HTTP, you can run:
 
 ```bash
-npx @warmio/mcp http --host 127.0.0.1 --port 3000 --path /mcp
+npx -y @warmio/mcp@latest http --host 127.0.0.1 --port 3000 --path /mcp
 ```
 
 Relevant optional environment variables:

package/dist/install.js

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { dirname, join, resolve } from 'path';
 import { homedir, platform } from 'os';
 import { verifyWarmApiKey } from './server.js';
-import { getWarmApiKeyPath } from './config-paths.js';
+import { getWarmApiKeyPath, readConfigFile } from './config-paths.js';
 const HOME = homedir();
 const CWD = process.cwd();
 function isRecord(value) {
@@ -46,10 +46,13 @@ const GLOBAL_CLIENTS = [
     { name: 'Gemini CLI', configPath: join(HOME, '.gemini', 'settings.json'), format: 'json' },
 ];
 const PROJECT_CONFIGS = ['.mcp.json', '.cursor/mcp.json', '.vscode/mcp.json'];
+const MCP_PACKAGE_SPEC = '@warmio/mcp@latest';
 const MCP_CONFIG = platform() === 'win32'
-    ? { command: 'cmd', args: ['/c', 'npx', '-y', '@warmio/mcp', '--server'] }
-    : { command: 'npx', args: ['-y', '@warmio/mcp', '--server'] };
+    ? { command: 'cmd', args: ['/c', 'npx', '-y', MCP_PACKAGE_SPEC, '--server'] }
+    : { command: 'npx', args: ['-y', MCP_PACKAGE_SPEC, '--server'] };
 const WARM_API_KEY_PATH = getWarmApiKeyPath();
+const WARM_TOML_BLOCK_PATTERN = /\n?\[mcp_servers\.warm\][\s\S]*?(?=\n\[[^\n]+\]|\s*$)/g;
+const WARM_TOML_ENV_BLOCK_PATTERN = /\n?\[mcp_servers\.warm\.env\][\s\S]*?(?=\n\[[^\n]+\]|\s*$)/g;
 function detectProjectClients() {
     const found = [];
     for (const name of PROJECT_CONFIGS) {
@@ -71,20 +74,133 @@ function isDetected(client) {
     }
     return existsSync(dirname(client.configPath));
 }
-function isConfigured(client) {
-    if (!existsSync(client.configPath)) {
-        return false;
+function getStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
     }
+    return value.filter((entry) => typeof entry === 'string');
+}
+function isWarmPackageSpecifier(value) {
+    return /^@warmio\/mcp(?:@.+)?$/.test(value);
+}
+function isLegacyWarmPackageSpecifier(value) {
+    return /^@anthropic\/warm-mcp-server(?:@.+)?$/.test(value);
+}
+function normalizePathLikeValue(value) {
+    return value.replace(/\\/g, '/').toLowerCase();
+}
+function isLocalWarmMcpPath(value) {
+    const normalized = normalizePathLikeValue(value);
+    return normalized.includes('/warm-mcp/dist/index.js') || normalized.endsWith('/warm-mcp');
+}
+function isSupportedWarmInvocation(command, args) {
+    return [command, ...args].some((value) => typeof value === 'string' &&
+        (isWarmPackageSpecifier(value) || isLocalWarmMcpPath(value)));
+}
+function isLegacyWarmInvocation(command, args) {
+    return [command, ...args].some((value) => typeof value === 'string' && isLegacyWarmPackageSpecifier(value));
+}
+function getJsonEnvStatus(server) {
+    const env = isRecord(server?.env) ? server.env : undefined;
+    const inlineApiKey = typeof env?.WARM_API_KEY === 'string' && env.WARM_API_KEY.trim()
+        ? env.WARM_API_KEY.trim()
+        : null;
+    return {
+        hasApiKeyFileOverride: typeof env?.WARM_API_KEY_FILE === 'string' && env.WARM_API_KEY_FILE.trim().length > 0,
+        inlineApiKey,
+    };
+}
+function getJsonStatus(client, content) {
     try {
-        const content = readFileSync(client.configPath, 'utf-8');
-        if (client.format === 'toml') {
-            return content.includes('[mcp_servers.warm]');
+        const parsed = JSON.parse(content);
+        const servers = isRecord(parsed.mcpServers) ? parsed.mcpServers : undefined;
+        const server = isRecord(servers?.warm) ? servers.warm : undefined;
+        const envStatus = getJsonEnvStatus(server);
+        if (!server) {
+            return { client, state: 'missing', ...envStatus };
+        }
+        const command = typeof server.command === 'string' ? server.command : undefined;
+        const args = getStringArray(server.args);
+        if (client.isProjectLevel && command && !isLegacyWarmInvocation(command, args)) {
+            return { client, state: 'configured', ...envStatus };
         }
-        return !!JSON.parse(content)?.mcpServers?.warm;
+        if (isSupportedWarmInvocation(command, args)) {
+            return { client, state: 'configured', ...envStatus };
+        }
+        return { client, state: 'needs_migration', ...envStatus };
     }
     catch {
-        return false;
+        return { client, state: 'missing', hasApiKeyFileOverride: false, inlineApiKey: null };
+    }
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function getTomlSection(content, sectionName) {
+    const pattern = new RegExp(`(?:^|\\n)\\[${escapeRegExp(sectionName)}\\]\\n([\\s\\S]*?)(?=\\n\\[[^\\n]+\\]|\\s*$)`);
+    const match = content.match(pattern);
+    return match ? match[0].replace(/^\n/, '') : null;
+}
+function getTomlStringValue(block, key) {
+    if (!block) {
+        return undefined;
+    }
+    const pattern = new RegExp(`^${escapeRegExp(key)}\\s*=\\s*(?:"([^"]*)"|'([^']*)')\\s*$`, 'm');
+    const match = block.match(pattern);
+    return match?.[1] ?? match?.[2];
+}
+function getTomlStringArrayValue(block, key) {
+    if (!block) {
+        return [];
+    }
+    const pattern = new RegExp(`^${escapeRegExp(key)}\\s*=\\s*\\[([\\s\\S]*?)\\]\\s*$`, 'm');
+    const match = block.match(pattern);
+    if (!match) {
+        return [];
+    }
+    const values = [];
+    const valuePattern = /"((?:\\.|[^"])*)"|'((?:\\.|[^'])*)'/g;
+    for (const item of match[1].matchAll(valuePattern)) {
+        values.push(item[1] ?? item[2] ?? '');
+    }
+    return values;
+}
+function getTomlEnvStatus(content) {
+    const envBlock = getTomlSection(content, 'mcp_servers.warm.env');
+    if (!envBlock) {
+        return { envLines: [], hasApiKeyFileOverride: false, inlineApiKey: null };
+    }
+    const envLines = envBlock.split('\n').slice(1).filter((line) => line.trim().length > 0);
+    const inlineApiKey = getTomlStringValue(envBlock, 'WARM_API_KEY')?.trim() || null;
+    const apiKeyFile = getTomlStringValue(envBlock, 'WARM_API_KEY_FILE');
+    return {
+        envLines,
+        hasApiKeyFileOverride: typeof apiKeyFile === 'string' && apiKeyFile.trim().length > 0,
+        inlineApiKey,
+    };
+}
+function getTomlStatus(client, content) {
+    const warmBlock = getTomlSection(content, 'mcp_servers.warm');
+    const envStatus = getTomlEnvStatus(content);
+    if (!warmBlock) {
+        return { client, state: 'missing', ...envStatus };
+    }
+    const command = getTomlStringValue(warmBlock, 'command');
+    const args = getTomlStringArrayValue(warmBlock, 'args');
+    if (isSupportedWarmInvocation(command, args)) {
+        return { client, state: 'configured', ...envStatus };
+    }
+    return { client, state: 'needs_migration', ...envStatus };
+}
+function getClientStatus(client) {
+    if (!existsSync(client.configPath)) {
+        return { client, state: 'missing', hasApiKeyFileOverride: false, inlineApiKey: null };
     }
+    const content = readFileSync(client.configPath, 'utf-8');
+    if (client.format === 'toml') {
+        return getTomlStatus(client, content);
+    }
+    return getJsonStatus(client, content);
 }
 function configureJson(client) {
     let config = {};
@@ -103,8 +219,14 @@ function configureJson(client) {
     const existing = isRecord(servers.warm) ? servers.warm : undefined;
     const existingEnv = isRecord(existing?.env) ? existing.env : {};
     const nextEnv = { ...existingEnv };
+    const existingCommand = typeof existing?.command === 'string' ? existing.command : undefined;
+    const existingArgs = getStringArray(existing?.args);
+    const preserveProjectCommand = client.isProjectLevel &&
+        !!existingCommand &&
+        !isLegacyWarmInvocation(existingCommand, existingArgs) &&
+        !isWarmPackageSpecifier(existingCommand);
     delete nextEnv.WARM_API_KEY;
-    if (client.isProjectLevel && existing?.command) {
+    if (preserveProjectCommand) {
         servers.warm = {
             ...existing,
             ...(Object.keys(nextEnv).length > 0 ? { env: nextEnv } : {}),
@@ -130,15 +252,21 @@ function configureToml(client) {
     }
     const tomlCommand = platform() === 'win32' ? 'cmd' : 'npx';
     const tomlArgs = platform() === 'win32'
-        ? '["/c", "npx", "-y", "@warmio/mcp", "--server"]'
-        : '["-y", "@warmio/mcp", "--server"]';
+        ? `["/c", "npx", "-y", "${MCP_PACKAGE_SPEC}", "--server"]`
+        : `["-y", "${MCP_PACKAGE_SPEC}", "--server"]`;
     const warmBlock = `[mcp_servers.warm]\ncommand = "${tomlCommand}"\nargs = ${tomlArgs}\n`;
-    const warmBlockPattern = /\n?\[mcp_servers\.warm\][\s\S]*?(?=\n\[[^\n]+\]|\s*$)/g;
-    let nextContent = content.replace(warmBlockPattern, '').trimEnd();
+    const preservedEnvLines = getTomlEnvStatus(content).envLines.filter((line) => !/^\s*WARM_API_KEY\s*=/.test(line));
+    let nextContent = content
+        .replace(WARM_TOML_ENV_BLOCK_PATTERN, '')
+        .replace(WARM_TOML_BLOCK_PATTERN, '')
+        .trimEnd();
     if (nextContent.length > 0) {
         nextContent += '\n\n';
     }
     nextContent += warmBlock;
+    if (preservedEnvLines.length > 0) {
+        nextContent += `\n[mcp_servers.warm.env]\n${preservedEnvLines.join('\n')}\n`;
+    }
     mkdirSync(dirname(client.configPath), { recursive: true });
     writeFileSync(client.configPath, nextContent.endsWith('\n') ? nextContent : `${nextContent}\n`);
 }
@@ -197,6 +325,18 @@ function storeApiKey(apiKey) {
     mkdirSync(dirname(WARM_API_KEY_PATH), { recursive: true });
     writeFileSync(WARM_API_KEY_PATH, `${apiKey}\n`, { mode: 0o600 });
 }
+function getStatusLabel(status, force) {
+    if (force) {
+        return 'not configured';
+    }
+    if (status === 'configured') {
+        return 'configured';
+    }
+    if (status === 'needs_migration') {
+        return 'needs migration';
+    }
+    return 'not configured';
+}
 export async function install(options = {}) {
     const force = options.force ?? false;
     const shouldValidateApiKey = options.validateApiKey ?? true;
@@ -207,12 +347,11 @@ export async function install(options = {}) {
     const globalClients = GLOBAL_CLIENTS.filter(isDetected);
     const projectClients = detectProjectClients();
     const allClients = [...globalClients, ...projectClients];
-    const needsSetup = allClients.filter((client) => !isConfigured(client) || force);
+    const clientStatuses = allClients.map(getClientStatus);
+    const needsSetup = clientStatuses.filter((status) => force || status.state !== 'configured');
     console.log('  MCP clients found:');
-    allClients.forEach((client) => {
-        const configured = isConfigured(client);
-        const status = configured && !force ? 'configured' : 'not configured';
-        console.log(`    ${client.name.padEnd(22)} ${shortPath(client.configPath).padEnd(55)} ${status}`);
+    clientStatuses.forEach((status) => {
+        console.log(`    ${status.client.name.padEnd(22)} ${shortPath(status.client.configPath).padEnd(55)} ${getStatusLabel(status.state, force)}`);
     });
     console.log('');
     if (needsSetup.length === 0) {
@@ -221,34 +360,69 @@ export async function install(options = {}) {
         console.log('');
         return;
     }
-    const apiKey = await prompt('  Warm API key: ');
-    if (!apiKey) {
-        console.log('');
-        console.log('  No key provided. Get one at https://warm.io/settings');
-        console.log('');
-        return;
+    const storedApiKey = readConfigFile(WARM_API_KEY_PATH);
+    const migratedApiKey = needsSetup.find((status) => typeof status.inlineApiKey === 'string' && status.inlineApiKey.length > 0)
+        ?.inlineApiKey ?? null;
+    const hasApiKeyFileOverride = needsSetup.some((status) => status.hasApiKeyFileOverride);
+    let apiKeyToStore = null;
+    let shouldStoreApiKey = false;
+    let shouldPromptForApiKey = force;
+    if (!shouldPromptForApiKey) {
+        if (storedApiKey) {
+            console.log('  Using stored Warm API key.');
+            console.log('');
+            apiKeyToStore = storedApiKey;
+        }
+        else if (migratedApiKey) {
+            console.log('  Reusing Warm API key from existing client config.');
+            console.log('');
+            apiKeyToStore = migratedApiKey;
+            shouldStoreApiKey = true;
+        }
+        else if (hasApiKeyFileOverride) {
+            console.log('  Reusing existing WARM_API_KEY_FILE override.');
+            console.log('');
+        }
+        else {
+            shouldPromptForApiKey = true;
+        }
+    }
+    if (shouldPromptForApiKey) {
+        const apiKey = await prompt('  Warm API key: ');
+        if (!apiKey) {
+            console.log('');
+            console.log('  No key provided. Get one at https://warm.io/settings');
+            console.log('');
+            return;
+        }
+        apiKeyToStore = apiKey;
+        shouldStoreApiKey = true;
     }
-    if (shouldValidateApiKey) {
-        const isValid = await validateApiKey(apiKey);
+    if (apiKeyToStore && shouldValidateApiKey && (shouldStoreApiKey || force)) {
+        const isValid = await validateApiKey(apiKeyToStore);
         if (!isValid) {
             return;
         }
     }
-    storeApiKey(apiKey);
+    if (apiKeyToStore && shouldStoreApiKey) {
+        storeApiKey(apiKeyToStore);
+    }
     console.log('  Configuring...');
     console.log('');
-    needsSetup.forEach((client) => {
+    needsSetup.forEach((status) => {
         try {
-            configure(client);
-            console.log(`    ${client.name.padEnd(22)} done`);
+            configure(status.client);
+            console.log(`    ${status.client.name.padEnd(22)} done`);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            console.log(`    ${client.name.padEnd(22)} failed: ${message}`);
+            console.log(`    ${status.client.name.padEnd(22)} failed: ${message}`);
         }
     });
     console.log('');
-    console.log(`  Stored API key at ${shortPath(WARM_API_KEY_PATH)}`);
+    if (apiKeyToStore) {
+        console.log(`  Stored API key at ${shortPath(WARM_API_KEY_PATH)}`);
+    }
     console.log('  All set! Restart your MCP clients and try:');
     console.log('    "What\'s my net worth?"');
     console.log('');

package/dist/load-env.js

@@ -29,7 +29,7 @@ export function loadDotEnv() {
     }
     for (const candidate of candidates) {
         if (fs.existsSync(candidate)) {
-            loadEnvFile({ path: candidate, override: false });
+            loadEnvFile({ path: candidate, override: false, quiet: true });
             return;
         }
     }

package/dist/server.d.ts

@@ -1,5 +1,5 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { Implementation } from '@modelcontextprotocol/sdk/types.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';

package/dist/server.js

@@ -1,7 +1,10 @@
 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, getAccountsOutputSchema, getFinancialStateOutputSchema, getTransactionsInputSchema, getTransactionsOutputSchema, verifyKeyOutputSchema, } from './schemas.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() {
@@ -18,12 +21,6 @@ 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: [
@@ -37,35 +34,70 @@ function createStructuredToolResult(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`.');
+    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 client.getTransactions(args));
+        return createStructuredToolResult(await tool.handler(parseResult.data));
     });
-    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;

package/dist/warm-api-client.js

@@ -163,7 +163,7 @@ export async function apiRequest(endpoint, params = {}, options = {}) {
     const requestOptions = createWarmApiClientConfig(options);
     const apiKey = requestOptions.apiKeyResolver?.() ?? getConfiguredApiKey();
     if (!apiKey) {
-        throw new Error('WARM_API_KEY not set. Run "npx @warmio/mcp" to configure or set WARM_API_KEY.');
+        throw new Error('WARM_API_KEY not set. Run "npx -y @warmio/mcp@latest" to configure or set WARM_API_KEY.');
     }
     const url = new URL(endpoint, requestOptions.apiUrl);
     Object.entries(params).forEach(([key, value]) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warmio/mcp",
-  "version": "4.3.1",
+  "version": "4.3.2",
   "description": "Warm MCP server for local stdio and Streamable HTTP access",
   "type": "module",
   "main": "dist/index.js",