@sardis/mcp-server 0.2.7 → 1.1.0

package/dist/tools/fiat.js

@@ -1,393 +1,776 @@
 /**
- * Fiat Rails tools for MCP server
+ * Fiat/Treasury tools for MCP server
  *
- * Tools for funding wallets from bank accounts and withdrawing to fiat.
+ * USD-first launch with multi-currency-ready schemas.
  */
 import { z } from 'zod';
 import { getConfig } from '../config.js';
 import { apiRequest } from '../api.js';
-// Schemas
+const AccountHolderSyncSchema = z.object({
+    account_token: z.string().optional(),
+});
+const ListFinancialAccountsSchema = z.object({
+    account_token: z.string().optional(),
+    refresh: z.boolean().optional(),
+});
+const LinkExternalBankSchema = z.object({
+    financial_account_token: z.string(),
+    verification_method: z.enum(['MICRO_DEPOSIT', 'PRENOTE', 'EXTERNALLY_VERIFIED']).optional(),
+    owner_type: z.enum(['INDIVIDUAL', 'BUSINESS']).optional(),
+    owner: z.string(),
+    account_type: z.enum(['CHECKING', 'SAVINGS']).optional(),
+    routing_number: z.string(),
+    account_number: z.string(),
+    name: z.string().optional(),
+    currency: z.string().optional(),
+    country: z.string().optional(),
+    account_token: z.string().optional(),
+    company_id: z.string().optional(),
+    user_defined_id: z.string().optional(),
+});
+const VerifyMicroDepositsSchema = z.object({
+    token: z.string(),
+    micro_deposits: z.tuple([z.string(), z.string()]),
+});
 const FundWalletSchema = z.object({
-    wallet_id: z.string().optional().describe('Wallet to fund'),
-    amount: z.union([z.string(), z.number()]).describe('Amount to fund in USD'),
-    source: z.enum(['ach', 'wire', 'card', 'bank_account']).optional().describe('Funding source type'),
-    currency: z.string().optional().describe('Currency code'),
-    source_id: z.string().optional().describe('Saved payment method ID'),
+    wallet_id: z.string().optional().describe('Optional wallet reference for metadata'),
+    amount: z.union([z.string(), z.number()]).optional().describe('Legacy amount in major units'),
+    amount_minor: z.number().int().positive().optional().describe('Amount in minor units'),
+    source: z.enum(['ach', 'wire', 'card', 'bank_account']).optional(),
+    currency: z.string().optional(),
+    source_id: z.string().optional(),
+    financial_account_token: z.string().optional(),
+    external_bank_account_token: z.string().optional(),
+    method: z.enum(['ACH_NEXT_DAY', 'ACH_SAME_DAY']).optional(),
+    sec_code: z.enum(['CCD', 'PPD', 'WEB']).optional(),
+    memo: z.string().optional(),
+    idempotency_key: z.string().optional(),
+    user_defined_id: z.string().optional(),
 });
 const WithdrawSchema = z.object({
-    wallet_id: z.string().describe('Wallet to withdraw from'),
-    amount: z.string().describe('Amount to withdraw in USD'),
-    destination_id: z.string().describe('Bank account ID to withdraw to'),
+    wallet_id: z.string().optional(),
+    amount: z.union([z.string(), z.number()]).optional(),
+    amount_minor: z.number().int().positive().optional(),
+    destination_id: z.string().optional().describe('Legacy destination alias'),
+    account_id: z.string().optional().describe('Legacy destination alias'),
+    financial_account_token: z.string().optional(),
+    external_bank_account_token: z.string().optional(),
+    method: z.enum(['ACH_NEXT_DAY', 'ACH_SAME_DAY']).optional(),
+    sec_code: z.enum(['CCD', 'PPD', 'WEB']).optional(),
+    memo: z.string().optional(),
+    idempotency_key: z.string().optional(),
+    user_defined_id: z.string().optional(),
 });
 const StatusSchema = z.object({
-    transfer_id: z.string().optional().describe('Transfer ID to check'),
-    funding_id: z.string().optional().describe('Funding ID to check (alias for transfer_id)'),
+    payment_token: z.string().optional(),
+    transfer_id: z.string().optional(),
+    funding_id: z.string().optional(),
+});
+const FundingListSchema = z.object({
+    type: z.enum(['deposit', 'withdrawal', 'all']).optional(),
+    limit: z.number().int().positive().optional(),
 });
