@warmio/mcp 7.0.1 → 9.0.0

package/dist/schemas.js

@@ -1,248 +1,2 @@
-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 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 describeOperationInputSchema = {
-    operation_id: z.string().min(1),
-    input: automationInputSchema
-        .optional()
-        .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()
-        .uuid()
-        .optional()
-        .describe('Approval ID returned by describe_operation for the exact write input.'),
-};
-export const transactionIndexSchema = z
-    .object({
-    total: z.number().int().nonnegative(),
-    months: z.array(z
-        .object({
-        month: monthSchema,
-        count: z.number().int().nonnegative(),
-    })
-        .strict()),
-})
-    .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({
-        spend: z.number().finite().nullable(),
-        save: z.number().finite().nullable(),
-        borrow: z.number().finite().nullable(),
-        build: z.number().finite().nullable(),
-    })
-        .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,
-    updated_at: dateTimeSchema,
-    content_hash: z.string(),
-    byte_length: z.number().int().nonnegative(),
-    counts: z
-        .object({
-        accounts: z.number().int().nonnegative(),
-        transaction_months: z.number().int().nonnegative(),
-        transactions: z.number().int().nonnegative(),
-        snapshots: z.number().int().nonnegative(),
-    })
-        .strict(),
-})
-    .strict();
-export const verifyKeyOutputSchema = {
-    status: z.string(),
-    valid: z.boolean(),
-};
+export { automationInputSchema, financialContextAccountSchema as accountSchema, financialContextMetaSchema, financialContextSchema, financialContextTransactionSchema as transactionSchema, latestTransactionsSchema, transactionMonthSchema, } from '@warmio/contracts/schemas';
+export { describeOperationMcpInputShape as describeOperationInputSchema, emptyMcpInputShape as emptyInputSchema, getTransactionsMcpInputShape as getTransactionsInputSchema, invokeOperationMcpInputShape as invokeOperationInputSchema, searchOperationsMcpInputShape as searchOperationsInputSchema, } from '@warmio/contracts/mcp';

package/dist/server.d.ts

@@ -1,5 +1,6 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { type Implementation } from '@modelcontextprotocol/sdk/types.js';
+import { type PrivateMcpMode } from '@warmio/contracts/mcp';
 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';
@@ -7,7 +8,7 @@ export interface WarmServerOptions extends WarmApiClientOptions {
     mode?: WarmServerMode;
     serverInfo?: Implementation;
 }
