@warmio/mcp 5.0.1 → 7.0.0

package/dist/schemas.js

@@ -1,160 +1,247 @@
 import { z } from 'zod';
+const monthSchema = z.string().regex(/^\d{4}-\d{2}$/, 'Expected YYYY-MM month.');
 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 = {};
-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 automationInputSchema = z
+    .object({
+    body: z.record(z.unknown()).optional(),
+    params: z.record(z.string()).optional(),
+})
+    .strict();
+export const searchOperationsInputSchema = {
+    query: z.string().max(200).optional().describe('Words describing the action or data you need.'),
 };
-export const getTransactionsInputSchema = {
-    cursor: z
-        .string()
-        .min(1)
+export const describeOperationInputSchema = {
+    operation_id: z.string().min(1),
+    input: automationInputSchema
         .optional()
-        .describe('Opaque pagination cursor from a prior get_transactions response.'),
-    last_knowledge: dateTimeSchema
-        .optional()
-        .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
+        .describe('Exact intended input. Required to obtain approval for a write operation.'),
+};
+export const invokeOperationInputSchema = {
+    operation_id: z.string().min(1),
+    input: automationInputSchema.optional(),
+    approval_id: z
         .string()
-        .min(1)
-        .max(120)
+        .uuid()
         .optional()
-        .describe('Optional merchant or description search query.'),
-};
-export const getTransactionsOutputSchema = {
-    generated_at: dateTimeSchema.nullable(),
-    next_knowledge: dateTimeSchema.nullable(),
-    pagination: z
-        .object({
-        has_more: z.boolean(),
-        limit: z.number().int().min(1).max(1000),
-        next_cursor: z.string().nullable(),
-    })
-        .strict(),
-    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()),
+        .describe('Approval ID returned by describe_operation for the exact write input.'),
 };