-// Tool definitions
+function toMinorUnits(input) {
+    if (input === undefined)
+        return 0;
+    const value = typeof input === 'number' ? input : Number.parseFloat(input);
+    if (!Number.isFinite(value) || value <= 0)
+        return 0;
+    return Math.round(value * 100);
+}
+function buildSimulatedPayment(prefix, direction, amountMinor) {
+    const token = `${prefix}_${Date.now().toString(36)}`;
+    const common = {
+        payment_token: token,
+        status: 'PENDING',
+        result: 'APPROVED',
+        direction,
+        method: 'ACH_NEXT_DAY',
+        currency: 'USD',
+        pending_amount: amountMinor,
+        settled_amount: 0,
+        financial_account_token: 'fa_simulated',
+        external_bank_account_token: 'eba_simulated',
+    };
+    return prefix === 'fund' ? { ...common, funding_id: token } : { ...common, withdrawal_id: token };
+}
+function serialize(result) {
+    return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+}
+function validateLiveTreasuryArgs(financialAccountToken, externalBankAccountToken, amountMinor) {
+    if (!financialAccountToken)
+        return 'financial_account_token is required in live mode';
+    if (!externalBankAccountToken)
+        return 'external_bank_account_token is required in live mode';
+    if (amountMinor <= 0)
+        return 'amount or amount_minor must be greater than 0';
+    return null;
+}
 export const fiatToolDefinitions = [
+    {
+        name: 'sardis_sync_treasury_account_holder',
+        description: 'Sync financial accounts from Lithic for an account holder token.',
+        inputSchema: {
+            type: 'object',
+            properties: { account_token: { type: 'string' } },
+            required: [],
+        },
+    },
+    {
+        name: 'sardis_list_financial_accounts',
+        description: 'List treasury financial accounts available for ACH funding and settlement.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                account_token: { type: 'string' },
+                refresh: { type: 'boolean' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'sardis_link_external_bank_account',
+        description: 'Create and link an external bank account for ACH rails.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                financial_account_token: { type: 'string' },
+                verification_method: { type: 'string', enum: ['MICRO_DEPOSIT', 'PRENOTE', 'EXTERNALLY_VERIFIED'] },
+                owner_type: { type: 'string', enum: ['INDIVIDUAL', 'BUSINESS'] },
+                owner: { type: 'string' },
+                account_type: { type: 'string', enum: ['CHECKING', 'SAVINGS'] },
+                routing_number: { type: 'string' },
+                account_number: { type: 'string' },
+                name: { type: 'string' },
+                currency: { type: 'string' },
+                country: { type: 'string' },
+            },
+            required: ['financial_account_token', 'owner', 'routing_number', 'account_number'],
+        },
+    },
+    {
+        name: 'sardis_verify_micro_deposits',
+        description: 'Verify external bank account ownership with two micro-deposit amounts.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                token: { type: 'string' },
+                micro_deposits: { type: 'array', items: { type: 'string' }, minItems: 2, maxItems: 2 },
+            },
+            required: ['token', 'micro_deposits'],
+        },
+    },
     {
         name: 'sardis_fund_wallet',
-        description: 'Fund a wallet from a bank account, wire transfer, or card. Use this to add funds to a wallet. USD is automatically converted to USDC.',
+        description: 'fund treasury via ACH collection. USD-first route for card spend backing.',
         inputSchema: {
             type: 'object',
             properties: {
-                amount: { type: 'number', description: 'Amount to fund in USD' },
-                wallet_id: { type: 'string', description: 'Wallet to fund' },
-                source: {
-                    type: 'string',
-                    enum: ['ach', 'wire', 'card', 'bank_account'],
-                    description: 'Funding source type. ACH is free but slower, wire is faster, card has fees.',
-                },
-                currency: { type: 'string', description: 'Currency code (default: USD)' },
-                source_id: { type: 'string', description: 'Saved payment method ID' },
+                amount: { type: 'number', description: 'Legacy amount in major units (USD)' },
+                amount_minor: { type: 'number', description: 'Amount in minor units (e.g. cents)' },
+                financial_account_token: { type: 'string' },
+                external_bank_account_token: { type: 'string' },
+                method: { type: 'string', enum: ['ACH_NEXT_DAY', 'ACH_SAME_DAY'] },
+                sec_code: { type: 'string', enum: ['CCD', 'PPD', 'WEB'] },
+                memo: { type: 'string' },
             },
-            required: ['amount'],
+            required: [],
         },
     },
     {
         name: 'sardis_withdraw_to_bank',
-        description: 'Withdraw funds from wallet to a bank account. USDC is converted to USD.',
+        description: 'Withdraw treasury funds to an external bank account via ACH payment.',
         inputSchema: {
             type: 'object',
             properties: {
-                wallet_id: { type: 'string', description: 'Wallet to withdraw from' },
-                amount: { type: 'string', description: 'Amount to withdraw in USD' },
-                destination_id: { type: 'string', description: 'Bank account ID to withdraw to' },
+                amount: { type: 'number', description: 'Legacy amount in major units (USD)' },
+                amount_minor: { type: 'number', description: 'Amount in minor units (e.g. cents)' },
+                financial_account_token: { type: 'string' },
+                external_bank_account_token: { type: 'string' },
+                method: { type: 'string', enum: ['ACH_NEXT_DAY', 'ACH_SAME_DAY'] },
+                sec_code: { type: 'string', enum: ['CCD', 'PPD', 'WEB'] },
             },
-            required: ['wallet_id', 'amount', 'destination_id'],
+            required: [],
         },
     },
     {
         name: 'sardis_withdraw',
-        description: 'Withdraw funds from wallet to a bank account (alias for sardis_withdraw_to_bank).',
+        description: 'Alias for sardis_withdraw_to_bank.',
         inputSchema: {
             type: 'object',
             properties: {
-                amount: { type: 'number', description: 'Amount to withdraw' },
-                destination: { type: 'string', description: 'Destination type (bank_account, wire)' },
-                account_id: { type: 'string', description: 'Bank account ID to withdraw to' },
-                wallet_id: { type: 'string', description: 'Wallet to withdraw from' },
+                amount: { type: 'number' },
+                amount_minor: { type: 'number' },
+                account_id: { type: 'string' },
+                financial_account_token: { type: 'string' },
+                external_bank_account_token: { type: 'string' },
             },
-            required: ['amount'],
+            required: [],
         },
     },
     {
         name: 'sardis_get_funding_status',
-        description: 'Check the status of a funding transfer.',
+        description: 'Get status of a treasury payment token.',
         inputSchema: {
             type: 'object',
             properties: {
-                transfer_id: { type: 'string', description: 'Funding transfer ID' },
+                payment_token: { type: 'string' },
+                transfer_id: { type: 'string' },
+                funding_id: { type: 'string' },
             },
-            required: ['transfer_id'],
+            required: [],
         },
     },
     {
         name: 'sardis_get_withdrawal_status',
-        description: 'Check the status of a withdrawal to bank.',
+        description: 'Get withdrawal status by treasury payment token.',
         inputSchema: {
             type: 'object',
             properties: {
-                transfer_id: { type: 'string', description: 'Withdrawal transfer ID' },
+                payment_token: { type: 'string' },
+                transfer_id: { type: 'string' },
             },
-            required: ['transfer_id'],
+            required: [],
+        },
+    },
+    {
+        name: 'sardis_get_treasury_balances',
+        description: 'Get latest treasury balances across linked financial accounts.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            required: [],
         },
     },
     {
         name: 'sardis_list_funding_transactions',
-        description: 'List all funding and withdrawal transactions.',
+        description: 'List treasury funding and withdrawal activity (simulated summary in sandbox mode).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                type: { type: 'string', enum: ['deposit', 'withdrawal', 'all'] },
+                limit: { type: 'number' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'sardis_get_multi_balance',
+        description: 'Get all balances (crypto + fiat + card) for an agent in one unified call.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                wallet_id: { type: 'string', description: 'Wallet ID to get balances for' },
+                agent_id: { type: 'string', description: 'Agent ID to get balances for' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'sardis_offramp_usdc_to_fiat',
+        description: 'Convert USDC to fiat via best available ramp provider.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                amount: { type: 'number', description: 'Amount in major units (USD)' },
+                amount_minor: { type: 'number', description: 'Amount in minor units (e.g. cents)' },
+                source_chain: { type: 'string', description: 'Source blockchain (e.g. base, polygon, ethereum)' },
+                destination_currency: { type: 'string', description: 'Target fiat currency (e.g. USD, EUR)' },
+                external_bank_account_token: { type: 'string', description: 'Destination bank account token' },
+                wallet_id: { type: 'string', description: 'Source wallet ID' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'sardis_onramp_fiat_to_usdc',
+        description: 'Convert fiat to USDC via best available ramp provider.',
         inputSchema: {
             type: 'object',
             properties: {
-                type: { type: 'string', enum: ['deposit', 'withdrawal', 'all'], description: 'Filter by transaction type' },
-                limit: { type: 'number', description: 'Maximum number of results' },
+                amount: { type: 'number', description: 'Amount in major units (USD)' },
+                amount_minor: { type: 'number', description: 'Amount in minor units (e.g. cents)' },
+                source_currency: { type: 'string', description: 'Source fiat currency (e.g. USD, EUR)' },
+                destination_chain: { type: 'string', description: 'Target blockchain (e.g. base, polygon, ethereum)' },
+                external_bank_account_token: { type: 'string', description: 'Source bank account token' },
+                wallet_id: { type: 'string', description: 'Destination wallet ID' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'sardis_get_ramp_quote',
+        description: 'Get price quotes from available ramp providers for fiat<>crypto conversion.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                direction: { type: 'string', enum: ['onramp', 'offramp'], description: 'Conversion direction' },
+                amount: { type: 'number', description: 'Amount in major units' },
+                amount_minor: { type: 'number', description: 'Amount in minor units' },
+                source_currency: { type: 'string', description: 'Source currency (USD, EUR, USDC)' },
+                destination_currency: { type: 'string', description: 'Destination currency (USD, EUR, USDC)' },
+                chain: { type: 'string', description: 'Blockchain for crypto side (e.g. base, polygon)' },
             },
             required: [],
         },
     },
 ];
-// Tool handlers
 export const fiatToolHandlers = {
+    sardis_sync_treasury_account_holder: async (args) => {
+        const parsed = AccountHolderSyncSchema.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: 'text', text: `Invalid request: ${parsed.error.message}` }], isError: true };
+        const config = getConfig();
+        if (!config.apiKey || config.mode === 'simulated') {
+            return serialize([
+                {
+                    organization_id: 'org_simulated',
+                    financial_account_token: 'fa_simulated',
+                    account_role: 'ISSUING',
+                    currency: 'USD',
+                    status: 'OPEN',
+                    is_program_level: false,
+                },
+            ]);
+        }
+        try {
+            return serialize(await apiRequest('POST', '/api/v2/treasury/account-holders/sync', parsed.data));
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Failed to sync account holder: ${error instanceof Error ? error.message : 'Unknown error'}` }], isError: true };
+        }
+    },
+    sardis_list_financial_accounts: async (args) => {
+        const parsed = ListFinancialAccountsSchema.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: 'text', text: `Invalid request: ${parsed.error.message}` }], isError: true };
+        const config = getConfig();
+        if (!config.apiKey || config.mode === 'simulated') {
+            return serialize([
+                {
+                    organization_id: 'org_simulated',
+                    financial_account_token: 'fa_simulated',
+                    account_role: 'ISSUING',
+                    currency: 'USD',
+                    status: 'OPEN',
+                    is_program_level: false,
+                },
+            ]);
+        }
+        try {
+            const search = new URLSearchParams();
+            if (parsed.data.account_token)
+                search.set('account_token', parsed.data.account_token);
+            search.set('refresh', String(parsed.data.refresh ?? false));
+            return serialize(await apiRequest('GET', `/api/v2/treasury/financial-accounts?${search.toString()}`));
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Failed to list financial accounts: ${error instanceof Error ? error.message : 'Unknown error'}` }], isError: true };
+        }
+    },
+    sardis_link_external_bank_account: async (args) => {
+        const parsed = LinkExternalBankSchema.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: 'text', text: `Invalid request: ${parsed.error.message}` }], isError: true };
+        const config = getConfig();
+        if (!config.apiKey || config.mode === 'simulated') {
+            return serialize({
+                organization_id: 'org_simulated',
+                external_bank_account_token: 'eba_simulated',
+                financial_account_token: parsed.data.financial_account_token,
+                owner: parsed.data.owner,
+                owner_type: parsed.data.owner_type ?? 'BUSINESS',
+                verification_method: parsed.data.verification_method ?? 'MICRO_DEPOSIT',
+                verification_state: 'PENDING',
+                state: 'ENABLED',
+                account_type: parsed.data.account_type ?? 'CHECKING',
+                currency: parsed.data.currency ?? 'USD',
+                country: parsed.data.country ?? 'USA',
+            });
+        }
+        try {
+            return serialize(await apiRequest('POST', '/api/v2/treasury/external-bank-accounts', parsed.data));
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Failed to link bank account: ${error instanceof Error ? error.message : 'Unknown error'}` }], isError: true };
+        }
+    },
+    sardis_verify_micro_deposits: async (args) => {
+        const parsed = VerifyMicroDepositsSchema.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: 'text', text: `Invalid request: ${parsed.error.message}` }], isError: true };
+        const config = getConfig();
+        if (!config.apiKey || config.mode === 'simulated') {
+            return serialize({
+                external_bank_account_token: parsed.data.token,
+                verification_state: 'ENABLED',
+                state: 'ENABLED',
+            });
+        }
+        try {
+            return serialize(await apiRequest('POST', `/api/v2/treasury/external-bank-accounts/${parsed.data.token}/verify-micro-deposits`, { micro_deposits: parsed.data.micro_deposits }));
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Failed to verify micro deposits: ${error instanceof Error ? error.message : 'Unknown error'}` }], isError: true };
+        }
+    },
     sardis_fund_wallet: async (args) => {
         const parsed = FundWalletSchema.safeParse(args);
-        if (!parsed.success) {
-            return {
-                content: [{ type: 'text', text: `Invalid request: ${parsed.error.message}` }],
-                isError: true,
-            };
+        if (!parsed.success)
+            return { content: [{ type: 'text', text: `Invalid request: ${parsed.error.message}` }], isError: true };
+        const amountMinor = parsed.data.amount_minor ?? toMinorUnits(parsed.data.amount);
+        if (amountMinor <= 0) {
+            return { content: [{ type: 'text', text: 'Invalid request: amount or amount_minor is required' }], isError: true };
         }
         const config = getConfig();
-        const walletId = parsed.data.wallet_id || config.walletId || 'wallet_default';
-        const amount = typeof parsed.data.amount === 'number'
-            ? parsed.data.amount.toString()
-            : parsed.data.amount;
         if (!config.apiKey || config.mode === 'simulated') {
-            const transferId = `fund_${Date.now().toString(36)}`;
-            const source = parsed.data.source || 'ach';
-            const eta = source === 'wire' ? '1 hour' : source === 'card' ? '5 minutes' : '2-3 business days';
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            funding_id: transferId,
-                            wallet_id: walletId,
-                            amount: amount,
-                            source_type: source,
-                            currency: parsed.data.currency || 'USD',
-                            status: 'processing',
-                            estimated_arrival: eta,
-                            created_at: new Date().toISOString(),
-                            message: `Funding of $${amount} initiated via ${source.toUpperCase()}`,
-                        }, null, 2),
-                    }],
-            };
+            const simulated = buildSimulatedPayment('fund', 'DEBIT', amountMinor || 10000);
+            return serialize({
+                ...simulated,
+                wallet_id: parsed.data.wallet_id || config.walletId || 'wallet_default',
+                source_type: parsed.data.source || 'ach',
+                message: `Funding initiated for ${((simulated.pending_amount || 0) / 100).toFixed(2)} USD`,
+            });
         }
