@michaleffffff/mcp-trading-server 2.9.9 → 3.0.1

package/dist/tools/accountInfo.js

@@ -1,40 +1,132 @@
 import { z } from "zod";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
+import { getBalances, getMarginBalance } from "../services/balanceService.js";
 import { getTradeFlowTypeDesc } from "../utils/mappings.js";
-export const getAccountInfoTool = {
-    name: "get_account_info",
-    description: "Get full account information for a pool (freeMargin, quoteProfit, etc.). Essential for risk management.",
+function readErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    if (error && typeof error === "object" && "message" in error) {
+        return String(error.message);
+    }
+    return String(error ?? "unknown error");
+}
+function assertSdkReadSuccess(result, actionName) {
+    if (!result || typeof result !== "object" || Array.isArray(result))
+        return;
+    if (!Object.prototype.hasOwnProperty.call(result, "code"))
+        return;
+    const code = Number(result.code);
+    if (!Number.isFinite(code) || code === 0)
+        return;
+    const payload = result.data;
+    const hasPayload = payload !== null &&
+        payload !== undefined &&
+        (!Array.isArray(payload) || payload.length > 0);
+    if (code > 0 && hasPayload) {
+        // Keep aligned with server-side read normalization:
+        // positive non-zero code with usable payload is warning-like.
+        return;
+    }
+    const message = String(result.msg ?? result.message ?? "unknown error");
+    throw new Error(`${actionName} failed: code=${code}, msg=${message}`);
+}
+function normalizeAccountInfo(result) {
+    if (!(result && result.code === 0 && Array.isArray(result.data))) {
+        return result;
+    }
+    const values = result.data;
+    return {
+        ...result,
+        data: {
+            freeMargin: values[0],
+            walletBalance: values[1],
+            freeBaseAmount: values[2],
+            baseProfit: values[3],
+            quoteProfit: values[4],
+            reservedAmount: values[5],
+            releaseTime: values[6],
+            tradeableMargin: (BigInt(values[0]) + BigInt(values[1]) + (BigInt(values[6]) === 0n ? BigInt(values[4]) : 0n)).toString(),
+            baseProfitStatus: "base token to be unlocked",
+            quoteProfitStatus: BigInt(values[6]) > 0n ? "quote token to be unlocked" : "quote token unlocked/available"
+        }
+    };
+}
+export const getAccountTool = {
+    name: "get_account",
+    description: "Unified account snapshot. Distinguishes wallet balance vs trading-account metrics. Provide poolId for full trading-account details.",
     schema: {
-        poolId: z.string().describe("Pool ID"),
+        poolId: z.string().optional().describe("Optional Pool ID. Required to include trading-account metrics (account info + margin)."),
     },
     handler: async (args) => {
         try {
             const { client, address } = await resolveClient();
             const chainId = getChainId();
-            const result = await client.account.getAccountInfo(chainId, address, args.poolId);
-            // Map the raw array to a structured object for better usability
-            let structuredData = result;
-            if (result && result.code === 0 && Array.isArray(result.data)) {
-                const d = result.data;
-                structuredData = {
-                    ...result,
-                    data: {
-                        freeMargin: d[0],
-                        walletBalance: d[1],
-                        freeBaseAmount: d[2],
-                        baseProfit: d[3],
-                        quoteProfit: d[4],
-                        reservedAmount: d[5],
-                        releaseTime: d[6],
-                        // Business Logic: 
-                        // tradeableMargin = freeMargin + walletBalance + (quoteProfit if releaseTime == 0)
-                        tradeableMargin: (BigInt(d[0]) + BigInt(d[1]) + (BigInt(d[6]) === 0n ? BigInt(d[4]) : 0n)).toString(),
-                        baseProfitStatus: "base token to be unlocked",
-                        quoteProfitStatus: BigInt(d[6]) > 0n ? "quote token to be unlocked" : "quote token unlocked/available"
-                    }
-                };
+            const poolId = args.poolId?.trim();
+            const overview = {
+                meta: {
+                    address,
+                    chainId,
+                    poolId: poolId ?? null,
+                    partial: false,
+                },
+                wallet: {
+                    scope: "wallet_balance",
+                    description: "On-chain wallet quote-token balance (funds not yet deposited into trading account).",
+                    quoteTokenBalance: null,
+                    raw: null,
+                    error: null,
+                },
+                tradingAccount: {
+                    scope: "trading_account_balance",
+                    description: poolId
+                        ? "Trading-account metrics for the selected pool."
+                        : "Provide poolId to include trading-account metrics (account info + margin).",
+                    poolId: poolId ?? null,
+                    accountInfo: null,
+                    marginBalance: null,
+                    error: null,
+                },
+                warnings: [],
+            };
+            try {
+                const walletBalances = await getBalances(client, address);
+                assertSdkReadSuccess(walletBalances, "getWalletQuoteTokenBalance");
+                overview.wallet.quoteTokenBalance = walletBalances?.data ?? walletBalances;
+                overview.wallet.raw = walletBalances;
+            }
+            catch (walletError) {
+                overview.meta.partial = true;
+                overview.wallet.error = readErrorMessage(walletError);
+                overview.warnings.push(`wallet section failed: ${overview.wallet.error}`);
+            }
+            if (poolId) {
+                try {
+                    const [accountInfoRaw, marginBalanceRaw] = await Promise.all([
+                        client.account.getAccountInfo(chainId, address, poolId),
+                        getMarginBalance(client, address, poolId),
+                    ]);
+                    assertSdkReadSuccess(accountInfoRaw, "getAccountInfo");
+                    assertSdkReadSuccess(marginBalanceRaw, "getAvailableMarginBalance");
+                    overview.tradingAccount.accountInfo = normalizeAccountInfo(accountInfoRaw);
+                    overview.tradingAccount.marginBalance = marginBalanceRaw;
+                }
+                catch (tradingError) {
+                    overview.meta.partial = true;
+                    overview.tradingAccount.error = readErrorMessage(tradingError);
+                    overview.warnings.push(`tradingAccount section failed: ${overview.tradingAccount.error}`);
+                }
+            }
+            if (overview.warnings.length === 0) {
+                delete overview.warnings;
+            }
+            const hasWalletData = overview.wallet.quoteTokenBalance !== null;
+            const hasTradingData = overview.tradingAccount.accountInfo !== null || overview.tradingAccount.marginBalance !== null;
+            if (!hasWalletData && !hasTradingData) {
+                throw new Error("Failed to build account snapshot: wallet and trading-account sections both unavailable.");
             }
-            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: structuredData }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
+            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: overview }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
         }
         catch (error) {
             return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
@@ -65,25 +157,3 @@ export const getTradeFlowTool = {
         }
     },
 };