-export const getFinancialStateOutputSchema = {
-    budgets: z.array(z
+export const transactionIndexSchema = z
+    .object({
+    total: z.number().int().nonnegative(),
+    months: 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(),
+        month: monthSchema,
+        count: z.number().int().nonnegative(),
     })
         .strict()),
-    category_spending: z.array(z
+})
+    .strict();
+export const positionSchema = z
+    .object({
+    date: dateSchema.nullable(),
+    net_worth: z.number().finite().nullable(),
+    cash: z.number().finite().nullable(),
+    debt: z.number().finite().nullable(),
+    investments: z.number().finite().nullable(),
+    other_assets: z.number().finite().nullable(),
+    total_assets: z.number().finite().nullable(),
+})
+    .strict();
+export const accountSchema = z
+    .object({
+    id: z.string(),
+    name: z.string(),
+    type: z.enum(['depository', 'credit', 'loan', 'investment', 'brokerage', 'other']),
+    subtype: z.string().nullable(),
+    group: z.enum(['cash', 'debt', 'investments']).nullable(),
+    institution: z.string().nullable(),
+    mask: z.string().nullable(),
+    balance: z.number().finite().nullable(),
+    available: z.number().finite().nullable(),
+    currency: z.string().nullable(),
+    updated_at: dateTimeSchema.nullable(),
+})
+    .strict();
+export const statusSchema = z
+    .object({
+    position: positionSchema.nullable(),
+    accounts: z.array(accountSchema),
+})
+    .strict();
+export const recurringSchema = z
+    .object({
+    id: z.string(),
+    account_id: z.string().nullable(),
+    direction: z.enum(['inflow', 'outflow']).nullable(),
+    frequency: z
+        .enum(['WEEKLY', 'BIWEEKLY', 'MONTHLY', 'QUARTERLY', 'SEMI_ANNUALLY', 'ANNUALLY'])
+        .nullable(),
+    status: z.enum(['active', 'inactive', 'dismissed']).nullable(),
+    merchant: z.string().nullable(),
+    amount: z.number().finite().nullable(),
+    next_date: dateSchema.nullable(),
+})
+    .strict();
+export const budgetSchema = z
+    .object({
+    id: z.string(),
+    name: z.string(),
+    type: z.enum(['category', 'merchant']),
+    period: z.enum(['weekly', 'biweekly', 'monthly']),
+    status: z.enum(['under', 'warning', 'over']),
+    amount: z.number().finite(),
+    spent: z.number().finite(),
+    remaining: z.number().finite(),
+    used_percent: z.number().finite(),
+})
+    .strict();
+export const goalSchema = z
+    .object({
+    id: z.string(),
+    name: z.string(),
+    category: z.string(),
+    status: z.enum(['not_started', 'in_progress', 'on_track', 'behind', 'completed']),
+    target: z.number().finite(),
+    current: z.number().finite(),
+    progress_percent: z.number().finite(),
+    target_date: dateSchema.nullable(),
+})
+    .strict();
+export const snapshotSchema = z
+    .object({
+    date: dateSchema,
+    net_worth: z.number().finite().nullable(),
+    cash: z.number().finite().nullable(),
+    debt: z.number().finite().nullable(),
+    income: z.number().finite().nullable(),
+    expenses: z.number().finite().nullable(),
+    cash_flow: z.number().finite().nullable(),
+    savings_rate: z.number().finite().nullable(),
+    investments: z.number().finite().nullable(),
+    assets: z.number().finite().nullable(),
+    health_score: z.number().finite().nullable(),
+})
+    .strict();
+export const liabilitySchema = z
+    .object({
+    account_id: z.string().nullable(),
+    type: z.enum(['credit', 'student', 'mortgage', 'other']).nullable(),
+    balance: z.number().finite().nullable(),
+    minimum_payment: z.number().finite().nullable(),
+    due_date: dateSchema.nullable(),
+    interest_rate: z.number().finite().nullable(),
+    rate_type: z.enum(['fixed', 'variable']).nullable(),
+    overdue: z.boolean().nullable(),
+})
+    .strict();
+export const holdingSchema = z
+    .object({
+    account_id: z.string().nullable(),
+    symbol: z.string().nullable(),
+    name: z.string().nullable(),
+    type: z
+        .enum(['cash', 'derivative', 'equity', 'etf', 'fixed_income', 'mutual_fund', 'other'])
+        .nullable(),
+    quantity: z.number().finite().nullable(),
+    value: z.number().finite().nullable(),
+    cost_basis: z.number().finite().nullable(),
+})
+    .strict();
+export const healthSchema = z
+    .object({
+    score: z.number().finite(),
+    label: z.enum(['Needs Attention', 'Good', 'Strong']),
+    level: z.enum(['critical', 'poor', 'fair', 'good', 'strong']),
+    summary: z.string(),
+    data_completeness: z.number().finite(),
+    pillars: z
         .object({
-        amount: z.number().finite(),
-        category: z.string(),
+        spend: z.number().finite().nullable(),
+        save: z.number().finite().nullable(),
+        borrow: z.number().finite().nullable(),
+        build: z.number().finite().nullable(),
     })
-        .strict()),
+        .strict()
+        .nullable(),
+})
+    .strict();
+export const financialContextSchema = z
+    .object({
+    version: z.literal('v1'),
+    updated_at: dateTimeSchema,
+    currency: z.literal('USD'),
+    status: statusSchema,
+    transactions: transactionIndexSchema,
+    recurring: z.array(recurringSchema),
+    budgets: z.array(budgetSchema),
+    goals: z.array(goalSchema),
+    snapshots: z.array(snapshotSchema),
+    liabilities: z.array(liabilitySchema),
+    holdings: z.array(holdingSchema),
+    health: healthSchema.nullable(),
+})
+    .strict();
+export const transactionSchema = z
+    .object({
+    id: z.string(),
+    account_id: z.string().nullable(),
+    date: dateSchema.nullable(),
+    amount: z.number().finite(),
+    merchant: z.string().nullable(),
+    name: z.string().nullable(),
+    category: z.string().nullable(),
+    subcategory: z.string().nullable(),
+    pending: z.boolean().nullable(),
+    currency: z.string().nullable(),
+})
+    .strict();
+export const transactionMonthSchema = z
+    .object({
+    month: monthSchema,
+    start_date: dateSchema,
+    end_date: dateSchema,
+    count: z.number().int().nonnegative(),
+    items: z.array(transactionSchema),
+})
+    .strict();
+export const latestTransactionsSchema = z
+    .object({
+    since: dateSchema,
+    window_days: z.literal(10),
+    count: z.number().int().nonnegative(),
+    items: z.array(transactionSchema),
+})
+    .strict();
+export const getTransactionsInputSchema = {
+    month: monthSchema
+        .optional()
+        .describe('Transaction month in YYYY-MM format. Mutually exclusive with latest. Months outside the covered range return an error.'),
+    latest: z
+        .boolean()
+        .optional()
+        .describe('When true, return the fixed 10-day latest window. Mutually exclusive with month. A bare call with no arguments defaults to latest: true.'),
+};
+export const financialContextMetaSchema = z
+    .object({
+    version: z.literal('v1'),
+    user_id: z.string(),
+    context_id: z.string(),
     generated_at: dateTimeSchema,
-    goals: z.array(z
+    updated_at: dateTimeSchema,
+    content_hash: z.string(),
+    byte_length: z.number().int().nonnegative(),
+    counts: 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(),
+        accounts: z.number().int().nonnegative(),
+        transaction_months: z.number().int().nonnegative(),
+        transactions: z.number().int().nonnegative(),
+        snapshots: z.number().int().nonnegative(),
     })
         .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()),
