finoptima 1.0.0

package/index.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+/**
+ * EcoChain MCP Server (DEC-2026-043)
+ *
+ * Model Context Protocol server for AI agent access to EcoChain.
+ * Provides 22 tools: 1 login + 21 platform tools.
+ *
+ * Authentication: EcoAuth login flow (no hardcoded credentials)
+ *   1. AI asks user for their phone number
+ *   2. AI calls `login` tool → push notification sent to EcoAuth app
+ *   3. User approves on their phone
+ *   4. All subsequent tools use the JWT token
+ *
+ * Environment variables:
+ *   ECOCHAIN_API_URL — Optional. API base URL (default: https://api.toutcreer.com)
+ */
+
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} = require('@modelcontextprotocol/sdk/types.js');
+
+const { allTools } = require('./tools/index.js');
+const apiClient = require('./lib/api-client.js');
+
+const POLL_INTERVAL_MS = 2000;
+const POLL_TIMEOUT_MS = 120000;
+
+let authenticated = false;
+
+/**
+ * EcoAuth login flow
+ */
+async function loginWithEcoAuth(phoneNumber) {
+  const loginResponse = await apiClient.post('/auth/login', { phoneNumber });
+
+  if (!loginResponse.twoFactorRequired && loginResponse.token) {
+    return loginResponse;
+  }
+
+  if (!loginResponse.twoFactorRequired || !loginResponse.challenge?.token) {
+    throw new Error('Unexpected login response: ' + JSON.stringify(loginResponse));
+  }
+
+  const challengeToken = loginResponse.challenge.token;
+  const deviceName = loginResponse.challenge.device_name || 'your device';
+  const userName = loginResponse.user?.displayName || phoneNumber;
+
+  // Return info for the AI to tell the user
+  const waitMessage = `Challenge sent to ${deviceName}. ${userName}, please approve on your EcoAuth app.`;
+  console.error(`[EcoChain MCP] ${waitMessage}`);
+
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < POLL_TIMEOUT_MS) {
+    await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS));
+
+    try {
+      const status = await apiClient.get(`/authenticator/challenge/${challengeToken}/status`);
+
+      if (status.status === 'approved') {
+        const completeResponse = await apiClient.post('/auth/login/complete', { challengeToken });
+        if (!completeResponse.token) {
+          throw new Error('Login complete but no token received');
+        }
+        return completeResponse;
+      }
+
+      if (status.status === 'denied') {
+        throw new Error('Login denied by user on EcoAuth');
+      }
+
+      if (status.status === 'expired') {
+        throw new Error('Challenge expired. Please try again.');
+      }
+    } catch (err) {
+      if (err.message?.includes('denied') || err.message?.includes('expired')) throw err;
+      console.error(`[EcoChain MCP] Poll error (retrying): ${err.message || err.error || err}`);
+    }
+  }
+
+  throw new Error(`Login timeout: no approval received within ${POLL_TIMEOUT_MS / 1000}s`);
+}
+
+// Login tool — the AI calls this after asking the user for their phone number
+const loginTool = {
+  name: 'login',
+  description: 'Login to EcoChain via EcoAuth. Ask the user for their phone number first (e.g. +33612345678), then call this tool. The user will receive a push notification on their EcoAuth app and must approve it. This must be called before any other tool.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      phone_number: { type: 'string', description: 'User phone number in international format (e.g. +33612345678)' }
+    },
+    required: ['phone_number']
+  },
+  handler: async ({ phone_number }) => {
+    if (authenticated) {
+      return JSON.stringify({ status: 'already_authenticated', user_id: process.env.ECOCHAIN_USER_ID });
+    }
+
+    const result = await loginWithEcoAuth(phone_number);
+    apiClient.setToken(result.token);
+    process.env.ECOCHAIN_USER_ID = result.user.uid;
+    authenticated = true;
+
+    return JSON.stringify({
+      status: 'authenticated',
+      user: result.user.displayName,
+      user_id: result.user.uid,
+      expires_in: result.expiresIn
+    });
+  }
+};
+
+// All tools: login first, then platform tools
+const allToolsWithLogin = [loginTool, ...allTools];
+
+// Create MCP server
+const server = new Server(
+  {
+    name: 'ecochain',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// List tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: allToolsWithLogin.map(tool => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+    })),
+  };
+});
+
+// Execute tools
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  const tool = allToolsWithLogin.find(t => t.name === name);
+  if (!tool) {
+    return {
+      content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+      isError: true,
+    };
+  }
+
+  // Block all tools except login if not authenticated
+  if (!authenticated && name !== 'login') {
+    return {
+      content: [{ type: 'text', text: 'Not authenticated. Please ask the user for their phone number and call the `login` tool first.' }],
+      isError: true,
+    };
+  }
+
+  try {
+    const result = await tool.handler(args || {});
+    return {
+      content: [{ type: 'text', text: result }],
+    };
+  } catch (err) {
+    const errorMessage = err.error || err.message || String(err);
+    return {
+      content: [{ type: 'text', text: `Error: ${errorMessage}` }],
+      isError: true,
+    };
+  }
+});
+
+// Start server — no auth at startup, AI will call login tool
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('[EcoChain MCP] Server started. Call the `login` tool to authenticate.');
+}
+
+main().catch((err) => {
+  console.error('[EcoChain MCP] Fatal error:', err);
+  process.exit(1);
+});