+        const validationError = validateLiveTreasuryArgs(parsed.data.financial_account_token, parsed.data.external_bank_account_token, amountMinor);
+        if (validationError)
+            return { content: [{ type: 'text', text: `Invalid request: ${validationError}` }], isError: true };
         try {
-            const result = await apiRequest('POST', '/api/v2/fiat/fund', parsed.data);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-            };
+            const result = await apiRequest('POST', '/api/v2/treasury/fund', {
+                financial_account_token: parsed.data.financial_account_token,
+                external_bank_account_token: parsed.data.external_bank_account_token,
+                amount_minor: amountMinor,
+                method: parsed.data.method ?? 'ACH_NEXT_DAY',
+                sec_code: parsed.data.sec_code ?? 'CCD',
+                memo: parsed.data.memo,
+                idempotency_key: parsed.data.idempotency_key,
+                user_defined_id: parsed.data.user_defined_id,
+            });
+            return serialize({ ...result, funding_id: result.payment_token });
         }
         catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to fund wallet: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
+            return { content: [{ type: 'text', text: `Failed to fund wallet: ${error instanceof Error ? error.message : 'Unknown error'}` }], isError: true };
         }
     },
     sardis_withdraw_to_bank: async (args) => {
         const parsed = WithdrawSchema.safeParse(args);
-        if (!parsed.success) {
-            return {
-                content: [{ type: 'text', text: `Invalid request: ${parsed.error.message}` }],
-                isError: true,
-            };
+        if (!parsed.success)
+            return { content: [{ type: 'text', text: `Invalid request: ${parsed.error.message}` }], isError: true };
+        const amountMinor = parsed.data.amount_minor ?? toMinorUnits(parsed.data.amount);
+        if (amountMinor <= 0) {
+            return { content: [{ type: 'text', text: 'Invalid request: amount or amount_minor is required' }], isError: true };
         }
+        const externalBankAccountToken = parsed.data.external_bank_account_token ?? parsed.data.destination_id ?? parsed.data.account_id;
         const config = getConfig();
         if (!config.apiKey || config.mode === 'simulated') {
-            const transferId = `wd_${Date.now().toString(36)}`;
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            id: transferId,
-                            wallet_id: parsed.data.wallet_id,
-                            amount: parsed.data.amount,
-                            destination_bank: '****1234',
-                            status: 'processing',
-                            estimated_arrival: '1-2 business days',
-                            created_at: new Date().toISOString(),
-                            message: `Withdrawal of $${parsed.data.amount} initiated`,
-                        }, null, 2),
-                    }],
-            };
+            const simulated = buildSimulatedPayment('wd', 'CREDIT', amountMinor || 10000);
+            return serialize({
+                ...simulated,
+                wallet_id: parsed.data.wallet_id || config.walletId || 'wallet_default',
+                destination_bank: externalBankAccountToken || 'eba_simulated',
+                estimated_arrival: '1-2 business days',
+            });
         }