-export type WarmServerMode = 'automation' | 'context';
+export type WarmServerMode = PrivateMcpMode;
 export declare const API_URL: string;
 export declare const WARM_SERVER_INFO: {
     name: string;

package/dist/server.js

@@ -3,8 +3,8 @@ 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 { getTransactionsMcpInputSchema, normalizeGetTransactionsMcpInput, privateMcpToolDefinitions, } from '@warmio/contracts/mcp';
 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() {
@@ -29,8 +29,7 @@ function createStructuredToolResult(structuredContent, isError = false) {
                 text: JSON.stringify(structuredContent, null, 2),
             },
         ],
-        ...(isError ? { isError: true } : {}),
-        structuredContent,
+        ...(isError ? { isError: true } : { structuredContent }),
     };
 }
 function createToolFailure(error) {
@@ -48,69 +47,56 @@ function createToolFailure(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 };
+function getToolDefinition(name, mode) {
+    const definition = privateMcpToolDefinitions.find((candidate) => candidate.mode === mode && candidate.name === name);
+    if (!definition)
+        throw new Error(`Missing ${mode} MCP contract for ${name}.`);
+    return definition;
+}
+function getListToolOutputSchema(outputSchema) {
+    const schema = toJsonSchemaCompat(outputSchema, {
+        pipeStrategy: 'output',
+        strictUnions: true,
+    });
+    if (schema.type === 'object')
+        return schema;
+    if (Array.isArray(schema.anyOf) &&
+        schema.anyOf.length > 0 &&
+        schema.anyOf.every((candidate) => typeof candidate === 'object' && candidate !== null && candidate.type === 'object')) {
+        return { ...schema, type: 'object' };
     }
-    throw new Error('Call get_transactions with `month` in YYYY-MM format, `latest: true`, or no arguments.');
+    return undefined;
 }
 export function registerWarmTools(server, options = {}, mode = 'context') {
     const client = createWarmApiClient({ ...options, audience: mode });
     const contextTools = [
         {
-            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.',
+            ...getToolDefinition('get_financial_context', 'context'),
             handler: async () => await client.getFinancialContext(),
-            inputShape: emptyInputSchema,
-            name: 'get_financial_context',
         },
         {
-            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.',
+            ...getToolDefinition('get_transactions', 'context'),
             handler: async (args) => {
-                return await client.getTransactions(parseGetTransactionsArgs(args));
+                return await client.getTransactions(normalizeGetTransactionsMcpInput(args));
             },
-            inputShape: getTransactionsInputSchema,
-            name: 'get_transactions',
         },
         {
-            annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-            description: 'Read-only API key validation for the configured Warm account.',
+            ...getToolDefinition('verify_key', 'context'),
             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.',
+            ...getToolDefinition('search_operations', 'automation'),
             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.',
+            ...getToolDefinition('describe_operation', 'automation'),
             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.',
+            ...getToolDefinition('invoke_operation', 'automation'),
             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;
@@ -120,15 +106,19 @@ export function registerWarmTools(server, options = {}, mode = 'context') {
         },
     });
     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,
-            }),
-            name: tool.name,
-        })),
+        tools: tools.map((tool) => {
+            const outputSchema = getListToolOutputSchema(tool.outputSchema);
+            return {
+                description: tool.description,
+                annotations: tool.annotations,
+                inputSchema: toJsonSchemaCompat(z.object(tool.inputShape).strict(), {
+                    pipeStrategy: 'input',
+                    strictUnions: true,
+                }),
+                ...(outputSchema ? { outputSchema } : {}),
+                name: tool.name,
+            };
+        }),
     }));
     server.server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const tool = tools.find((candidate) => candidate.name === request.params.name);