-export const getMarginBalanceTool = {
-    name: "get_margin_balance",
-    description: "Get available margin balance for a specific pool.",
-    schema: {
-        poolId: z.string().describe("Pool ID"),
-    },
-    handler: async (args) => {
-        try {
-            const { client, address } = await resolveClient();
-            const chainId = getChainId();
-            const result = await client.account.getAvailableMarginBalance({
-                poolId: args.poolId,
-                chainId,
-                address,
-            });
-            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: result }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
-        }
-        catch (error) {
-            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
-        }
-    },
-};

package/dist/tools/adjustMargin.js

@@ -8,7 +8,7 @@ export const adjustMarginTool = {
     schema: {
         poolId: z.string().describe("Pool ID"),
         positionId: z.string().describe("Position ID"),
-        adjustAmount: z.coerce.string().regex(/^-?\d+$/).describe("Quote token raw units. Positive = add, negative = remove."),
+        adjustAmount: z.union([z.string(), z.number()]).describe("Adjust amount. Human units are supported (e.g. '1' = 1 USDC). Use 'raw:<int>' for exact raw units."),
         quoteToken: z.string().optional().describe("Quote token address"),
         poolOracleType: z.coerce.number().optional().describe("Oracle type: 1 for Chainlink, 2 for Pyth"),
     },

package/dist/tools/cancelAllOrders.js

@@ -1,17 +1,49 @@
 import { z } from "zod";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
+function normalizeOrderIds(input) {
+    if (Array.isArray(input)) {
+        return input.map((id) => String(id).trim()).filter(Boolean);
+    }
+    if (typeof input === "string") {
+        const text = input.trim();
+        if (!text)
+            return [];
+        // Support toolchains that serialize arrays as JSON strings.
+        if (text.startsWith("[") && text.endsWith("]")) {
+            try {
+                const parsed = JSON.parse(text);
+                if (Array.isArray(parsed)) {
+                    return parsed.map((id) => String(id).trim()).filter(Boolean);
+                }
+            }
+            catch {
+                // Fallback to comma/single parsing below.
+            }
+        }
+        if (text.includes(",")) {
+            return text.split(",").map((id) => id.trim()).filter(Boolean);
+        }
+        return [text];
+    }
+    return [];
+}
 export const cancelAllOrdersTool = {
     name: "cancel_all_orders",
-    description: "Cancel multiple open orders by orderIds.",
+    description: "Cancel open orders by orderIds. Accepts array, JSON-array string, comma-separated string, or single orderId.",
     schema: {
-        orderIds: z.array(z.string()).min(1).describe("Order IDs to cancel."),
+        orderIds: z
+            .union([z.array(z.string()).min(1), z.string().min(1)])
+            .describe("Order IDs to cancel. Supports array or string (single/comma/JSON-array)."),
     },
     handler: async (args) => {
         try {
             const { client, signer } = await resolveClient();
             const chainId = getChainId();
-            const orderIds = args.orderIds;
+            const orderIds = normalizeOrderIds(args.orderIds);
+            if (orderIds.length === 0) {
+                throw new Error("orderIds is required and must include at least one non-empty order id.");
+            }
             const raw = await client.order.cancelAllOrders(orderIds, chainId);
             const result = await finalizeMutationResult(raw, signer, "cancel_all_orders");
             return {

package/dist/tools/index.js

@@ -28,10 +28,9 @@ export { createPerpMarketTool } from "./createPerpMarket.js";
 export { manageLiquidityTool, getLpPriceTool } from "./manageLiquidity.js";
 // Tools — 账户 & 查询
 export { getPositionsTool } from "./getPositions.js";
-export { getBalancesTool } from "./getBalances.js";
 export { getOpenOrdersTool, getOrderHistoryTool } from "./orderQueries.js";
 export { getPositionHistoryTool } from "./positionHistory.js";
-export { getAccountInfoTool, getTradeFlowTool, getMarginBalanceTool } from "./accountInfo.js";
+export { getAccountTool, getTradeFlowTool } from "./accountInfo.js";
 export { getAccountVipInfoTool } from "./getAccountVipInfo.js";
 export { accountDepositTool, accountWithdrawTool } from "./accountTransfer.js";
 export { getMarketListTool } from "./getMarketList.js";

package/dist/tools/manageLiquidity.js

@@ -3,6 +3,7 @@ import { quoteDeposit, quoteWithdraw, baseDeposit, baseWithdraw, getLpPrice, } f
 import { resolveClient } from "../auth/resolveClient.js";
 import { resolvePool } from "../services/marketService.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
+import { extractErrorMessage } from "../utils/errorMessage.js";
 export const manageLiquidityTool = {
     name: "manage_liquidity",
     description: "Add or withdraw liquidity from a BASE or QUOTE pool.",
@@ -40,11 +41,14 @@ export const manageLiquidityTool = {
             if (!raw) {
                 throw new Error(`SDK returned an empty result for liquidity ${action}. This usually occurs if the pool is not in an Active state (state: 2) or if there is a contract-level restriction. Please check pool_info.`);
             }
+            if (raw && typeof raw === "object" && "code" in raw && Number(raw.code) !== 0) {
+                throw new Error(`Liquidity ${action} failed: ${extractErrorMessage(raw)}`);
+            }
             const data = await finalizeMutationResult(raw, signer, "manage_liquidity");
             return { content: [{ type: "text", text: JSON.stringify({ status: "success", data }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
         }
         catch (error) {
-            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+            return { content: [{ type: "text", text: `Error: ${extractErrorMessage(error)}` }], isError: true };
         }
     },
 };
@@ -62,7 +66,7 @@ export const getLpPriceTool = {
             return { content: [{ type: "text", text: JSON.stringify({ status: "success", data }, (k, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
         }
         catch (error) {
-            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+            return { content: [{ type: "text", text: `Error: ${extractErrorMessage(error)}` }], isError: true };
         }
     },
 };

package/dist/tools/marketInfo.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { resolveClient, getChainId } from "../auth/resolveClient.js";
 import { getMarketDetail, resolvePool } from "../services/marketService.js";
 import { getPoolInfo, getLiquidityInfo } from "../services/poolService.js";
+import { extractErrorMessage } from "../utils/errorMessage.js";
 export const getMarketDetailTool = {
     name: "get_market_detail",
     description: "Get detailed information for a specific trading pool (fee rates, open interest, etc.). Supports PoolId, Token Address, or Keywords.",
@@ -20,7 +21,7 @@ export const getMarketDetailTool = {
             return { content: [{ type: "text", text: JSON.stringify({ status: "success", data }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
         }
         catch (error) {
-            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+            return { content: [{ type: "text", text: `Error: ${extractErrorMessage(error)}` }], isError: true };
         }
     },
 };
@@ -36,13 +37,13 @@ export const getPoolInfoTool = {
             const { client } = await resolveClient();
             const poolId = await resolvePool(client, args.poolId);
             const chainId = args.chainId ?? getChainId();
-            const data = await getPoolInfo(poolId, chainId);
+            const data = await getPoolInfo(poolId, chainId, client);
             if (!data)
                 throw new Error(`Pool info for ${poolId} returned undefined. The pool may not exist on chainId ${chainId}.`);
             return { content: [{ type: "text", text: JSON.stringify({ status: "success", data }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
         }
         catch (error) {
-            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+            return { content: [{ type: "text", text: `Error: ${extractErrorMessage(error)}` }], isError: true };
         }
     },
 };
@@ -65,7 +66,7 @@ export const getLiquidityInfoTool = {
             return { content: [{ type: "text", text: JSON.stringify({ status: "success", data }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
         }
         catch (error) {
-            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+            return { content: [{ type: "text", text: `Error: ${extractErrorMessage(error)}` }], isError: true };
         }
     },
 };

package/dist/tools/searchMarket.js

@@ -3,15 +3,15 @@ import { resolveClient } from "../auth/resolveClient.js";
 import { searchMarket } from "../services/marketService.js";
 export const searchMarketTool = {
     name: "search_market",
-    description: "Search for an active market by keyword.",
+    description: "Search active markets by keyword. Leave keyword empty to list active markets.",
     schema: {
-        keyword: z.string().describe('Search keyword, e.g. "BTC", "ETH"'),
+        keyword: z.string().optional().describe('Search keyword, e.g. "BTC", "ETH". Leave empty to return active markets.'),
         limit: z.number().int().positive().optional().describe("Max results (default 100)"),
     },
     handler: async (args) => {
         try {
             const { client } = await resolveClient();
-            const activeMarkets = await searchMarket(client, args.keyword, args.limit);
+            const activeMarkets = await searchMarket(client, args.keyword ?? "", args.limit ?? 100);
             return { content: [{ type: "text", text: JSON.stringify({ status: "success", data: activeMarkets }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
         }
         catch (error) {

package/dist/tools/updateOrderTpSl.js

@@ -2,20 +2,22 @@ import { z } from "zod";
 import { resolveClient } from "../auth/resolveClient.js";
 import { updateOrderTpSl } from "../services/tradeService.js";
 import { finalizeMutationResult } from "../utils/mutationResult.js";
+import { extractErrorMessage } from "../utils/errorMessage.js";
 export const updateOrderTpSlTool = {
     name: "update_order_tp_sl",
     description: "Update an existing take profit or stop loss order.",
     schema: {
         orderId: z.string().describe("The ID of the order to update"),
         marketId: z.string().describe("The market ID (config hash) for the order"),
-        size: z.string().describe("Order size (raw or human-readable)"),
-        price: z.string().describe("Order price (raw or human-readable, 30 decimals)"),
-        tpPrice: z.string().describe("TP price (raw or human-readable, 30 decimals)"),
-        tpSize: z.string().describe("TP size (raw or human-readable)"),
-        slPrice: z.string().describe("SL price (raw or human-readable, 30 decimals)"),
-        slSize: z.string().describe("SL size (raw or human-readable)"),
-        useOrderCollateral: z.boolean().describe("Whether to use order collateral"),
-        isTpSlOrder: z.boolean().optional().describe("Whether this is a TP/SL order"),
+        poolId: z.string().optional().describe("Optional poolId hint for decimal resolution."),
+        size: z.union([z.string(), z.number()]).describe("Order size (raw or human-readable)"),
+        price: z.union([z.string(), z.number()]).describe("Order price (raw or human-readable, 30 decimals)"),
+        tpPrice: z.union([z.string(), z.number()]).describe("TP price (raw or human-readable, 30 decimals)"),
+        tpSize: z.union([z.string(), z.number()]).describe("TP size (raw or human-readable)"),
+        slPrice: z.union([z.string(), z.number()]).describe("SL price (raw or human-readable, 30 decimals)"),
+        slSize: z.union([z.string(), z.number()]).describe("SL size (raw or human-readable)"),
+        useOrderCollateral: z.coerce.boolean().describe("Whether to use order collateral"),
+        isTpSlOrder: z.coerce.boolean().optional().describe("Whether this is a TP/SL order"),
         quoteToken: z.string().describe("Quote token address"),
     },
     handler: async (args) => {
@@ -26,7 +28,7 @@ export const updateOrderTpSlTool = {
             return { content: [{ type: "text", text: JSON.stringify({ status: "success", data }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
         }
         catch (error) {
-            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
+            return { content: [{ type: "text", text: `Error: ${extractErrorMessage(error)}` }], isError: true };
         }
     },
 };

package/dist/utils/errorMessage.js

@@ -0,0 +1,69 @@
+const USELESS_MESSAGE_SET = new Set([
+    "",
+    "undefined",
+    "null",
+    "[object object]",
+    "{}",
+]);
+function cleanMessage(input) {
+    if (typeof input !== "string")
+        return null;
+    const text = input.trim();
+    if (!text)
+        return null;
+    if (USELESS_MESSAGE_SET.has(text.toLowerCase()))
+        return null;
+    return text;
+}
+function isRecord(value) {
+    return !!value && typeof value === "object";
+}
+function safeStringify(value) {
+    try {
+        return cleanMessage(JSON.stringify(value, (_, item) => (typeof item === "bigint" ? item.toString() : item)));
+    }
+    catch {
+        return cleanMessage(String(value ?? ""));
+    }
+}
+export function isMeaningfulErrorMessage(message) {
+    return cleanMessage(message) !== null;
+}
+export function extractErrorMessage(error, fallback = "Unknown error") {
+    const visited = new Set();
+    const read = (value, depth) => {
+        if (depth > 6 || value === null || value === undefined)
+            return null;
+        if (typeof value === "string")
+            return cleanMessage(value);
+        if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+            return cleanMessage(String(value));
+        }
+        if (value instanceof Error) {
+            const message = cleanMessage(value.message);
+            if (message)
+                return message;
+            return read(value.cause, depth + 1);
+        }
+        if (!isRecord(value)) {
+            return cleanMessage(String(value));
+        }
+        if (visited.has(value))
+            return null;
+        visited.add(value);
+        const directKeys = ["message", "reason", "shortMessage", "msg", "detail", "error_description"];
+        for (const key of directKeys) {
+            const message = read(value[key], depth + 1);
+            if (message)
+                return message;
+        }
+        const nestedKeys = ["error", "data", "cause", "response", "info"];
+        for (const key of nestedKeys) {
+            const message = read(value[key], depth + 1);
+            if (message)
+                return message;
+        }
+        return safeStringify(value);
+    };
+    return read(error, 0) ?? fallback;
+}

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@michaleffffff/mcp-trading-server",
-  "version": "2.9.9",
+  "version": "3.0.1",
   "type": "module",
   "bin": {
     "myx-mcp": "dist/server.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "README.md",
+    "TOOL_EXAMPLES.md",
+    "CHANGELOG.md"
   ],
   "scripts": {
     "build": "rm -rf dist && tsc",

package/dist/tools/getBalances.js

@@ -1,17 +0,0 @@
-import { resolveClient } from "../auth/resolveClient.js";
-import { getBalances } from "../services/balanceService.js";
-export const getBalancesTool = {
-    name: "get_balances",
-    description: "Get the account balances for different tokens.",
-    schema: {},
-    handler: async () => {
-        try {
-            const { client, address } = await resolveClient();
-            const data = await getBalances(client, address);
-            return { content: [{ type: "text", text: JSON.stringify({ status: "success", data }, (_, v) => typeof v === 'bigint' ? v.toString() : v, 2) }] };
-        }
-        catch (error) {
-            return { content: [{ type: "text", text: `Error: ${error.message}` }], isError: true };
-        }
-    },
-};