+        const validationError = validateLiveTreasuryArgs(parsed.data.financial_account_token, externalBankAccountToken, amountMinor);
+        if (validationError)
+            return { content: [{ type: 'text', text: `Invalid request: ${validationError}` }], isError: true };
         try {
-            const result = await apiRequest('POST', '/api/v2/fiat/withdraw', parsed.data);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-            };
+            const result = await apiRequest('POST', '/api/v2/treasury/withdraw', {
+                financial_account_token: parsed.data.financial_account_token,
+                external_bank_account_token: externalBankAccountToken,
+                amount_minor: amountMinor,
+                method: parsed.data.method ?? 'ACH_NEXT_DAY',
+                sec_code: parsed.data.sec_code ?? 'CCD',
+                memo: parsed.data.memo,
+                idempotency_key: parsed.data.idempotency_key,
+                user_defined_id: parsed.data.user_defined_id,
+            });
+            return serialize({ ...result, withdrawal_id: result.payment_token });
         }
         catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to withdraw: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
+            return { content: [{ type: 'text', text: `Failed to withdraw: ${error instanceof Error ? error.message : 'Unknown error'}` }], isError: true };
         }
     },
     sardis_get_funding_status: async (args) => {
         const parsed = StatusSchema.safeParse(args);
-        const transferId = parsed.success && (parsed.data.transfer_id || parsed.data.funding_id);
-        if (!transferId) {
-            return {
-                content: [{ type: 'text', text: 'Invalid request: transfer_id or funding_id is required' }],
-                isError: true,
-            };
-        }
+        if (!parsed.success)
+            return { content: [{ type: 'text', text: `Invalid request: ${parsed.error.message}` }], isError: true };
+        const token = parsed.data.payment_token || parsed.data.transfer_id || parsed.data.funding_id;
+        if (!token)
+            return { content: [{ type: 'text', text: 'Invalid request: payment_token or transfer_id is required' }], isError: true };
         const config = getConfig();
         if (!config.apiKey || config.mode === 'simulated') {
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            funding_id: transferId,
-                            id: transferId,
-                            type: 'funding',
-                            status: 'completed',
-                            amount: '100.00',
-                            completed_at: new Date().toISOString(),
-                        }, null, 2),
-                    }],
-            };
+            return serialize({ payment_token: token, funding_id: token, status: 'SETTLED', type: 'funding' });
         }
         try {
-            const result = await apiRequest('GET', `/api/v2/fiat/status/${transferId}`);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-            };
+            const result = await apiRequest('GET', `/api/v2/treasury/payments/${token}`);
+            return serialize({ ...result, funding_id: result.payment_token });
         }
         catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to get status: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