@@ -141,11 +131,9 @@ export function registerWarmTools(server, options = {}, mode = 'context') {
             throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for tool ${request.params.name}: ${parseResult.error.message}`);
         }
         if (tool.name === 'get_transactions') {
-            try {
-                parseGetTransactionsArgs(parseResult.data);
-            }
-            catch (error) {
-                throw new McpError(ErrorCode.InvalidParams, error instanceof Error ? error.message : String(error));
+            const transactionInput = await getTransactionsMcpInputSchema.safeParseAsync(parseResult.data);
+            if (!transactionInput.success) {
+                throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for tool ${request.params.name}: ${transactionInput.error.message}`);
             }
         }
         try {

package/dist/types.d.ts

@@ -3,5 +3,5 @@ export declare const WARM_AUTOMATION_TOOL_NAMES: readonly ["search_operations",
 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 { 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 { PrivateMcpMode } from '@warmio/contracts/mcp';
 export type { WarmServerOptions } from './server.js';

package/dist/warm-api-client.d.ts

@@ -1,159 +1,25 @@
-import { type WarmApiAudience } from './config-paths.js';
+import { type PrivateMcpMode } from '@warmio/contracts/mcp';
+import type { AutomationInput, AutomationOperation, FinancialContext, FinancialContextAccount, FinancialContextBudget, FinancialContextGoal, FinancialContextHealth, FinancialContextHolding, FinancialContextLiability, FinancialContextMeta, FinancialContextPosition, FinancialContextRecurring, FinancialContextSnapshot, FinancialContextStatus, FinancialContextTransaction, FinancialContextTransactionIndex, LatestTransactions, TransactionMonth } from '@warmio/contracts/types';
+export type { AutomationInput, AutomationOperation, FinancialContext, FinancialContextMeta, LatestTransactions, TransactionMonth, } from '@warmio/contracts/types';
 export interface WarmApiClientOptions {
-    audience?: WarmApiAudience;
+    audience?: PrivateMcpMode;
     apiKeyResolver?: () => string | null;
     apiUrl?: string;
     fetchImplementation?: typeof fetch;
     requestTimeoutMs?: number;
 }
-export interface TransactionIndex {
-    total: number;
-    months: Array<{
-        month: string;
-        count: number;
-    }>;
-}
-export interface Position {
-    date: string | null;
-    net_worth: number | null;
-    cash: number | null;
-    debt: number | null;
-    investments: number | null;
-    other_assets: number | null;
-    total_assets: number | null;
-}
-export interface Account {
-    id: string;
-    name: string;
-    type: 'depository' | 'credit' | 'loan' | 'investment' | 'brokerage' | 'other';
-    subtype: string | null;
-    group: 'cash' | 'debt' | 'investments' | null;
-    institution: string | null;
-    mask: string | null;
-    balance: number | null;
-    available: number | null;
-    currency: string | null;
-    updated_at: string | null;
-}
-export interface Status {
-    position: Position | null;
-    accounts: Account[];
-}
-export interface Recurring {
-    id: string;
-    account_id: string | null;
-    direction: 'inflow' | 'outflow' | null;
-    frequency: 'WEEKLY' | 'BIWEEKLY' | 'MONTHLY' | 'QUARTERLY' | 'SEMI_ANNUALLY' | 'ANNUALLY' | null;
-    status: 'active' | 'inactive' | 'dismissed' | null;
-    merchant: string | null;
-    amount: number | null;
-    next_date: string | null;
-}
-export interface Budget {
-    id: string;
-    name: string;
-    type: 'category' | 'merchant';
-    period: 'weekly' | 'biweekly' | 'monthly';
-    status: 'under' | 'warning' | 'over';
-    amount: number;
-    spent: number;
-    remaining: number;
-    used_percent: number;
-}
-export interface Goal {
-    id: string;
-    name: string;
-    category: string;
-    status: 'not_started' | 'in_progress' | 'on_track' | 'behind' | 'completed';
-    target: number;
-    current: number;
-    progress_percent: number;
-    target_date: string | null;
-}
-export interface Snapshot {
-    date: string;
-    net_worth: number | null;
-    cash: number | null;
-    debt: number | null;
-    income: number | null;
-    expenses: number | null;
-    cash_flow: number | null;
-    savings_rate: number | null;
-    investments: number | null;
-    assets: number | null;
-    health_score: number | null;
-}
-export interface Liability {
-    account_id: string | null;
-    type: 'credit' | 'student' | 'mortgage' | 'other' | null;
-    balance: number | null;
-    minimum_payment: number | null;
-    due_date: string | null;
-    interest_rate: number | null;
-    rate_type: 'fixed' | 'variable' | null;
-    overdue: boolean | null;
-}
-export interface Holding {
-    account_id: string | null;
-    symbol: string | null;
-    name: string | null;
-    type: 'cash' | 'derivative' | 'equity' | 'etf' | 'fixed_income' | 'mutual_fund' | 'other' | null;
-    quantity: number | null;
-    value: number | null;
-    cost_basis: number | null;
-}
-export interface Health {
-    score: number;
-    label: 'Needs Attention' | 'Good' | 'Strong';
-    level: 'critical' | 'poor' | 'fair' | 'good' | 'strong';
-    summary: string;
-    data_completeness: number;
-    pillars: {
-        spend: number | null;
-        save: number | null;
-        borrow: number | null;
-        build: number | null;
-    } | null;
-}
-export interface FinancialContext extends Record<string, unknown> {
-    version: 'v1';
-    updated_at: string;
-    currency: 'USD';
-    status: Status;
-    transactions: TransactionIndex;
-    recurring: Recurring[];
-    budgets: Budget[];
-    goals: Goal[];
-    snapshots: Snapshot[];
-    liabilities: Liability[];
-    holdings: Holding[];
-    health: Health | null;
-}
-export interface Transaction {
-    id: string;
-    account_id: string | null;
-    date: string | null;
-    amount: number;
-    merchant: string | null;
-    name: string | null;
-    category: string | null;
-    subcategory: string | null;
-    pending: boolean | null;
-    currency: string | null;
-}
-export interface TransactionMonth extends Record<string, unknown> {
-    month: string;
-    start_date: string;
-    end_date: string;
-    count: number;
-    items: Transaction[];
-}
-export interface LatestTransactions extends Record<string, unknown> {
-    since: string;
-    window_days: 10;
-    count: number;
-    items: Transaction[];
-}
+export type Account = FinancialContextAccount;
+export type Budget = FinancialContextBudget;
+export type Goal = FinancialContextGoal;
+export type Health = FinancialContextHealth;
+export type Holding = FinancialContextHolding;
+export type Liability = FinancialContextLiability;
+export type Position = FinancialContextPosition;
+export type Recurring = FinancialContextRecurring;
+export type Snapshot = FinancialContextSnapshot;
+export type Status = FinancialContextStatus;
+export type Transaction = FinancialContextTransaction;
+export type TransactionIndex = FinancialContextTransactionIndex;
 export type GetTransactionsInput = {
     month: string;
     latest?: never;
@@ -162,42 +28,14 @@ export type GetTransactionsInput = {
     month?: never;
 };
 export type GetTransactionsOutput = TransactionMonth | LatestTransactions;
-export interface FinancialContextMeta extends Record<string, unknown> {
-    version: 'v1';
-    user_id: string;
-    context_id: string;
-    generated_at: string;
-    updated_at: string;
-    content_hash: string;
-    byte_length: number;
-    counts: {
-        accounts: number;
-        transaction_months: number;
-        transactions: number;
-        snapshots: number;
-    };
-}
 export interface VerifyKeyOutput extends Record<string, unknown> {
     audience?: 'automation' | 'context' | 'oauth';
     status: string;
     valid: boolean;
 }
-export interface AutomationOperation extends Record<string, unknown> {
-    confirmation_required: boolean;
-    description: string;
-    method: 'DELETE' | 'GET' | 'PATCH' | 'POST' | 'PUT';
-    operation_id: string;
-    path: string;
-    risk: Array<'read' | 'write' | 'destructive' | 'external_effect'>;
-    summary: string;
-}
-export interface AutomationInput {
-    body?: Record<string, unknown>;
-    params?: Record<string, string>;
-}
-export interface AutomationOperationDescription extends AutomationOperation {
+export type AutomationOperationDescription = AutomationOperation & {
     input_schema: Record<string, unknown>;
-}
+};
 export interface DescribeOperationOutput extends Record<string, unknown> {
     approval?: {
         approval_url: string;
@@ -225,7 +63,7 @@ export interface WarmApiClient {
     validateAudience(): Promise<VerifyKeyOutput>;
     verifyKey(): Promise<VerifyKeyOutput>;
 }
-export declare function getConfiguredApiKey(audience?: WarmApiAudience): string | null;
+export declare function getConfiguredApiKey(audience?: PrivateMcpMode): string | null;
 export declare function resetConfiguredApiKeyCache(): void;
 interface WarmApiResponse<TBody> {
     body: TBody;
@@ -239,5 +77,4 @@ export declare class WarmApiError extends Error {
     constructor(message: string, response: WarmApiResponse<unknown>);
 }
 export declare function createWarmApiClient(options?: WarmApiClientOptions): WarmApiClient;
-export declare function verifyWarmApiKey(apiKey: string, audience?: WarmApiAudience): Promise<VerifyKeyOutput>;
-export {};
+export declare function verifyWarmApiKey(apiKey: string, audience?: PrivateMcpMode): Promise<VerifyKeyOutput>;