package/lib/api-client.js

@@ -0,0 +1,102 @@
+/**
+ * EcoChain API Client (DEC-2026-043)
+ *
+ * Makes authenticated HTTPS requests to the backend API.
+ * Auth: JWT Bearer token obtained via EcoAuth login flow.
+ */
+
+const https = require('https');
+const http = require('http');
+
+class ApiClient {
+  constructor() {
+    this.apiUrl = process.env.ECOCHAIN_API_URL || 'https://api.toutcreer.com';
+    this.jwtToken = null; // Set after EcoAuth login
+
+    const parsed = new URL(this.apiUrl);
+    this.hostname = parsed.hostname;
+    this.port = parsed.port || (parsed.protocol === 'https:' ? 443 : 80);
+    this.protocol = parsed.protocol;
+    this.basePath = parsed.pathname.replace(/\/$/, '');
+  }
+
+  /**
+   * Set JWT token after successful EcoAuth login
+   */
+  setToken(token) {
+    this.jwtToken = token;
+  }
+
+  /**
+   * Make an HTTP request to the backend API
+   */
+  async request(method, path, body = null) {
+    const fullPath = `${this.basePath}/v3${path}`;
+
+    const headers = {
+      'Content-Type': 'application/json',
+    };
+
+    if (this.jwtToken) {
+      headers['Authorization'] = `Bearer ${this.jwtToken}`;
+    }
+
+    const bodyStr = body ? JSON.stringify(body) : null;
+    if (bodyStr) {
+      headers['Content-Length'] = Buffer.byteLength(bodyStr);
+    }
+
+    const options = {
+      hostname: this.hostname,
+      port: this.port,
+      path: fullPath,
+      method: method.toUpperCase(),
+      headers
+    };
+
+    const transport = this.protocol === 'https:' ? https : http;
+
+    return new Promise((resolve, reject) => {
+      const req = transport.request(options, (res) => {
+        let data = '';
+        res.on('data', chunk => { data += chunk; });
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(data);
+            if (res.statusCode >= 400) {
+              reject({
+                status: res.statusCode,
+                error: parsed.error || `HTTP ${res.statusCode}`,
+                data: parsed
+              });
+            } else {
+              resolve(parsed);
+            }
+          } catch {
+            if (res.statusCode >= 400) {
+              reject({ status: res.statusCode, error: data });
+            } else {
+              resolve(data);
+            }
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.setTimeout(30000, () => {
+        req.destroy();
+        reject(new Error('Request timeout'));
+      });
+
+      if (bodyStr) req.write(bodyStr);
+      req.end();
+    });
+  }
+
+  // Convenience methods
+  async get(path) { return this.request('GET', path); }
+  async post(path, body) { return this.request('POST', path, body); }
+  async delete(path, body) { return this.request('DELETE', path, body); }
+}
+
+module.exports = new ApiClient();

package/lib/logger.js

@@ -0,0 +1,66 @@
+/**
+ * Activity Logger for MCP Server (DEC-2026-043)
+ *
+ * Logs every MCP tool invocation to the backend activity log.
+ * Non-blocking: failures don't affect the tool response.
+ */
+
+const apiClient = require('./api-client');
+
+/**
+ * Log an agent action to the activity log
+ */
+async function logActivity({ action, requestData, responseSummary, status, errorMessage, durationMs }) {
+  try {
+    await apiClient.post('/agent-keys/log', {
+      action,
+      request_data: requestData || null,
+      response_summary: responseSummary || null,
+      status: status || 'success',
+      error_message: errorMessage || null,
+      duration_ms: durationMs || null
+    });
+  } catch (err) {
+    // Non-blocking: log errors silently
+    console.error('[MCP Logger] Failed to log activity:', err.message || err);
+  }
+}
+
+/**
+ * Wrap a tool handler with automatic logging
+ */
+function withLogging(toolName, handler) {
+  return async (args) => {
+    const start = Date.now();
+    try {
+      const result = await handler(args);
+      const durationMs = Date.now() - start;
+
+      // Log success (non-blocking)
+      logActivity({
+        action: toolName,
+        requestData: args,
+        responseSummary: { success: true },
+        status: 'success',
+        durationMs
+      });
+
+      return result;
+    } catch (err) {
+      const durationMs = Date.now() - start;
+
+      // Log error (non-blocking)
+      logActivity({
+        action: toolName,
+        requestData: args,
+        status: 'error',
+        errorMessage: err.message || String(err),
+        durationMs
+      });
+
+      throw err;
+    }
+  };
+}
+
+module.exports = { logActivity, withLogging };

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "finoptima",
+  "version": "1.0.0",
+  "description": "FINOPTIMA — EcoChain AI Finance Agent via MCP. Portfolio optimization, AMM liquidity, trading, swaps. Secured by EcoAuth 2FA.",
+  "main": "index.js",
+  "bin": {
+    "finoptima": "index.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "keywords": [
+    "mcp",
+    "ai-agent",
+    "finance",
+    "defi",
+    "amm",
+    "trading",
+    "ecochain",
+    "ecoauth",
+    "model-context-protocol"
+  ],
+  "author": "EcoChain Team",
+  "license": "MIT",
+  "homepage": "https://www.toutcreer.com/trading/finoptima.md",
+  "repository": {
+    "type": "git",
+    "url": "https://www.toutcreer.com"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/tools/index.js

@@ -0,0 +1,399 @@
+/**
+ * MCP Tools Registry (DEC-2026-043)
+ *
+ * 21 tools organized by scope:
+ * - READ (14): Portfolio, balances, prices, pools, orderbook, etc.
+ * - TRADE (2): Place/cancel orders
+ * - SWAP (2): Quote/execute AMM swaps
+ * - LIQUIDITY (2): Add/remove liquidity
+ * - SEND (1): Internal transfers
+ */
+
+const apiClient = require('../lib/api-client');
+const { withLogging } = require('../lib/logger');
+
+// Helper: get user ID from env (set at startup from API key lookup)
+function uid() {
+  return process.env.ECOCHAIN_USER_ID || 'me';
+}
+
+// ============================================
+// READ TOOLS (scope: read)
+// ============================================
+
+const readTools = [
+  {
+    name: 'get_balances',
+    description: 'Get all wallet balances for the user (ECO, BTC, ETH). Returns chain, balance, and formatted values.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    handler: withLogging('get_balances', async () => {
+      const data = await apiClient.get(`/wallets/${uid()}`);
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'get_balance',
+    description: 'Get balance for a specific chain (ECO, BTC, or ETH).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        chain: { type: 'string', description: 'Chain name: ECO, BTC, or ETH', enum: ['ECO', 'BTC', 'ETH'] }
+      },
+      required: ['chain']
+    },
+    handler: withLogging('get_balance', async ({ chain }) => {
+      const data = await apiClient.get(`/wallets/${uid()}/${chain}/balance`);
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'get_portfolio',
+    description: 'Get complete portfolio view: all wallets plus LP positions in liquidity pools.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    handler: withLogging('get_portfolio', async () => {
+      const [wallets, positions] = await Promise.all([
+        apiClient.get(`/wallets/${uid()}`),
+        apiClient.get(`/amm/positions/${uid()}`)
+      ]);
+      return JSON.stringify({ wallets, lp_positions: positions }, null, 2);
+    })
+  },
+  {
+    name: 'get_prices',
+    description: 'Get current BTC and ETH prices in EUR from CoinGecko.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    handler: withLogging('get_prices', async () => {
+      const data = await apiClient.get('/prices');
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'get_pools',
+    description: 'List all AMM liquidity pools with their reserves, fees, and TVL.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    handler: withLogging('get_pools', async () => {
+      const data = await apiClient.get('/amm/pools');
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'get_pool_details',
+    description: 'Get detailed information about a specific liquidity pool (reserves, constant product k, fee rate).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pool_id: { type: 'string', description: 'The UUID of the pool' }
+      },
+      required: ['pool_id']
+    },
+    handler: withLogging('get_pool_details', async ({ pool_id }) => {
+      const data = await apiClient.get(`/amm/pools/${pool_id}`);
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'get_lp_positions',
+    description: 'Get all LP (Liquidity Provider) positions for the user, showing share of each pool.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    handler: withLogging('get_lp_positions', async () => {
+      const data = await apiClient.get(`/amm/positions/${uid()}`);
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'get_orderbook',
+    description: 'Get the order book (bids and asks) for a trading pair.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pair_id: { type: 'string', description: 'Trading pair ID (e.g., ECO-BTC)' }
+      },
+      required: ['pair_id']
+    },
+    handler: withLogging('get_orderbook', async ({ pair_id }) => {
+      const data = await apiClient.get(`/trading/orderbook/${pair_id}`);
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'get_ticker',
+    description: 'Get 24h trading statistics for a pair (price, volume, high, low, change).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pair_id: { type: 'string', description: 'Trading pair ID (e.g., ECO-BTC)' }
+      },
+      required: ['pair_id']
+    },
+    handler: withLogging('get_ticker', async ({ pair_id }) => {
+      const data = await apiClient.get(`/trading/ticker/${pair_id}`);
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'get_candles',
+    description: 'Get OHLCV candlestick data for technical analysis. Intervals: 1m, 5m, 15m, 1h, 4h, 1d, 1w.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pair_id: { type: 'string', description: 'Trading pair ID' },
+        interval: { type: 'string', description: 'Candle interval', enum: ['1m', '5m', '15m', '1h', '4h', '1d', '1w'] },
+        limit: { type: 'number', description: 'Number of candles (default 100, max 500)' }
+      },
+      required: ['pair_id']
+    },
+    handler: withLogging('get_candles', async ({ pair_id, interval, limit }) => {
+      const params = new URLSearchParams();
+      if (interval) params.set('interval', interval);
+      if (limit) params.set('limit', limit.toString());
+      const qs = params.toString();
+      const data = await apiClient.get(`/trading/candles/${pair_id}${qs ? '?' + qs : ''}`);
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'get_trading_pairs',
+    description: 'List all active trading pairs on the exchange.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+    handler: withLogging('get_trading_pairs', async () => {
+      const data = await apiClient.get('/trading/pairs');
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'get_my_orders',
+    description: 'Get all open orders for the user, optionally filtered by status.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        status: { type: 'string', description: 'Filter by status: open, filled, cancelled', enum: ['open', 'filled', 'cancelled'] }
+      },
+      required: []
+    },
+    handler: withLogging('get_my_orders', async ({ status }) => {
+      const params = status ? `?status=${status}` : '';
+      const data = await apiClient.get(`/trading/orders/${uid()}${params}`);
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'get_trade_history',
+    description: 'Get the trade execution history for the user.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Number of trades (default 50)' }
+      },
+      required: []
+    },
+    handler: withLogging('get_trade_history', async ({ limit }) => {
+      const params = limit ? `?limit=${limit}` : '';
+      const data = await apiClient.get(`/trading/history/${uid()}${params}`);
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'get_transaction_history',
+    description: 'Get transaction history (sends, receives, deposits, withdrawals).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        limit: { type: 'number', description: 'Number of transactions (default 50)' },
+        type: { type: 'string', description: 'Filter by type: send, receive, deposit, withdrawal' }
+      },
+      required: []
+    },
+    handler: withLogging('get_transaction_history', async ({ limit, type }) => {
+      const params = new URLSearchParams();
+      if (limit) params.set('limit', limit.toString());
+      if (type) params.set('type', type);
+      const qs = params.toString();
+      const data = await apiClient.get(`/transactions/${uid()}${qs ? '?' + qs : ''}`);
+      return JSON.stringify(data, null, 2);
+    })
+  }
+];
+
+// ============================================
+// TRADE TOOLS (scope: trade)
+// ============================================
+
+const tradeTools = [
+  {
+    name: 'place_order',
+    description: 'Place a trading order (limit or market, buy or sell). Returns the created order.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pair_id: { type: 'string', description: 'Trading pair ID (e.g., ECO-BTC)' },
+        side: { type: 'string', description: 'Order side', enum: ['buy', 'sell'] },
+        type: { type: 'string', description: 'Order type', enum: ['limit', 'market'] },
+        amount: { type: 'number', description: 'Amount to trade (in base currency)' },
+        price: { type: 'number', description: 'Price per unit (required for limit orders)' }
+      },
+      required: ['pair_id', 'side', 'type', 'amount']
+    },
+    handler: withLogging('place_order', async ({ pair_id, side, type, amount, price }) => {
+      const body = {
+        user_id: uid(),
+        pair_id,
+        side,
+        type,
+        amount
+      };
+      if (price !== undefined) body.price = price;
+      const data = await apiClient.post('/trading/orders', body);
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'cancel_order',
+    description: 'Cancel an open trading order by its ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        order_id: { type: 'string', description: 'The UUID of the order to cancel' }
+      },
+      required: ['order_id']
+    },
+    handler: withLogging('cancel_order', async ({ order_id }) => {
+      const data = await apiClient.delete(`/trading/orders/${order_id}`, { user_id: uid() });
+      return JSON.stringify(data, null, 2);
+    })
+  }
+];
+
+// ============================================
+// SWAP TOOLS (scope: swap)
+// ============================================
+
+const swapTools = [
+  {
+    name: 'get_swap_quote',
+    description: 'Get a swap quote without executing. Shows expected output, price impact, and fees (0.3%).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        token_in: { type: 'string', description: 'Input token (e.g., ECO, BTC)', enum: ['ECO', 'BTC', 'ETH'] },
+        token_out: { type: 'string', description: 'Output token (e.g., BTC, ECO)', enum: ['ECO', 'BTC', 'ETH'] },
+        amount_in: { type: 'number', description: 'Amount of input token to swap' }
+      },
+      required: ['token_in', 'token_out', 'amount_in']
+    },
+    handler: withLogging('get_swap_quote', async ({ token_in, token_out, amount_in }) => {
+      const data = await apiClient.post('/amm/swap/quote', { from_token: token_in, to_token: token_out, amount: amount_in });
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'execute_swap',
+    description: 'Execute an AMM swap. Swaps tokens through a liquidity pool with 0.3% fee. Returns the executed swap details.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        token_in: { type: 'string', description: 'Input token', enum: ['ECO', 'BTC', 'ETH'] },
+        token_out: { type: 'string', description: 'Output token', enum: ['ECO', 'BTC', 'ETH'] },
+        amount_in: { type: 'number', description: 'Amount of input token' },
+        min_amount_out: { type: 'number', description: 'Minimum acceptable output (slippage protection)' }
+      },
+      required: ['token_in', 'token_out', 'amount_in']
+    },
+    handler: withLogging('execute_swap', async ({ token_in, token_out, amount_in, min_amount_out }) => {
+      const body = { user_id: uid(), token_in, token_out, amount_in };
+      if (min_amount_out !== undefined) body.min_amount_out = min_amount_out;
+      const data = await apiClient.post('/amm/swap', body);
+      return JSON.stringify(data, null, 2);
+    })
+  }
+];
+
+// ============================================
+// LIQUIDITY TOOLS (scope: liquidity)
+// ============================================
+
+const liquidityTools = [
+  {
+    name: 'add_liquidity',
+    description: 'Add liquidity to an AMM pool. You must provide both tokens in the correct ratio. Mints LP tokens in return.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pool_id: { type: 'string', description: 'Pool UUID to add liquidity to' },
+        amount_a: { type: 'number', description: 'Amount of token A to deposit' },
+        amount_b: { type: 'number', description: 'Amount of token B to deposit' }
+      },
+      required: ['pool_id', 'amount_a', 'amount_b']
+    },
+    handler: withLogging('add_liquidity', async ({ pool_id, amount_a, amount_b }) => {
+      const data = await apiClient.post('/amm/liquidity/add', {
+        user_id: uid(),
+        pool_id,
+        amount_a,
+        amount_b
+      });
+      return JSON.stringify(data, null, 2);
+    })
+  },
+  {
+    name: 'remove_liquidity',
+    description: 'Remove liquidity from an AMM pool by burning LP tokens. Returns both tokens proportionally.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        pool_id: { type: 'string', description: 'Pool UUID' },
+        lp_amount: { type: 'number', description: 'Amount of LP tokens to burn' }
+      },
+      required: ['pool_id', 'lp_amount']
+    },
+    handler: withLogging('remove_liquidity', async ({ pool_id, lp_amount }) => {
+      const data = await apiClient.post('/amm/liquidity/remove', {
+        user_id: uid(),
+        pool_id,
+        lp_amount
+      });
+      return JSON.stringify(data, null, 2);
+    })
+  }
+];
+
+// ============================================
+// SEND TOOLS (scope: send)
+// ============================================
+
+const sendTools = [
+  {
+    name: 'send_funds',
+    description: 'Send funds to another user (by user ID or phone number). Internal transfer only — no blockchain fees.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        to: { type: 'string', description: 'Recipient user ID (UUID) or phone number' },
+        chain: { type: 'string', description: 'Token to send', enum: ['ECO', 'BTC', 'ETH'] },
+        amount: { type: 'number', description: 'Amount to send (in base units: cents for ECO, satoshis for BTC)' },
+        note: { type: 'string', description: 'Optional note for the transfer' }
+      },
+      required: ['to', 'chain', 'amount']
+    },
+    handler: withLogging('send_funds', async ({ to, chain, amount, note }) => {
+      const body = {
+        from_uid: uid(),
+        to_identifier: to,
+        chain,
+        amount
+      };
+      if (note) body.note = note;
+      const data = await apiClient.post('/transactions/send', body);
+      return JSON.stringify(data, null, 2);
+    })
+  }
+];
+
+// Export all tools grouped by scope
+module.exports = {
+  readTools,
+  tradeTools,
+  swapTools,
+  liquidityTools,
+  sendTools,
+  allTools: [...readTools, ...tradeTools, ...swapTools, ...liquidityTools, ...sendTools]
+};