+            return { content: [{ type: 'text', text: `Failed to get status: ${error instanceof Error ? error.message : 'Unknown error'}` }], isError: true };
         }
     },
     sardis_get_withdrawal_status: async (args) => {
         const parsed = StatusSchema.safeParse(args);
-        if (!parsed.success) {
-            return {
-                content: [{ type: 'text', text: `Invalid request: ${parsed.error.message}` }],
-                isError: true,
-            };
-        }
+        if (!parsed.success)
+            return { content: [{ type: 'text', text: `Invalid request: ${parsed.error.message}` }], isError: true };
+        const token = parsed.data.payment_token || parsed.data.transfer_id;
+        if (!token)
+            return { content: [{ type: 'text', text: 'Invalid request: payment_token or transfer_id is required' }], isError: true };
         const config = getConfig();
         if (!config.apiKey || config.mode === 'simulated') {
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            id: parsed.data.transfer_id,
-                            type: 'withdrawal',
-                            status: 'processing',
-                            amount: '100.00',
-                            estimated_arrival: '1-2 business days',
-                        }, null, 2),
-                    }],
-            };
+            return serialize({ payment_token: token, withdrawal_id: token, status: 'PROCESSING', type: 'withdrawal' });
         }
         try {
-            const result = await apiRequest('GET', `/api/v2/fiat/status/${parsed.data.transfer_id}`);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-            };
+            const result = await apiRequest('GET', `/api/v2/treasury/payments/${token}`);
+            return serialize({ ...result, withdrawal_id: result.payment_token });
         }
         catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to get status: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