-};
+})
+    .strict();
 export const verifyKeyOutputSchema = {
     status: z.string(),
     valid: z.boolean(),

package/dist/server.d.ts

@@ -1,15 +1,17 @@
 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 };
+import { createWarmApiClient, type WarmApiClientOptions, getConfiguredApiKey, verifyWarmApiKey, WarmApiError } from './warm-api-client.js';
+export { createWarmApiClient, getConfiguredApiKey, verifyWarmApiKey, WarmApiError };
 export type { WarmApiClientOptions } from './warm-api-client.js';
 export interface WarmServerOptions extends WarmApiClientOptions {
+    mode?: WarmServerMode;
     serverInfo?: Implementation;
 }
+export type WarmServerMode = 'automation' | 'context';
 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 registerWarmTools(server: McpServer, options?: WarmApiClientOptions, mode?: WarmServerMode): void;
 export declare function createWarmServer(options?: WarmServerOptions): McpServer;

package/dist/server.js

@@ -3,10 +3,10 @@ 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';
+import { createWarmApiClient, getConfiguredApiKey, verifyWarmApiKey, WarmApiError, } from './warm-api-client.js';
+import { describeOperationInputSchema, emptyInputSchema, getTransactionsInputSchema, invokeOperationInputSchema, searchOperationsInputSchema, } from './schemas.js';
+export { createWarmApiClient, getConfiguredApiKey, verifyWarmApiKey, WarmApiError };
+export const API_URL = process.env.WARM_API_URL || 'https://app.warm.io';
 function getPackageVersion() {
     try {
         const packageJson = fs.readFileSync(new URL('../package.json', import.meta.url), 'utf-8');
@@ -21,7 +21,7 @@ export const WARM_SERVER_INFO = {
     name: 'warm',
     version: getPackageVersion(),
 };
-function createStructuredToolResult(structuredContent) {
+function createStructuredToolResult(structuredContent, isError = false) {
     return {
         content: [
             {
@@ -29,48 +29,91 @@ function createStructuredToolResult(structuredContent) {
                 text: JSON.stringify(structuredContent, null, 2),
             },
         ],
+        ...(isError ? { isError: true } : {}),
         structuredContent,
     };
 }
-export function registerWarmTools(server, options = {}) {
-    const client = createWarmApiClient(options);
-    const tools = [
+function createToolFailure(error) {
+    if (error instanceof WarmApiError) {
+        return createStructuredToolResult({
+            body: error.body,
+            headers: error.headers,
+            message: error.message,
+            status: error.status,
+        }, true);
+    }
+    return createStructuredToolResult({
+        error: {
+            message: error instanceof Error ? error.message : String(error),
+        },
+    }, true);
+}
+function parseGetTransactionsArgs(args) {
+    const hasMonth = typeof args.month === 'string';
+    const hasLatestKey = Object.prototype.hasOwnProperty.call(args, 'latest');
+    const hasLatest = args.latest === true;
+    if (hasMonth && hasLatestKey) {
+        throw new Error('`month` and `latest` are mutually exclusive.');
+    }
+    if (hasMonth) {
+        return { month: args.month };
+    }
+    if (hasLatest || Object.keys(args).length === 0) {
+        return { latest: true };
+    }
+    throw new Error('Call get_transactions with `month` in YYYY-MM format, `latest: true`, or no arguments.');
+}
+export function registerWarmTools(server, options = {}, mode = 'context') {
+    const client = createWarmApiClient({ ...options, audience: mode });
+    const contextTools = [
         {
-            description: 'Read-only list of connected financial accounts with balances, subtypes, institutions, and masks when available.',
-            handler: async () => await client.getAccounts(),
+            annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+            description: 'Read-only compact FinancialContext JSON. Includes status.position, status.accounts, transaction index total/months, recurring, budgets, goals, snapshots, liabilities, holdings, and health. Transaction items are not inline; use get_transactions for items.',
+            handler: async () => await client.getFinancialContext(),
             inputShape: emptyInputSchema,
-            name: 'get_accounts',
+            name: 'get_financial_context',
         },
         {
-            description: 'Read-only transaction export with strict opaque cursor pagination and optional last_knowledge incremental sync.',
+            annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+            description: 'Read-only transactions from the FinancialContext artifact. Pass exactly one selector: `month` in YYYY-MM format for a month page, or `latest: true` for the fixed latest window. A bare call with no arguments defaults to `latest: true`. The latest window is fixed at 10 days and is not caller-configurable. `month` and `latest` are mutually exclusive. Months outside the covered range return an error.',
             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);
+                return await client.getTransactions(parseGetTransactionsArgs(args));
             },
             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',
-        },
-        {
+            annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
             description: 'Read-only API key validation for the configured Warm account.',
-            handler: async () => await client.verifyKey(),
+            handler: async () => await client.validateAudience(),
             inputShape: emptyInputSchema,
             name: 'verify_key',
         },
     ];
+    const automationTools = [
+        {
+            annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+            description: 'Search the supported Warm operation catalog. Use this first to find the smallest matching operation.',
+            handler: async (args) => await client.searchOperations(typeof args.query === 'string' ? args.query : undefined),
+            inputShape: searchOperationsInputSchema,
+            name: 'search_operations',
+        },
+        {
+            annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false },
+            description: 'Describe one operation, including its input schema and risk. For write operations, pass the exact intended input to receive an approval with its ID, status, URL, and expiry.',
+            handler: async (args) => await client.describeOperation(args.operation_id, args.input),
+            inputShape: describeOperationInputSchema,
+            name: 'describe_operation',
+        },
+        {
+            annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false },
+            description: 'Invoke one previously discovered Warm operation. Every write operation requires the approval_id returned for the exact same input by describe_operation.',
+            handler: async (args) => await client.invokeOperation(args.operation_id, args.input, typeof args.approval_id === 'string' ? args.approval_id : undefined),
+            inputShape: invokeOperationInputSchema,
+            name: 'invoke_operation',
+        },
+    ];
+    const tools = mode === 'automation' ? automationTools : contextTools;
     server.server.registerCapabilities({
         tools: {
             listChanged: true,
@@ -79,6 +122,7 @@ export function registerWarmTools(server, options = {}) {
     server.server.setRequestHandler(ListToolsRequestSchema, () => ({
         tools: tools.map((tool) => ({
             description: tool.description,
+            annotations: tool.annotations,
             inputSchema: toJsonSchemaCompat(z.object(tool.inputShape).strict(), {
                 pipeStrategy: 'input',
                 strictUnions: true,
@@ -96,12 +140,32 @@ export function registerWarmTools(server, options = {}) {
         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));
+        if (tool.name === 'get_transactions') {
+            try {
+                parseGetTransactionsArgs(parseResult.data);
+            }
+            catch (error) {
+                throw new McpError(ErrorCode.InvalidParams, error instanceof Error ? error.message : String(error));
+            }
+        }
+        try {
+            if (tool.name !== 'verify_key') {
+                await client.validateAudience();
+            }
+            const result = await tool.handler(parseResult.data);
+            const isFailedAutomationOperation = tool.name === 'invoke_operation' &&
+                typeof result.status === 'number' &&
+                result.status >= 400;
+            return createStructuredToolResult(result, isFailedAutomationOperation);
+        }
+        catch (error) {
+            return createToolFailure(error);
+        }
     });
 }
 export function createWarmServer(options = {}) {
-    const { serverInfo, ...clientOptions } = options;
+    const { mode = 'context', serverInfo, ...clientOptions } = options;
     const server = new McpServer(serverInfo || WARM_SERVER_INFO);
-    registerWarmTools(server, clientOptions);
+    registerWarmTools(server, clientOptions, mode);
     return server;
 }

package/dist/types.d.ts

@@ -1,4 +1,7 @@
-export declare const WARM_TOOL_NAMES: readonly ["get_accounts", "get_transactions", "get_financial_state", "verify_key"];
+export declare const WARM_CONTEXT_TOOL_NAMES: readonly ["get_financial_context", "get_transactions", "verify_key"];
+export declare const WARM_AUTOMATION_TOOL_NAMES: readonly ["search_operations", "describe_operation", "invoke_operation"];
+export declare const WARM_TOOL_NAMES: readonly ["get_financial_context", "get_transactions", "verify_key", "search_operations", "describe_operation", "invoke_operation"];
 export type WarmToolName = (typeof WARM_TOOL_NAMES)[number];
-export type { GetAccountsOutput, GetTransactionsInput, GetTransactionsOutput, VerifyKeyOutput, WarmApiAccount, WarmApiBudget, WarmApiClient, WarmApiClientOptions, WarmApiGoal, WarmApiHolding, WarmApiLiability, WarmApiTransaction, WarmFinancialState, } from './warm-api-client.js';
+export type { Account, AutomationInput, AutomationOperation, AutomationOperationDescription, Budget, DescribeOperationOutput, FinancialContext, FinancialContextMeta, GetTransactionsInput, GetTransactionsOutput, Goal, Health, Holding, InvokeOperationOutput, LatestTransactions, Liability, Position, Recurring, Snapshot, Status, Transaction, TransactionIndex, TransactionMonth, VerifyKeyOutput, WarmApiClient, WarmApiClientOptions, } from './warm-api-client.js';
+export type { WarmApiAudience } from './config-paths.js';
 export type { WarmServerOptions } from './server.js';

package/dist/types.js

@@ -1,6 +1,11 @@
-export const WARM_TOOL_NAMES = [
-    'get_accounts',
+export const WARM_CONTEXT_TOOL_NAMES = [
+    'get_financial_context',
     'get_transactions',
-    'get_financial_state',
     'verify_key',
 ];
+export const WARM_AUTOMATION_TOOL_NAMES = [
+    'search_operations',
+    'describe_operation',
+    'invoke_operation',
+];
+export const WARM_TOOL_NAMES = [...WARM_CONTEXT_TOOL_NAMES, ...WARM_AUTOMATION_TOOL_NAMES];