+            return { content: [{ type: 'text', text: `Failed to get status: ${error instanceof Error ? error.message : 'Unknown error'}` }], isError: true };
         }
     },
-    sardis_withdraw: async (args) => {
+    sardis_get_treasury_balances: async () => {
         const config = getConfig();
-        const amount = typeof args === 'object' && args !== null && 'amount' in args
-            ? args.amount
-            : 0;
-        const accountId = typeof args === 'object' && args !== null && 'account_id' in args
-            ? args.account_id
-            : 'acct_default';
-        const walletId = typeof args === 'object' && args !== null && 'wallet_id' in args
-            ? args.wallet_id || config.walletId
-            : config.walletId;
-        if (amount === 0) {
-            return {
-                content: [{ type: 'text', text: 'Invalid request: amount is required' }],
-                isError: true,
-            };
-        }
         if (!config.apiKey || config.mode === 'simulated') {
-            const transferId = `wd_${Date.now().toString(36)}`;
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify({
-                            withdrawal_id: transferId,
-                            wallet_id: walletId,
-                            amount: amount.toString(),
-                            destination_bank: '****1234',
-                            account_id: accountId,
-                            status: 'processing',
-                            estimated_arrival: '1-2 business days',
-                            created_at: new Date().toISOString(),
-                            message: `Withdrawal of $${amount} initiated`,
-                        }, null, 2),
-                    }],
-            };
+            return serialize([
+                {
+                    organization_id: 'org_simulated',
+                    financial_account_token: 'fa_simulated',
+                    currency: 'USD',
+                    available_amount_minor: 250000,
+                    pending_amount_minor: 10000,
+                    total_amount_minor: 260000,
+                },
+            ]);
         }
         try {
-            const result = await apiRequest('POST', '/api/v2/fiat/withdraw', {
-                wallet_id: walletId,
-                amount: amount.toString(),
-                destination_id: accountId,
-            });
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-            };
+            return serialize(await apiRequest('GET', '/api/v2/treasury/balances'));
         }
         catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to withdraw: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
+            return { content: [{ type: 'text', text: `Failed to fetch balances: ${error instanceof Error ? error.message : 'Unknown error'}` }], isError: true };
+        }
+    },
+    sardis_withdraw: async (args) => {
+        const withdrawToBankHandler = fiatToolHandlers['sardis_withdraw_to_bank'];
+        if (!withdrawToBankHandler) {
+            return { content: [{ type: 'text', text: 'withdraw handler is unavailable' }], isError: true };
         }
+        return withdrawToBankHandler(args);
     },
     sardis_list_funding_transactions: async (args) => {
+        const parsed = FundingListSchema.safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: 'text', text: `Invalid request: ${parsed.error.message}` }], isError: true };
         const config = getConfig();
-        const typeFilter = typeof args === 'object' && args !== null && 'type' in args
-            ? args.type
-            : 'all';
+        const typeFilter = parsed.data.type ?? 'all';
+        const limit = parsed.data.limit ?? 20;
         if (!config.apiKey || config.mode === 'simulated') {
             const mockTransactions = [
-                {
-                    id: 'fund_001',
-                    type: 'deposit',
-                    amount: '1000.00',
-                    status: 'completed',
-                    source: 'bank_account',
-                    created_at: new Date(Date.now() - 86400000).toISOString(),
+                { id: 'fund_001', type: 'deposit', amount_minor: 100000, status: 'SETTLED' },
+                { id: 'wd_001', type: 'withdrawal', amount_minor: 25000, status: 'PENDING' },
+            ];
+            const filtered = typeFilter === 'all' ? mockTransactions : mockTransactions.filter((tx) => tx.type === typeFilter);
+            return serialize(filtered.slice(0, limit));
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        message: 'List endpoint is not exposed yet. Use sardis_get_funding_status/sardis_get_withdrawal_status per payment token.',
+                        supported_paths: ['/api/v2/treasury/payments/{payment_token}', '/api/v2/treasury/balances'],
+                    }, null, 2),
+                }],
+        };
+    },
+    sardis_get_multi_balance: async (args) => {
+        const parsed = z.object({
+            wallet_id: z.string().optional(),
+            agent_id: z.string().optional(),
+        }).safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: 'text', text: `Invalid request: ${parsed.error.message}` }], isError: true };
+        const config = getConfig();
+        if (!config.apiKey || config.mode === 'simulated') {
+            return serialize({
+                wallet_id: parsed.data.wallet_id || config.walletId || 'wallet_default',
+                agent_id: parsed.data.agent_id || 'agent_default',
+                crypto: {
+                    base: { USDC: { available_minor: 500000, pending_minor: 0, total_minor: 500000 } },
+                    polygon: { USDC: { available_minor: 250000, pending_minor: 0, total_minor: 250000 } },
                 },
-                {
-                    id: 'wd_001',
-                    type: 'withdrawal',
-                    amount: '200.00',
-                    status: 'processing',
-                    destination: 'bank_account',
-                    created_at: new Date(Date.now() - 3600000).toISOString(),
+                fiat: {
+                    USD: { available_minor: 250000, pending_minor: 10000, total_minor: 260000 },
                 },
-            ];
-            const filtered = typeFilter === 'all'
-                ? mockTransactions
-                : mockTransactions.filter(t => t.type === typeFilter);
-            return {
-                content: [{
-                        type: 'text',
-                        text: JSON.stringify(filtered, null, 2),
-                    }],
-            };
+                cards: {
+                    total_limit_minor: 1000000,
+                    total_spent_minor: 125000,
+                    available_minor: 875000,
+                },
+                total_value_usd_minor: 1135000,
+            });
+        }
+        try {
+            const search = new URLSearchParams();
+            if (parsed.data.wallet_id)
+                search.set('wallet_id', parsed.data.wallet_id);
+            if (parsed.data.agent_id)
+                search.set('agent_id', parsed.data.agent_id);
+            return serialize(await apiRequest('GET', `/api/v2/treasury/multi-balance?${search.toString()}`));
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Failed to fetch multi-balance: ${error instanceof Error ? error.message : 'Unknown error'}` }], isError: true };
+        }
+    },
+    sardis_offramp_usdc_to_fiat: async (args) => {
+        const parsed = z.object({
+            amount: z.union([z.string(), z.number()]).optional(),
+            amount_minor: z.number().int().positive().optional(),
+            source_chain: z.string().optional(),
+            destination_currency: z.string().optional(),
+            external_bank_account_token: z.string().optional(),
+            wallet_id: z.string().optional(),
+        }).safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: 'text', text: `Invalid request: ${parsed.error.message}` }], isError: true };
+        const amountMinor = parsed.data.amount_minor ?? toMinorUnits(parsed.data.amount);
+        if (amountMinor <= 0) {
+            return { content: [{ type: 'text', text: 'Invalid request: amount or amount_minor is required' }], isError: true };
+        }
+        const config = getConfig();
+        if (!config.apiKey || config.mode === 'simulated') {
+            return serialize({
+                offramp_id: `offramp_${Date.now().toString(36)}`,
+                status: 'PENDING',
+                source_chain: parsed.data.source_chain || 'base',
+                source_token: 'USDC',
+                source_amount_minor: amountMinor,
+                destination_currency: parsed.data.destination_currency || 'USD',
+                destination_amount_minor: Math.round(amountMinor * 0.998),
+                fee_minor: Math.round(amountMinor * 0.002),
+                exchange_rate: 1.0,
+                estimated_settlement: '1-2 business days',
+                provider: 'bridge-xyz',
+            });
+        }
+        try {
+            return serialize(await apiRequest('POST', '/api/v2/treasury/offramp', {
+                amount_minor: amountMinor,
+                source_chain: parsed.data.source_chain || 'base',
+                destination_currency: parsed.data.destination_currency || 'USD',
+                external_bank_account_token: parsed.data.external_bank_account_token,
+                wallet_id: parsed.data.wallet_id,
+            }));
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Failed to execute offramp: ${error instanceof Error ? error.message : 'Unknown error'}` }], isError: true };
+        }
+    },
+    sardis_onramp_fiat_to_usdc: async (args) => {
+        const parsed = z.object({
+            amount: z.union([z.string(), z.number()]).optional(),
+            amount_minor: z.number().int().positive().optional(),
+            source_currency: z.string().optional(),
+            destination_chain: z.string().optional(),
+            external_bank_account_token: z.string().optional(),
+            wallet_id: z.string().optional(),
+        }).safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: 'text', text: `Invalid request: ${parsed.error.message}` }], isError: true };
+        const amountMinor = parsed.data.amount_minor ?? toMinorUnits(parsed.data.amount);
+        if (amountMinor <= 0) {
+            return { content: [{ type: 'text', text: 'Invalid request: amount or amount_minor is required' }], isError: true };
+        }
+        const config = getConfig();
+        if (!config.apiKey || config.mode === 'simulated') {
+            return serialize({
+                onramp_id: `onramp_${Date.now().toString(36)}`,
+                status: 'PENDING',
+                source_currency: parsed.data.source_currency || 'USD',
+                source_amount_minor: amountMinor,
+                destination_chain: parsed.data.destination_chain || 'base',
+                destination_token: 'USDC',
+                destination_amount_minor: Math.round(amountMinor * 0.997),
+                fee_minor: Math.round(amountMinor * 0.003),
+                exchange_rate: 1.0,
+                estimated_settlement: '10-30 minutes',
+                provider: 'bridge-xyz',
+            });
+        }
+        try {
+            return serialize(await apiRequest('POST', '/api/v2/treasury/onramp', {
+                amount_minor: amountMinor,
+                source_currency: parsed.data.source_currency || 'USD',
+                destination_chain: parsed.data.destination_chain || 'base',
+                external_bank_account_token: parsed.data.external_bank_account_token,
+                wallet_id: parsed.data.wallet_id,
+            }));
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Failed to execute onramp: ${error instanceof Error ? error.message : 'Unknown error'}` }], isError: true };
+        }
+    },
+    sardis_get_ramp_quote: async (args) => {
+        const parsed = z.object({
+            direction: z.enum(['onramp', 'offramp']).optional(),
+            amount: z.union([z.string(), z.number()]).optional(),
+            amount_minor: z.number().int().positive().optional(),
+            source_currency: z.string().optional(),
+            destination_currency: z.string().optional(),
+            chain: z.string().optional(),
+        }).safeParse(args);
+        if (!parsed.success)
+            return { content: [{ type: 'text', text: `Invalid request: ${parsed.error.message}` }], isError: true };
+        const amountMinor = parsed.data.amount_minor ?? toMinorUnits(parsed.data.amount);
+        if (amountMinor <= 0) {
+            return { content: [{ type: 'text', text: 'Invalid request: amount or amount_minor is required' }], isError: true };
+        }
+        const config = getConfig();
+        if (!config.apiKey || config.mode === 'simulated') {
+            const direction = parsed.data.direction || 'offramp';
+            const fee = direction === 'offramp' ? 0.002 : 0.003;
+            return serialize({
+                quotes: [
+                    {
+                        provider: 'bridge-xyz',
+                        direction,
+                        source_currency: parsed.data.source_currency || (direction === 'onramp' ? 'USD' : 'USDC'),
+                        destination_currency: parsed.data.destination_currency || (direction === 'onramp' ? 'USDC' : 'USD'),
+                        source_amount_minor: amountMinor,
+                        destination_amount_minor: Math.round(amountMinor * (1 - fee)),
+                        fee_minor: Math.round(amountMinor * fee),
+                        exchange_rate: 1.0,
+                        estimated_time: direction === 'onramp' ? '10-30 minutes' : '1-2 business days',
+                    },
+                    {
+                        provider: 'circle',
+                        direction,
+                        source_currency: parsed.data.source_currency || (direction === 'onramp' ? 'USD' : 'USDC'),
+                        destination_currency: parsed.data.destination_currency || (direction === 'onramp' ? 'USDC' : 'USD'),
+                        source_amount_minor: amountMinor,
+                        destination_amount_minor: Math.round(amountMinor * (1 - fee - 0.001)),
+                        fee_minor: Math.round(amountMinor * (fee + 0.001)),
+                        exchange_rate: 1.0,
+                        estimated_time: direction === 'onramp' ? '5-15 minutes' : '1-3 business days',
+                    },
+                ],
+                best_quote: 'bridge-xyz',
+            });
         }
         try {
-            const params = new URLSearchParams();
-            if (typeFilter && typeFilter !== 'all')
-                params.append('type', typeFilter);
-            const result = await apiRequest('GET', `/api/v2/fiat/transactions?${params}`);
-            return {
-                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-            };
+            const search = new URLSearchParams();
+            if (parsed.data.direction)
+                search.set('direction', parsed.data.direction);
+            search.set('amount_minor', String(amountMinor));
+            if (parsed.data.source_currency)
+                search.set('source_currency', parsed.data.source_currency);
+            if (parsed.data.destination_currency)
+                search.set('destination_currency', parsed.data.destination_currency);
+            if (parsed.data.chain)
+                search.set('chain', parsed.data.chain);
+            return serialize(await apiRequest('GET', `/api/v2/treasury/ramp-quote?${search.toString()}`));
         }
         catch (error) {
-            return {
-                content: [{
-                        type: 'text',
-                        text: `Failed to list transactions: ${error instanceof Error ? error.message : 'Unknown error'}`,
-                    }],
-                isError: true,
-            };
+            return { content: [{ type: 'text', text: `Failed to get ramp quote: ${error instanceof Error ? error.message : 'Unknown error'}` }], isError: true };
         }
     },
 };