@aihubspot/agent-trade-mcp 0.1.11 → 0.1.13

package/README.md

@@ -1,6 +1,6 @@
 # AI Hub Agent Trade MCP
 
-Install with `npm install -g @aihubspot/agent-trade-mcp`, then start `ai-hub-trade-mcp --profile default`.
+Install with `npm install -g @aihubspot/agent-trade-mcp`, then start `ai-hub-trade-mcp --profile default`. The default Toolset exposes the focused market, spot-order, universal-transfer, and wallet-query workflows. Use `--toolset full` to expose every supported Core capability. Read responses use compact text by default; use `--response-mode compat` only for clients that require the legacy duplicated JSON text.
 
 This package provides a local stdio MCP server. State-changing operations require a preview and a new explicit user confirmation.
 
@@ -15,9 +15,19 @@ ai-hub-trade-mcp setup --client cursor --profile default
 ai-hub-trade-mcp setup --client claude-desktop --profile default
 ai-hub-trade-mcp setup --client claude-code --profile default
 ai-hub-trade-mcp setup --client codex --profile default
+ai-hub-trade-mcp setup --client openclaw --profile default
+ai-hub-trade-mcp setup --client codex --profile default --toolset full
+ai-hub-trade-mcp setup --client codex --profile default --response-mode compat
 ```
 
-Setup registers the currently installed MCP binary through its absolute Node runtime and entrypoint path, so desktop clients do not depend on a global PATH or an unpublished `npx` package. Cursor and Claude Desktop configurations are merged with existing MCP servers through their JSON configurations. Claude Code and Codex are registered through their official CLIs; Claude Code uses user scope. Existing JSON configurations are validated, atomically updated, and backed up before their first modification. The setup command stores no API credentials; the MCP server continues to read its profile from `~/.ai-hub/config.toml`.
+Setup registers the currently installed MCP binary through its absolute Node runtime and entrypoint path, so desktop clients do not depend on a global PATH or an unpublished `npx` package. Cursor and Claude Desktop configurations are merged with existing MCP servers through their JSON configurations. Claude Code, Codex, and OpenClaw are registered through their official CLIs; Claude Code uses user scope. Existing JSON configurations are validated, atomically updated, and backed up before their first modification. The setup command stores no API credentials; the MCP server continues to read its profile from `~/.ai-hub/config.toml`.
+
+For OpenClaw, run setup on the machine that runs the OpenClaw Gateway and as the same operating-system user as that Gateway. The selected AI Hub profile must exist in that user's `~/.ai-hub/config.toml`. Verify the registration after setup:
+
+```bash
+openclaw mcp doctor ai-hub-trade-mcp-default --probe
+openclaw mcp reload
+```
 
 ## Spot market-order units
 
@@ -33,7 +43,7 @@ All read tools return `{ "ok": true, "data": ... }` in one of these stable forms
 - Objects: `{ "dataType": "object", "value": { ... } }`
 - Scalars: `{ "dataType": "scalar", "value": "..." }`
 
-MCP clients that support the current protocol also receive the same envelope in `structuredContent`, validated by each read tool's output schema. Check `data.dataType` before formatting; do not infer raw OpenAPI nesting.
+MCP clients receive the full envelope in `structuredContent`, validated by each read tool's output schema. In the default `compact` mode, text contains only the response type plus safe list metadata (`count`, `returnedCount`, `totalCount`, `nextOffset`, or `truncated` when applicable), so the same JSON is not duplicated in the Agent context. Use `--response-mode compat` to also place the full envelope in text. Check `data.dataType` before formatting; do not infer raw OpenAPI nesting.
 
 ## Bounded market analysis
 
@@ -41,11 +51,11 @@ Use these tools for requests that would otherwise return a broad market payload:
 
 - `market_get_symbol_overview`: counts by quote asset and a small sample. Use this first for a generic request to list trading pairs.
 - `market_list_symbols`: a paged, optionally quote-asset-filtered list without order-rule metadata.
-- `market_search_symbols`: required-keyword lookup with at most 20 basic matching rows. Do not use it for a generic pair list.
+- `market_search_symbols`: required-keyword lookup with at most 50 basic matching rows. Do not use it for a generic pair list.
 - `market_get_symbol_info`: exact precision and minimum order rules for one symbol only.
-- `market_get_ticker_summary`: watchlist, gainers, losers, and quote-volume leaders.
-- `market_get_depth_summary`: best bid/ask, spread, and up to 20 levels per side.
+- `market_get_ticker_summary`: watchlist, gainers, losers, and quote-volume leaders under one total result budget (20 by default, 50 maximum).
+- `market_get_depth_summary`: best bid/ask, spread, and up to 50 levels per side.
 - `market_get_trades_summary`: price range, buy/sell statistics, and up to 50 recent trades.
-- `market_get_klines_summary`: period change, high/low, latest candle, and up to 100 candles. It defaults to `60min`; formal intervals are `1min`, `5min`, `15min`, `30min`, `60min`, `1day`, `1week`, and `1month`.
+- `market_get_klines_summary`: period change, high/low, latest candle, and up to 50 candles. It defaults to `60min`; formal intervals are `1min`, `5min`, `15min`, `30min`, `60min`, `1day`, `1week`, and `1month`.
 
-The complete raw symbols endpoint is intentionally CLI-only because its payload is too large for Agent contexts. Raw ticker, depth, trades, and kline tools remain available only when an exact payload is explicitly needed. Raw trades are capped at 100 rows; raw klines support the upstream maximum of 300 rows.
+The default Toolset exposes only these bounded forms. The `full` Toolset additionally exposes raw symbols, depth, trades, and kline responses for explicit advanced use. Every list is limited to 50 rows; raw symbols are paged with `offset` and `nextOffset`.

package/dist/index.js

@@ -451,7 +451,7 @@ async function normalizeOpenApiBaseUrl(value) {
     throw new AiHubError("AI_HUB_UNSAFE_OPENAPI_URL", "Localhost is not allowed as an OpenAPI base URL.");
   }
   const records2 = isIP(url.hostname) ? [{ address: url.hostname }] : await lookup(url.hostname, { all: true, verbatim: true });
-  if (records2.length === 0 || records2.some((record3) => blockedIp(record3.address))) {
+  if (records2.length === 0 || records2.some((record4) => blockedIp(record4.address))) {
     throw new AiHubError("AI_HUB_UNSAFE_OPENAPI_URL", "OpenAPI base URL must resolve only to public addresses.");
   }
   url.pathname = url.pathname.replace(/\/+$/, "");
@@ -635,11 +635,11 @@ function strictObject(input, allowedKeys) {
   if (!input || typeof input !== "object" || Array.isArray(input)) {
     throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "Tool input must be an object.");
   }
-  const record3 = input;
-  for (const key of Object.keys(record3)) {
+  const record4 = input;
+  for (const key of Object.keys(record4)) {
     if (!allowedKeys.includes(key)) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `Unknown argument "${key}".`);
   }
-  return record3;
+  return record4;
 }
 function requiredString(input, name) {
   const value = input[name];
@@ -663,23 +663,6 @@ function optionalInteger(input, name, fallback, minimum, maximum) {
 
 // ../core/src/tools/account-tools.ts
 var accountTools = [
-  {
-    name: "spot_get_account",
-    title: "Get Spot Account",
-    description: "Get the signed account overview for the configured profile.",
-    cliPath: ["account", "get"],
-    module: "spot-account",
-    access: "signed",
-    operation: "read",
-    riskLevel: "low",
-    inputSchema: { type: "object", additionalProperties: false },
-    errorCodes: ["AI_HUB_CREDENTIAL_NOT_CONFIGURED", "AI_HUB_OPENAPI_NETWORK_ERROR", "AI_HUB_OPENAPI_HTTP_ERROR", "AI_HUB_OPENAPI_INVALID_RESPONSE", "AI_HUB_OPENAPI_BUSINESS_ERROR"],
-    validate: (input) => strictObject(input, []),
-    handler: async (_input, context) => {
-      if (!context.credentials) throw new AiHubError("AI_HUB_CREDENTIAL_NOT_CONFIGURED", `Credentials are not configured for profile "${context.profile.name}".`);
-      return context.api.account(context.credentials);
-    }
-  },
   {
     name: "account_get_asset_balance",
     title: "Get Asset Balance",
@@ -740,6 +723,95 @@ function optionalClientOrderId(input) {
   return optionalString(input, "newClientOrderId") ?? `agent_${randomUUID2().replaceAll("-", "").slice(0, 24)}`;
 }
 
+// ../core/src/tools/list-limit.ts
+var STANDARD_LIST_LIMIT = {
+  field: "limit",
+  defaultValue: 20,
+  maximum: 50
+};
+var STANDARD_PAGE_SIZE = {
+  field: "pageSize",
+  defaultValue: 20,
+  maximum: 50
+};
+function listLimitSchema(limit, description) {
+  return {
+    type: "integer",
+    minimum: 1,
+    maximum: limit.maximum,
+    description: description ?? `Defaults to ${limit.defaultValue}; maximum ${limit.maximum}.`
+  };
+}
+function optionalListLimit(input, limit) {
+  return optionalInteger(input, limit.field, limit.defaultValue, 1, limit.maximum);
+}
+function normalizeListLimitInput(input, limit) {
+  const value = record2(input);
+  return value ? { ...value, [limit.field]: optionalListLimit(value, limit) } : input;
+}
+function normalizedListLimit(input, limit) {
+  const value = input[limit.field];
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > limit.maximum) {
+    throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `${limit.field} must be an integer between 1 and ${limit.maximum}.`);
+  }
+  return value;
+}
+function withListLimit(tool) {
+  if (!tool.listLimit) return tool;
+  const limit = tool.listLimit;
+  return {
+    ...tool,
+    inputSchema: {
+      ...tool.inputSchema,
+      properties: {
+        ...tool.inputSchema.properties,
+        [limit.field]: listLimitSchema(limit, tool.inputSchema.properties?.[limit.field]?.description)
+      }
+    },
+    validate: (input) => tool.validate(normalizeListLimitInput(input, limit))
+  };
+}
+function record2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function truncateUnpagedListResponse(response, definition, input, maximum = STANDARD_LIST_LIMIT.maximum) {
+  const root = record2(response);
+  if (!root || definition.path.length === 0) return response;
+  const ancestors = [root];
+  let current = root;
+  for (const key of definition.path) {
+    const next = record2(current)?.[key];
+    if (key === definition.path[definition.path.length - 1]) {
+      if (!Array.isArray(next) || next.length <= maximum) return response;
+      const parent = record2(current);
+      if (!parent) return response;
+      const currentPage = definition.pageField ? input[definition.pageField] : void 0;
+      const nextPage = typeof currentPage === "number" ? currentPage + 1 : null;
+      const limitedParent = {
+        ...parent,
+        [key]: next.slice(0, maximum),
+        returnedCount: maximum,
+        totalCount: next.length,
+        truncated: true,
+        continuation: definition.pageField ? { available: true, [definition.pageField]: nextPage } : { available: false, reason: "The upstream endpoint does not expose a continuation parameter." }
+      };
+      let replacement = limitedParent;
+      for (let index = ancestors.length - 2; index >= 0; index -= 1) {
+        const ancestor = ancestors[index];
+        const childKey = definition.path[index];
+        if (!ancestor || !childKey) return response;
+        replacement = { ...ancestor, [childKey]: replacement };
+      }
+      return replacement;
+    }
+    const nextRecord = record2(next);
+    if (!nextRecord) return response;
+    ancestors.push(nextRecord);
+    current = nextRecord;
+  }
+  return response;
+}
+
 // ../core/src/tools/asset-tools.ts
 var ACCOUNT_TYPES = ["1", "2", "3", "4", "5"];
 var ACCOUNT_TYPE_NAMES = {
@@ -760,7 +832,6 @@ var accountTypeSchema = {
   ],
   description: "Account type: 1=Spot, 2=Isolated Margin (requires symbol), 3=Cross Margin, 4=C2C, 5=Derivatives. Do not use 2 for Derivatives."
 };
-var spotDerivativeAccounts = ["EXCHANGE", "FUTURE"];
 function accountType(value, name) {
   const result2 = requiredString(value, name);
   if (!ACCOUNT_TYPES.includes(result2)) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `${name} must be an account type: 1=Spot, 2=Isolated Margin, 3=Cross Margin, 4=C2C, or 5=Derivatives.`);
@@ -791,27 +862,7 @@ function transferQuery(input) {
   if (isIsolatedMarginTransfer(fromAccountType, toAccountType) && !symbol) {
     throw new AiHubError("AI_HUB_ISOLATED_MARGIN_SYMBOL_REQUIRED", "symbol is required when fromAccountType or toAccountType is 2 (Isolated Margin). Provide the isolated-margin trading pair, for example ETHUSDT.");
   }
-  return { fromAccountType, toAccountType, page: optionalPositiveInteger(value, "page", 1), pageSize: optionalPositiveInteger(value, "pageSize", 20, 100), ...symbol ? { symbol } : {}, ...optionalString(value, "coinSymbol") ? { coinSymbol: optionalString(value, "coinSymbol") } : {} };
-}
-function transferAccounts(input) {
-  const value = strictObject(input, ["coinSymbol", "amount", "fromAccount", "toAccount"]);
-  const fromAccount = requiredString(value, "fromAccount").toUpperCase();
-  const toAccount = requiredString(value, "toAccount").toUpperCase();
-  if (!spotDerivativeAccounts.includes(fromAccount) || !spotDerivativeAccounts.includes(toAccount) || fromAccount === toAccount) {
-    throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "account transfer supports only EXCHANGE -> FUTURE or FUTURE -> EXCHANGE. Use wallet transfer for isolated margin, cross margin, or C2C.");
-  }
-  return { coinSymbol: requiredString(value, "coinSymbol"), amount: positiveDecimal(value, "amount"), fromAccount, toAccount };
-}
-function transferAccountHistory(input) {
-  const value = strictObject(input, ["transferId", "coinSymbol", "fromAccount", "toAccount", "startTime", "endTime", "page", "limit"]);
-  const transferId = optionalString(value, "transferId");
-  if (!transferId && (!optionalString(value, "fromAccount") || !optionalString(value, "toAccount"))) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "fromAccount and toAccount are required when transferId is omitted.");
-  const fromAccount = optionalString(value, "fromAccount")?.toUpperCase();
-  const toAccount = optionalString(value, "toAccount")?.toUpperCase();
-  if (!transferId && (!spotDerivativeAccounts.includes(fromAccount) || !spotDerivativeAccounts.includes(toAccount) || fromAccount === toAccount)) {
-    throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "account transfer history supports only EXCHANGE -> FUTURE or FUTURE -> EXCHANGE when transferId is omitted.");
-  }
-  return { ...transferId ? { transferId } : {}, ...optionalString(value, "coinSymbol") ? { coinSymbol: optionalString(value, "coinSymbol") } : {}, ...fromAccount ? { fromAccount } : {}, ...toAccount ? { toAccount } : {}, ...optionalString(value, "startTime") ? { startTime: optionalString(value, "startTime") } : {}, ...optionalString(value, "endTime") ? { endTime: optionalString(value, "endTime") } : {}, page: optionalPositiveInteger(value, "page", 1), limit: optionalPositiveInteger(value, "limit", 20, 100) };
+  return { fromAccountType, toAccountType, page: optionalPositiveInteger(value, "page", 1), pageSize: normalizedListLimit(value, STANDARD_PAGE_SIZE), ...symbol ? { symbol } : {}, ...optionalString(value, "coinSymbol") ? { coinSymbol: optionalString(value, "coinSymbol") } : {} };
 }
 function withAccountTypeMetadata(response, value) {
   const metadata = { accountType: value, accountTypeName: accountTypeName(value) };
@@ -820,49 +871,17 @@ function withAccountTypeMetadata(response, value) {
 }
 function pagedDates(input) {
   const value = strictObject(input, ["startTime", "endTime", "page", "pageSize"]);
-  return { ...optionalString(value, "startTime") ? { startTime: optionalString(value, "startTime") } : {}, ...optionalString(value, "endTime") ? { endTime: optionalString(value, "endTime") } : {}, page: optionalPositiveInteger(value, "page", 1), pageSize: optionalPositiveInteger(value, "pageSize", 20, 100) };
+  return { ...optionalString(value, "startTime") ? { startTime: optionalString(value, "startTime") } : {}, ...optionalString(value, "endTime") ? { endTime: optionalString(value, "endTime") } : {}, page: optionalPositiveInteger(value, "page", 1), pageSize: normalizedListLimit(value, STANDARD_PAGE_SIZE) };
 }
 function coinOnly(input) {
   const value = strictObject(input, ["mainCoinSymbol"]);
   return { mainCoinSymbol: requiredString(value, "mainCoinSymbol") };
 }
 var assetTools = [
-  {
-    name: "account_transfer",
-    title: "Transfer Between Spot and Derivatives",
-    description: "Transfer only between Spot and Derivatives after confirmation. Use fromAccount=EXCHANGE and toAccount=FUTURE for Spot to Derivatives; use the reverse for Derivatives to Spot. Do not pass numeric account types to this Tool.",
-    cliPath: ["account", "transfer"],
-    module: "spot-account",
-    access: "signed",
-    operation: "write",
-    riskLevel: "high",
-    inputSchema: { type: "object", properties: { coinSymbol: { type: "string" }, amount: { type: "string" }, fromAccount: { type: "string", enum: spotDerivativeAccounts, description: "EXCHANGE means Spot; FUTURE means Derivatives." }, toAccount: { type: "string", enum: spotDerivativeAccounts, description: "EXCHANGE means Spot; FUTURE means Derivatives." } }, required: ["coinSymbol", "amount", "fromAccount", "toAccount"], additionalProperties: false },
-    errorCodes: writeErrors,
-    validate: transferAccounts,
-    handler: (input, context) => context.api.signedPost("/sapi/v1/asset/transfer", input, signed(context)),
-    writeSummary: (input) => {
-      const value = input;
-      return { action: "spot_derivatives_transfer", coinSymbol: value.coinSymbol, amount: value.amount, fromAccount: value.fromAccount, fromAccountName: value.fromAccount === "EXCHANGE" ? "Spot" : "Derivatives", toAccount: value.toAccount, toAccountName: value.toAccount === "EXCHANGE" ? "Spot" : "Derivatives" };
-    }
-  },
-  {
-    name: "account_get_transfer_history",
-    title: "Get Account Transfer History",
-    description: "Query documented account transfer history.",
-    cliPath: ["account", "transfer-history"],
-    module: "spot-account",
-    access: "signed",
-    operation: "read",
-    riskLevel: "low",
-    inputSchema: { type: "object", properties: { transferId: { type: "string" }, coinSymbol: { type: "string" }, fromAccount: { type: "string" }, toAccount: { type: "string" }, startTime: { type: "string" }, endTime: { type: "string" }, page: { type: "integer" }, limit: { type: "integer" } }, additionalProperties: false },
-    errorCodes: signedReadErrors,
-    validate: transferAccountHistory,
-    handler: (input, context) => context.api.signedPost("/sapi/v1/asset/transferQuery", input, signed(context))
-  },
   {
     name: "wallet_universal_transfer",
     title: "Universal Asset Transfer",
-    description: "Transfer between numeric account types after confirmation: 1=Spot, 2=Isolated Margin, 3=Cross Margin, 4=C2C, 5=Derivatives. Account type 2 is not Derivatives and requires symbol. For a straightforward Spot to Derivatives transfer, prefer account_transfer with EXCHANGE -> FUTURE.",
+    description: "Transfer between numeric account types after confirmation: 1=Spot, 2=Isolated Margin, 3=Cross Margin, 4=C2C, 5=Derivatives. Account type 2 is not Derivatives and requires symbol.",
     cliPath: ["wallet", "transfer"],
     module: "spot-deposit-withdraw",
     access: "signed",
@@ -886,8 +905,9 @@ var assetTools = [
     access: "signed",
     operation: "read",
     riskLevel: "low",
-    inputSchema: { type: "object", properties: { fromAccountType: accountTypeSchema, toAccountType: accountTypeSchema, symbol: { type: "string", description: "Isolated-margin trading pair when account type 2 is involved." }, coinSymbol: { type: "string" }, page: { type: "integer" }, pageSize: { type: "integer" } }, required: ["fromAccountType", "toAccountType"], additionalProperties: false },
+    inputSchema: { type: "object", properties: { fromAccountType: accountTypeSchema, toAccountType: accountTypeSchema, symbol: { type: "string", description: "Isolated-margin trading pair when account type 2 is involved." }, coinSymbol: { type: "string" }, page: { type: "integer", minimum: 1 }, pageSize: listLimitSchema(STANDARD_PAGE_SIZE) }, required: ["fromAccountType", "toAccountType"], additionalProperties: false },
     errorCodes: signedReadErrors,
+    listLimit: STANDARD_PAGE_SIZE,
     validate: transferQuery,
     handler: (input, context) => context.api.signedPost("/sapi/v1/asset/universal_transfer_query", input, signed(context))
   },
@@ -900,8 +920,9 @@ var assetTools = [
     access: "signed",
     operation: "read",
     riskLevel: "low",
-    inputSchema: { type: "object", properties: { startTime: { type: "string" }, endTime: { type: "string" }, page: { type: "integer" }, pageSize: { type: "integer" } }, additionalProperties: false },
+    inputSchema: { type: "object", properties: { startTime: { type: "string" }, endTime: { type: "string" }, page: { type: "integer", minimum: 1 }, pageSize: listLimitSchema(STANDARD_PAGE_SIZE) }, additionalProperties: false },
     errorCodes: signedReadErrors,
+    listLimit: STANDARD_PAGE_SIZE,
     validate: pagedDates,
     handler: (input, context) => context.api.signedPost("/sapi/v1/deposit/his_list", input, signed(context))
   },
@@ -916,6 +937,7 @@ var assetTools = [
     riskLevel: "low",
     inputSchema: { type: "object", properties: { mainCoinSymbol: { type: "string" } }, required: ["mainCoinSymbol"], additionalProperties: false },
     errorCodes: signedReadErrors,
+    unpagedListLimit: { path: ["data", "depositAddrList"] },
     validate: coinOnly,
     handler: (input, context) => context.api.signedPost("/sapi/v1/deposit/query_address", input, signed(context))
   },
@@ -930,6 +952,7 @@ var assetTools = [
     riskLevel: "low",
     inputSchema: { type: "object", properties: { mainCoinSymbol: { type: "string" }, trustType: { type: "string" }, addrType: { type: "string" } }, required: ["mainCoinSymbol"], additionalProperties: false },
     errorCodes: signedReadErrors,
+    unpagedListLimit: { path: ["data", "addressList"] },
     validate: (input) => {
       const value = strictObject(input, ["mainCoinSymbol", "trustType", "addrType"]);
       return { mainCoinSymbol: requiredString(value, "mainCoinSymbol"), ...optionalString(value, "trustType") ? { trustType: optionalString(value, "trustType") } : {}, ...optionalString(value, "addrType") ? { addrType: optionalString(value, "addrType") } : {} };
@@ -947,6 +970,7 @@ var assetTools = [
     riskLevel: "low",
     inputSchema: { type: "object", properties: { accountType: accountTypeSchema }, required: ["accountType"], additionalProperties: false },
     errorCodes: signedReadErrors,
+    unpagedListLimit: { path: ["data", "accountList"] },
     validate: (input) => {
       const value = strictObject(input, ["accountType"]);
       return { accountType: accountType(value, "accountType") };
@@ -956,23 +980,6 @@ var assetTools = [
       return withAccountTypeMetadata(await context.api.signedPost("/sapi/v1/asset/account/by_type", value, signed(context)), value.accountType);
     }
   },
-  {
-    name: "wallet_get_exchange_account",
-    title: "Get Exchange Account Assets",
-    description: "Query exchange account assets.",
-    cliPath: ["wallet", "exchange-account"],
-    module: "spot-deposit-withdraw",
-    access: "signed",
-    operation: "read",
-    riskLevel: "low",
-    inputSchema: { type: "object", additionalProperties: false },
-    errorCodes: signedReadErrors,
-    validate: (input) => {
-      strictObject(input, []);
-      return {};
-    },
-    handler: (_input, context) => context.api.signedPost("/sapi/v1/asset/exchange/account", {}, signed(context))
-  },
   {
     name: "wallet_create_withdraw",
     title: "Create Withdrawal",
@@ -1005,6 +1012,7 @@ var assetTools = [
     riskLevel: "low",
     inputSchema: { type: "object", properties: { withdrawId: { type: "string" }, withdrawOrderId: { type: "string" }, symbol: { type: "string" }, startTime: { type: "string" }, endTime: { type: "string" }, page: { type: "integer" } }, additionalProperties: false },
     errorCodes: signedReadErrors,
+    unpagedListLimit: { path: ["data", "withdrawList"], pageField: "page" },
     validate: (input) => {
       const value = strictObject(input, ["withdrawId", "withdrawOrderId", "symbol", "startTime", "endTime", "page"]);
       return { ...optionalString(value, "withdrawId") ? { withdrawId: optionalString(value, "withdrawId") } : {}, ...optionalString(value, "withdrawOrderId") ? { withdrawOrderId: optionalString(value, "withdrawOrderId") } : {}, ...optionalString(value, "symbol") ? { symbol: optionalString(value, "symbol") } : {}, ...optionalString(value, "startTime") ? { startTime: optionalString(value, "startTime") } : {}, ...optionalString(value, "endTime") ? { endTime: optionalString(value, "endTime") } : {}, page: optionalPositiveInteger(value, "page", 1) };
@@ -1014,7 +1022,7 @@ var assetTools = [
 ];
 
 // ../core/src/tools/market-summaries.ts
-function record2(value, message) {
+function record3(value, message) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new AiHubError("AI_HUB_OPENAPI_INVALID_RESPONSE", message);
   }
@@ -1092,7 +1100,7 @@ function tickerItem(value) {
 }
 function tickerRows(value) {
   if (Array.isArray(value)) return records(value, "Ticker response must be an array.");
-  const payload = record2(value, "Ticker response must be an array.");
+  const payload = record3(value, "Ticker response must be an array.");
   if (Array.isArray(payload.items)) return records(payload.items, "Ticker response items must be an array.");
   throw new AiHubError("AI_HUB_OPENAPI_INVALID_RESPONSE", "Ticker response must be an array.");
 }
@@ -1107,21 +1115,32 @@ function summarizeTickers(value, options) {
   const bySymbol = new Map(rows2.map((item) => [text(item.symbol)?.toUpperCase(), item]));
   const watchlistSymbols = ["BTC", "ETH", "SOL", "XRP", "DOGE", "BNB", "ADA"];
   const watchlist = watchlistSymbols.map((asset) => bySymbol.get(`${asset}/${quoteAsset}`)).filter((item) => Boolean(item)).map(tickerItem);
-  const limit = options.limit;
+  const watchlistItems = watchlist.slice(0, options.limit);
+  const leaderboardBudget = Math.max(0, options.limit - watchlistItems.length);
+  const leaderboards = [
+    [...rows2].sort(compareByNumericField("rose", "desc")),
+    [...rows2].sort(compareByNumericField("rose", "asc")),
+    [...rows2].sort(compareByNumericField("amount", "desc"))
+  ];
+  const leaderboardLimits = leaderboards.map((_items, index) => Math.floor((leaderboardBudget + 2 - index) / 3));
+  const topGainers = leaderboards[0]?.slice(0, leaderboardLimits[0]).map(tickerItem) ?? [];
+  const topLosers = leaderboards[1]?.slice(0, leaderboardLimits[1]).map(tickerItem) ?? [];
+  const topByQuoteVolume = leaderboards[2]?.slice(0, leaderboardLimits[2]).map(tickerItem) ?? [];
   return {
     quoteAsset,
     totalSymbols: rows2.length,
-    watchlist,
-    topGainers: [...rows2].sort(compareByNumericField("rose", "desc")).slice(0, limit).map(tickerItem),
-    topLosers: [...rows2].sort(compareByNumericField("rose", "asc")).slice(0, limit).map(tickerItem),
-    topByQuoteVolume: [...rows2].sort(compareByNumericField("amount", "desc")).slice(0, limit).map(tickerItem)
+    returnedSymbols: watchlistItems.length + topGainers.length + topLosers.length + topByQuoteVolume.length,
+    watchlist: watchlistItems,
+    topGainers,
+    topLosers,
+    topByQuoteVolume
   };
 }
 function normalizedSymbol(value) {
   return value.replaceAll("/", "").trim().toUpperCase();
 }
 function parsedSymbolRows(value) {
-  const payload = record2(value, "Symbols response must be an object.");
+  const payload = record3(value, "Symbols response must be an object.");
   const rows2 = records(payload.symbols, "Symbols response must contain a symbols array.");
   return rows2.map((item) => {
     const apiSymbol = text(item.symbol);
@@ -1200,6 +1219,18 @@ function listSymbols(value, options) {
     items
   };
 }
+function listFullSymbols(value, options) {
+  const rows2 = sortSymbolMatches(parsedSymbolRows(value));
+  const items = rows2.slice(options.offset, options.offset + options.limit).map(fullSymbolItem);
+  const nextOffset = options.offset + items.length;
+  return {
+    totalSymbols: rows2.length,
+    offset: options.offset,
+    limit: options.limit,
+    nextOffset: nextOffset < rows2.length ? nextOffset : null,
+    items
+  };
+}
 function searchSymbols(value, options) {
   const allRows = parsedSymbolRows(value);
   const query = options.query.trim().toUpperCase();
@@ -1228,7 +1259,7 @@ function level(value) {
   return { price: text(value[0]), quantity: text(value[1]) };
 }
 function summarizeDepth(value, symbol) {
-  const payload = record2(value, "Depth response must be an object.");
+  const payload = record3(value, "Depth response must be an object.");
   const bids = Array.isArray(payload.bids) ? payload.bids : [];
   const asks = Array.isArray(payload.asks) ? payload.asks : [];
   const bestBid = level(bids[0]);
@@ -1249,7 +1280,7 @@ function summarizeDepth(value, symbol) {
   };
 }
 function summarizeTrades(value, symbol) {
-  const payload = record2(value, "Trades response must be an object.");
+  const payload = record3(value, "Trades response must be an object.");
   const rows2 = records(payload.list, "Trades response must contain a list array.");
   let buyCount = 0;
   let sellCount = 0;
@@ -1511,6 +1542,28 @@ async function preflightSymbolOrder(context, order) {
   return rule;
 }
 
+// ../core/src/tools/ticker-summary-cache.ts
+var TICKER_SUMMARY_CACHE_TTL_MS = 3e3;
+var cache2 = /* @__PURE__ */ new Map();
+var pendingLoads2 = /* @__PURE__ */ new Map();
+function cacheKey2(context) {
+  return `${context.profile.name}\0${context.profile.configVersion}\0${context.profile.openApiBaseUrl}`;
+}
+async function getCachedTickerSummarySource(context) {
+  const key = cacheKey2(context);
+  const existing = cache2.get(key);
+  if (existing && existing.expiresAt > Date.now()) return existing.response;
+  const pending = pendingLoads2.get(key);
+  if (pending) return (await pending).response;
+  const load = (async () => {
+    const entry = { response: await context.api.ticker(), expiresAt: Date.now() + TICKER_SUMMARY_CACHE_TTL_MS };
+    cache2.set(key, entry);
+    return entry;
+  })().finally(() => pendingLoads2.delete(key));
+  pendingLoads2.set(key, load);
+  return (await load).response;
+}
+
 // ../core/src/tools/market-tools.ts
 var readErrors = ["AI_HUB_INVALID_ARGUMENT", "AI_HUB_OPENAPI_NETWORK_ERROR", "AI_HUB_OPENAPI_HTTP_ERROR", "AI_HUB_OPENAPI_INVALID_RESPONSE", "AI_HUB_OPENAPI_BUSINESS_ERROR"];
 var symbolReadErrors = [...readErrors, "AI_HUB_SYMBOL_NOT_FOUND"];
@@ -1548,7 +1601,7 @@ function validateKlineInput(input, options) {
     startTime,
     endTime,
     timezone: optionalString(value, "timezone"),
-    limit: optionalInteger(value, "limit", options.summary ? 20 : 50, 1, options.summary ? 100 : 300)
+    limit: normalizedListLimit(value, STANDARD_LIST_LIMIT)
   };
 }
 var marketTools = [
@@ -1586,17 +1639,20 @@ var marketTools = [
   {
     name: "market_get_symbols",
     title: "Get Spot Symbols",
-    description: "Get complete spot symbol metadata from the configured tenant OpenAPI. Use market_get_symbol_overview, market_list_symbols, market_search_symbols, or market_get_symbol_info for Agent-facing symbol requests, because this response may be large.",
+    description: "Get one bounded page of complete spot symbol metadata from the configured tenant OpenAPI.",
     cliPath: ["market", "symbols"],
     module: "spot-common",
     access: "public",
     operation: "read",
     riskLevel: "low",
-    mcpVisible: false,
-    inputSchema: { type: "object", additionalProperties: false },
+    inputSchema: { type: "object", properties: { offset: { type: "integer", minimum: 0, description: "Zero-based page offset. Defaults to 0." }, limit: listLimitSchema(STANDARD_LIST_LIMIT) }, additionalProperties: false },
     errorCodes: readErrors,
-    validate: (input) => strictObject(input, []),
-    handler: (_input, context) => getCachedSymbols(context)
+    listLimit: STANDARD_LIST_LIMIT,
+    validate: (input) => {
+      const value = strictObject(input, ["offset", "limit"]);
+      return { offset: optionalInteger(value, "offset", 0, 0, Number.MAX_SAFE_INTEGER), limit: normalizedListLimit(value, STANDARD_LIST_LIMIT) };
+    },
+    handler: async (input, context) => listFullSymbols(await getCachedSymbols(context), input)
   },
   {
     name: "market_get_symbol_overview",
@@ -1607,11 +1663,12 @@ var marketTools = [
     access: "public",
     operation: "read",
     riskLevel: "low",
-    inputSchema: { type: "object", properties: { limit: { type: "integer", minimum: 1, maximum: 20, description: "Number of sample display symbols. Defaults to 12." } }, additionalProperties: false },
+    inputSchema: { type: "object", properties: { limit: listLimitSchema(STANDARD_LIST_LIMIT, "Number of sample display symbols. Defaults to 20; maximum 50.") }, additionalProperties: false },
     errorCodes: readErrors,
+    listLimit: STANDARD_LIST_LIMIT,
     validate: (input) => {
       const value = strictObject(input, ["limit"]);
-      return { limit: optionalInteger(value, "limit", 12, 1, 20) };
+      return { limit: normalizedListLimit(value, STANDARD_LIST_LIMIT) };
     },
     handler: async (input, context) => summarizeSymbolOverview(await getCachedSymbols(context), input)
   },
@@ -1624,14 +1681,15 @@ var marketTools = [
     access: "public",
     operation: "read",
     riskLevel: "low",
-    inputSchema: { type: "object", properties: { quoteAsset: { type: "string" }, offset: { type: "integer", minimum: 0, description: "Zero-based page offset. Defaults to 0." }, limit: { type: "integer", minimum: 1, maximum: 50, description: "Page size. Defaults to 20." } }, additionalProperties: false },
+    inputSchema: { type: "object", properties: { quoteAsset: { type: "string" }, offset: { type: "integer", minimum: 0, description: "Zero-based page offset. Defaults to 0." }, limit: listLimitSchema(STANDARD_LIST_LIMIT) }, additionalProperties: false },
     errorCodes: readErrors,
+    listLimit: STANDARD_LIST_LIMIT,
     validate: (input) => {
       const value = strictObject(input, ["quoteAsset", "offset", "limit"]);
       return {
         quoteAsset: optionalString(value, "quoteAsset"),
         offset: optionalInteger(value, "offset", 0, 0, Number.MAX_SAFE_INTEGER),
-        limit: optionalInteger(value, "limit", 20, 1, 50)
+        limit: normalizedListLimit(value, STANDARD_LIST_LIMIT)
       };
     },
     handler: async (input, context) => listSymbols(await getCachedSymbols(context), input)
@@ -1645,11 +1703,12 @@ var marketTools = [
     access: "public",
     operation: "read",
     riskLevel: "low",
-    inputSchema: { type: "object", properties: { query: { type: "string", minLength: 1, description: "Required asset or symbol keyword, for example BTC." }, quoteAsset: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 20 } }, required: ["query"], additionalProperties: false },
+    inputSchema: { type: "object", properties: { query: { type: "string", minLength: 1, description: "Required asset or symbol keyword, for example BTC." }, quoteAsset: { type: "string" }, limit: listLimitSchema(STANDARD_LIST_LIMIT) }, required: ["query"], additionalProperties: false },
     errorCodes: readErrors,
+    listLimit: STANDARD_LIST_LIMIT,
     validate: (input) => {
       const value = strictObject(input, ["query", "quoteAsset", "limit"]);
-      return { query: requiredString(value, "query"), quoteAsset: optionalString(value, "quoteAsset"), limit: optionalInteger(value, "limit", 10, 1, 20) };
+      return { query: requiredString(value, "query"), quoteAsset: optionalString(value, "quoteAsset"), limit: normalizedListLimit(value, STANDARD_LIST_LIMIT) };
     },
     handler: async (input, context) => {
       const value = input;
@@ -1684,7 +1743,7 @@ var marketTools = [
     riskLevel: "low",
     inputSchema: {
       type: "object",
-      properties: { symbol: { type: "string", minLength: 1, description: "One exact symbol, for example ETHUSDT." }, symbols: { type: "string", minLength: 1, description: "An explicitly requested upstream symbol list." }, timeZone: { type: "string" } },
+      properties: { symbol: { type: "string", minLength: 1, description: "One exact symbol, for example ETHUSDT." }, symbols: { type: "string", minLength: 1, description: "An explicitly requested comma-separated upstream symbol list of at most 50 symbols." }, timeZone: { type: "string" } },
       oneOf: [{ required: ["symbol"] }, { required: ["symbols"] }],
       additionalProperties: false
     },
@@ -1695,6 +1754,7 @@ var marketTools = [
       const symbols = optionalString(value, "symbols");
       if (!symbol && !symbols) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "market_get_ticker requires symbol or symbols. Use market_get_ticker_summary for all-market data.");
       if (symbol && symbols) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "market_get_ticker accepts either symbol or symbols, not both.");
+      if (symbols && symbols.split(",").map((item) => item.trim()).filter(Boolean).length > STANDARD_LIST_LIMIT.maximum) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `symbols supports at most ${STANDARD_LIST_LIMIT.maximum} explicit symbols.`);
       return { symbol, symbols, timeZone: optionalString(value, "timeZone") };
     },
     handler: (input, context) => context.api.ticker(input)
@@ -1708,15 +1768,16 @@ var marketTools = [
     access: "public",
     operation: "read",
     riskLevel: "low",
-    inputSchema: { type: "object", properties: { quoteAsset: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 20 } }, additionalProperties: false },
+    inputSchema: { type: "object", properties: { quoteAsset: { type: "string" }, limit: listLimitSchema(STANDARD_LIST_LIMIT) }, additionalProperties: false },
     errorCodes: readErrors,
+    listLimit: STANDARD_LIST_LIMIT,
     validate: (input) => {
       const value = strictObject(input, ["quoteAsset", "limit"]);
-      return { quoteAsset: optionalString(value, "quoteAsset") ?? "USDT", limit: optionalInteger(value, "limit", 5, 1, 20) };
+      return { quoteAsset: optionalString(value, "quoteAsset") ?? "USDT", limit: normalizedListLimit(value, STANDARD_LIST_LIMIT) };
     },
     handler: async (input, context) => {
       const value = input;
-      return summarizeTickers(await context.api.ticker(), value);
+      return summarizeTickers(await getCachedTickerSummarySource(context), value);
     }
   },
   {
@@ -1728,12 +1789,12 @@ var marketTools = [
     access: "public",
     operation: "read",
     riskLevel: "low",
-    mcpVisible: false,
-    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 100 } }, required: ["symbol"], additionalProperties: false },
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: listLimitSchema(STANDARD_LIST_LIMIT) }, required: ["symbol"], additionalProperties: false },
     errorCodes: readErrors,
+    listLimit: STANDARD_LIST_LIMIT,
     validate: (input) => {
       const value = strictObject(input, ["symbol", "limit"]);
-      return { symbol: requiredString(value, "symbol"), limit: optionalInteger(value, "limit", 20, 1, 100) };
+      return { symbol: requiredString(value, "symbol"), limit: normalizedListLimit(value, STANDARD_LIST_LIMIT) };
     },
     handler: (input, context) => {
       const value = input;
@@ -1749,11 +1810,12 @@ var marketTools = [
     access: "public",
     operation: "read",
     riskLevel: "low",
-    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 20 } }, required: ["symbol"], additionalProperties: false },
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: listLimitSchema(STANDARD_LIST_LIMIT) }, required: ["symbol"], additionalProperties: false },
     errorCodes: readErrors,
+    listLimit: STANDARD_LIST_LIMIT,
     validate: (input) => {
       const value = strictObject(input, ["symbol", "limit"]);
-      return { symbol: requiredString(value, "symbol"), limit: optionalInteger(value, "limit", 10, 1, 20) };
+      return { symbol: requiredString(value, "symbol"), limit: normalizedListLimit(value, STANDARD_LIST_LIMIT) };
     },
     handler: async (input, context) => {
       const value = input;
@@ -1769,12 +1831,12 @@ var marketTools = [
     access: "public",
     operation: "read",
     riskLevel: "low",
-    mcpVisible: false,
-    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 100 } }, required: ["symbol"], additionalProperties: false },
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: listLimitSchema(STANDARD_LIST_LIMIT) }, required: ["symbol"], additionalProperties: false },
     errorCodes: readErrors,
+    listLimit: STANDARD_LIST_LIMIT,
     validate: (input) => {
       const value = strictObject(input, ["symbol", "limit"]);
-      return { symbol: requiredString(value, "symbol"), limit: optionalInteger(value, "limit", 20, 1, 100) };
+      return { symbol: requiredString(value, "symbol"), limit: normalizedListLimit(value, STANDARD_LIST_LIMIT) };
     },
     handler: (input, context) => {
       const value = input;
@@ -1790,11 +1852,12 @@ var marketTools = [
     access: "public",
     operation: "read",
     riskLevel: "low",
-    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 50 } }, required: ["symbol"], additionalProperties: false },
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: listLimitSchema(STANDARD_LIST_LIMIT) }, required: ["symbol"], additionalProperties: false },
     errorCodes: readErrors,
+    listLimit: STANDARD_LIST_LIMIT,
     validate: (input) => {
       const value = strictObject(input, ["symbol", "limit"]);
-      return { symbol: requiredString(value, "symbol"), limit: optionalInteger(value, "limit", 20, 1, 50) };
+      return { symbol: requiredString(value, "symbol"), limit: normalizedListLimit(value, STANDARD_LIST_LIMIT) };
     },
     handler: async (input, context) => {
       const value = input;
@@ -1810,9 +1873,9 @@ var marketTools = [
     access: "public",
     operation: "read",
     riskLevel: "low",
-    mcpVisible: false,
-    inputSchema: { type: "object", properties: { symbol: { type: "string", description: "Spot symbol, for example ETHUSDT or ETH/USDT." }, interval: { type: "string", enum: KLINE_INTERVALS, description: klineIntervalDescription }, startTime: { type: "integer", description: "Optional inclusive Unix timestamp in milliseconds." }, endTime: { type: "integer", description: "Optional inclusive Unix timestamp in milliseconds." }, timezone: { type: "string", description: klineTimezoneDescription }, limit: { type: "integer", minimum: 1, maximum: 300, description: "Number of newest-first candles. The upstream maximum is 300." } }, required: ["symbol", "interval"], additionalProperties: false },
+    inputSchema: { type: "object", properties: { symbol: { type: "string", description: "Spot symbol, for example ETHUSDT or ETH/USDT." }, interval: { type: "string", enum: KLINE_INTERVALS, description: klineIntervalDescription }, startTime: { type: "integer", description: "Optional inclusive Unix timestamp in milliseconds." }, endTime: { type: "integer", description: "Optional inclusive Unix timestamp in milliseconds." }, timezone: { type: "string", description: klineTimezoneDescription }, limit: listLimitSchema(STANDARD_LIST_LIMIT, "Number of newest-first candles. Defaults to 20; maximum 50.") }, required: ["symbol", "interval"], additionalProperties: false },
     errorCodes: readErrors,
+    listLimit: STANDARD_LIST_LIMIT,
     validate: (input) => {
       return validateKlineInput(input, { summary: false });
     },
@@ -1827,8 +1890,9 @@ var marketTools = [
     access: "public",
     operation: "read",
     riskLevel: "low",
-    inputSchema: { type: "object", properties: { symbol: { type: "string", description: "Spot symbol, for example ETHUSDT or ETH/USDT." }, interval: { type: "string", enum: KLINE_INTERVALS, description: `${klineIntervalDescription} Defaults to 60min when omitted.` }, startTime: { type: "integer", description: "Optional inclusive Unix timestamp in milliseconds." }, endTime: { type: "integer", description: "Optional inclusive Unix timestamp in milliseconds." }, timezone: { type: "string", description: klineTimezoneDescription }, limit: { type: "integer", minimum: 1, maximum: 100, description: "Number of candles included in the bounded analysis." } }, required: ["symbol"], additionalProperties: false },
+    inputSchema: { type: "object", properties: { symbol: { type: "string", description: "Spot symbol, for example ETHUSDT or ETH/USDT." }, interval: { type: "string", enum: KLINE_INTERVALS, description: `${klineIntervalDescription} Defaults to 60min when omitted.` }, startTime: { type: "integer", description: "Optional inclusive Unix timestamp in milliseconds." }, endTime: { type: "integer", description: "Optional inclusive Unix timestamp in milliseconds." }, timezone: { type: "string", description: klineTimezoneDescription }, limit: listLimitSchema(STANDARD_LIST_LIMIT, "Number of candles included in the bounded analysis. Defaults to 20; maximum 50.") }, required: ["symbol"], additionalProperties: false },
     errorCodes: readErrors,
+    listLimit: STANDARD_LIST_LIMIT,
     validate: (input) => {
       return validateKlineInput(input, { summary: true });
     },
@@ -1910,11 +1974,11 @@ function validateMarginOrderLookup(input) {
 }
 function validateMarginOpenOrders(input) {
   const value = strictObject(input, ["symbol", "limit", "isolated"]);
-  return { ...optionalString(value, "symbol") ? { symbol: optionalString(value, "symbol") } : {}, limit: optionalPositiveInteger(value, "limit", 100, 1e3), ...optionalBoolean(value, "isolated") !== void 0 ? { isolated: optionalBoolean(value, "isolated") } : {} };
+  return { ...optionalString(value, "symbol") ? { symbol: optionalString(value, "symbol") } : {}, limit: normalizedListLimit(value, STANDARD_LIST_LIMIT), ...optionalBoolean(value, "isolated") !== void 0 ? { isolated: optionalBoolean(value, "isolated") } : {} };
 }
 function validateMarginTrades(input) {
   const value = strictObject(input, ["symbol", "limit", "fromId"]);
-  return { symbol: requiredString(value, "symbol"), limit: optionalPositiveInteger(value, "limit", 100, 1e3), ...optionalString(value, "fromId") ? { fromId: optionalString(value, "fromId") } : {} };
+  return { symbol: requiredString(value, "symbol"), limit: normalizedListLimit(value, STANDARD_LIST_LIMIT), ...optionalString(value, "fromId") ? { fromId: optionalString(value, "fromId") } : {} };
 }
 var marginTools = [
   {
@@ -1940,8 +2004,9 @@ var marginTools = [
     access: "signed",
     operation: "read",
     riskLevel: "low",
-    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 1e3 }, isolated: { type: "boolean" } }, additionalProperties: false },
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: listLimitSchema(STANDARD_LIST_LIMIT), isolated: { type: "boolean" } }, additionalProperties: false },
     errorCodes: signedReadErrors,
+    listLimit: STANDARD_LIST_LIMIT,
     validate: validateMarginOpenOrders,
     handler: (input, context) => context.api.signedGet("/sapi/v2/margin/openOrders", input, signed(context))
   },
@@ -1954,8 +2019,9 @@ var marginTools = [
     access: "signed",
     operation: "read",
     riskLevel: "low",
-    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 1e3 }, fromId: { type: "string" } }, required: ["symbol"], additionalProperties: false },
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: listLimitSchema(STANDARD_LIST_LIMIT), fromId: { type: "string" } }, required: ["symbol"], additionalProperties: false },
     errorCodes: signedReadErrors,
+    listLimit: STANDARD_LIST_LIMIT,
     validate: validateMarginTrades,
     handler: (input, context) => context.api.signedGet("/sapi/v2/margin/myTrades", input, signed(context))
   },
@@ -2306,11 +2372,12 @@ var orderTools = [
     access: "signed",
     operation: "read",
     riskLevel: "low",
-    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 1e3 } }, additionalProperties: false },
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: listLimitSchema(STANDARD_LIST_LIMIT) }, additionalProperties: false },
     errorCodes: signedReadErrors2,
+    listLimit: STANDARD_LIST_LIMIT,
     validate: (input) => {
       const value = strictObject(input, ["symbol", "limit"]);
-      return { symbol: optionalString(value, "symbol"), limit: optionalInteger(value, "limit", 100, 1, 1e3) };
+      return { symbol: optionalString(value, "symbol"), limit: normalizedListLimit(value, STANDARD_LIST_LIMIT) };
     },
     handler: (input, context) => context.api.getOpenOrders(input, signed2(context))
   },
@@ -2323,11 +2390,12 @@ var orderTools = [
     access: "signed",
     operation: "read",
     riskLevel: "low",
-    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 1e3 }, fromId: { type: "string" } }, required: ["symbol"], additionalProperties: false },
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: listLimitSchema(STANDARD_LIST_LIMIT), fromId: { type: "string" } }, required: ["symbol"], additionalProperties: false },
     errorCodes: signedReadErrors2,
+    listLimit: STANDARD_LIST_LIMIT,
     validate: (input) => {
       const value = strictObject(input, ["symbol", "limit", "fromId"]);
-      return { symbol: requiredString(value, "symbol"), limit: optionalInteger(value, "limit", 100, 1, 1e3), fromId: optionalString(value, "fromId") };
+      return { symbol: requiredString(value, "symbol"), limit: normalizedListLimit(value, STANDARD_LIST_LIMIT), fromId: optionalString(value, "fromId") };
     },
     handler: (input, context) => context.api.getMyTrades(input, signed2(context))
   },
@@ -2424,7 +2492,7 @@ function fields(input, allowed, required = []) {
   return result2;
 }
 function pages(value) {
-  return { page: optionalPositiveInteger(value, "page", 1), pageSize: optionalPositiveInteger(value, "pageSize", 20, 100) };
+  return { page: optionalPositiveInteger(value, "page", 1), pageSize: normalizedListLimit(value, STANDARD_PAGE_SIZE) };
 }
 function transfer(value, requireSubUid) {
   const result2 = { coinSymbol: requiredString(value, "coinSymbol"), amount: positiveDecimal(value, "amount") };
@@ -2443,6 +2511,7 @@ var subAccountTools = [
     riskLevel: "low",
     inputSchema: { type: "object", additionalProperties: false },
     errorCodes: signedReadErrors,
+    unpagedListLimit: { path: ["data", "subUserList"] },
     validate: (input) => {
       strictObject(input, []);
       return {};
@@ -2498,6 +2567,7 @@ var subAccountTools = [
     riskLevel: "low",
     inputSchema: { type: "object", properties: { subUid: { type: "string" } }, required: ["subUid"], additionalProperties: false },
     errorCodes: signedReadErrors,
+    unpagedListLimit: { path: ["data", "apiList"] },
     validate: (input) => fields(input, ["subUid"], ["subUid"]),
     handler: (input, context) => context.api.signedPost("/sapi/v1/sub_user/sub_account_api/list", input, signed(context))
   },
@@ -2547,6 +2617,7 @@ var subAccountTools = [
     riskLevel: "low",
     inputSchema: { type: "object", properties: { subUid: { type: "string" }, accountType: { type: "string" }, type: { type: "string" } }, required: ["subUid", "accountType"], additionalProperties: false },
     errorCodes: signedReadErrors,
+    unpagedListLimit: { path: ["data", "accountList"] },
     validate: (input) => fields(input, ["subUid", "accountType", "type"], ["subUid", "accountType"]),
     handler: (input, context) => context.api.signedPost("/sapi/v1/sub_user/asset/account", input, signed(context))
   },
@@ -2577,8 +2648,9 @@ var subAccountTools = [
     access: "signed",
     operation: "read",
     riskLevel: "low",
-    inputSchema: { type: "object", properties: { subUid: { type: "string" }, coinSymbol: { type: "string" }, page: { type: "integer" }, pageSize: { type: "integer" } }, required: ["subUid", "coinSymbol"], additionalProperties: false },
+    inputSchema: { type: "object", properties: { subUid: { type: "string" }, coinSymbol: { type: "string" }, page: { type: "integer", minimum: 1 }, pageSize: listLimitSchema(STANDARD_PAGE_SIZE) }, required: ["subUid", "coinSymbol"], additionalProperties: false },
     errorCodes: signedReadErrors,
+    listLimit: STANDARD_PAGE_SIZE,
     validate: (input) => {
       const value = strictObject(input, ["subUid", "coinSymbol", "page", "pageSize"]);
       return { subUid: requiredString(value, "subUid"), coinSymbol: requiredString(value, "coinSymbol"), ...pages(value) };
@@ -2612,62 +2684,37 @@ var subAccountTools = [
     access: "signed",
     operation: "read",
     riskLevel: "low",
-    inputSchema: { type: "object", properties: { subUid: { type: "string" }, type: { type: "string" }, accountType: { type: "string" }, coinSymbol: { type: "string" }, page: { type: "integer" }, pageSize: { type: "integer" } }, required: ["subUid", "type", "accountType", "coinSymbol"], additionalProperties: false },
+    inputSchema: { type: "object", properties: { subUid: { type: "string" }, type: { type: "string" }, accountType: { type: "string" }, coinSymbol: { type: "string" }, page: { type: "integer", minimum: 1 }, pageSize: listLimitSchema(STANDARD_PAGE_SIZE) }, required: ["subUid", "type", "accountType", "coinSymbol"], additionalProperties: false },
     errorCodes: signedReadErrors,
+    listLimit: STANDARD_PAGE_SIZE,
     validate: (input) => {
       const value = strictObject(input, ["subUid", "type", "accountType", "coinSymbol", "page", "pageSize"]);
       return { subUid: requiredString(value, "subUid"), type: requiredString(value, "type"), accountType: requiredString(value, "accountType"), coinSymbol: requiredString(value, "coinSymbol"), ...pages(value) };
     },
     handler: (input, context) => context.api.signedPost("/sapi/v1/sub_user/asset/transfer_query", input, signed(context))
-  },
-  {
-    name: "sub_account_transfer_to_parent",
-    title: "Transfer From Sub-account to Parent",
-    description: "Transfer assets to the parent account after confirmation.",
-    cliPath: ["sub-account", "transfer-to-parent"],
-    module: "spot-sub-account",
-    access: "signed",
-    operation: "write",
-    riskLevel: "high",
-    inputSchema: { type: "object", properties: { coinSymbol: { type: "string" }, amount: { type: "string" } }, required: ["coinSymbol", "amount"], additionalProperties: false },
-    errorCodes: writeErrors,
-    validate: (input) => {
-      const value = strictObject(input, ["coinSymbol", "amount"]);
-      return transfer(value, false);
-    },
-    handler: (input, context) => context.api.signedPost("/sapi/v1/asset/subaccount/transfer", input, signed(context)),
-    writeSummary: (input) => ({ action: "sub_account_transfer_to_parent", ...input })
-  },
-  {
-    name: "sub_account_get_parent_transfer_history",
-    title: "Get Parent Transfer History",
-    description: "Query transfers between this sub-account and its parent.",
-    cliPath: ["sub-account", "parent-transfer-history"],
-    module: "spot-sub-account",
-    access: "signed",
-    operation: "read",
-    riskLevel: "low",
-    inputSchema: { type: "object", properties: { coinSymbol: { type: "string" }, page: { type: "integer" }, pageSize: { type: "integer" } }, required: ["coinSymbol"], additionalProperties: false },
-    errorCodes: signedReadErrors,
-    validate: (input) => {
-      const value = strictObject(input, ["coinSymbol", "page", "pageSize"]);
-      return { coinSymbol: requiredString(value, "coinSymbol"), ...pages(value) };
-    },
-    handler: (input, context) => context.api.signedPost("/sapi/v1/asset/subaccount/transfer_query", input, signed(context))
   }
 ];
 
 // ../core/src/tools/tool-registry.ts
 var allTools = [...marketTools, ...accountTools, ...orderTools, ...marginTools, ...assetTools, ...subAccountTools];
+function assertListLimitSchema(tool) {
+  const limit = tool.listLimit;
+  if (!limit) return;
+  const property = tool.inputSchema.properties?.[limit.field];
+  if (!property || property.type !== "integer" || property.minimum !== 1 || property.maximum !== limit.maximum) {
+    throw new AiHubError("AI_HUB_TOOL_LIST_LIMIT_INVALID", `Tool "${tool.name}" must expose its declared ${limit.field} range in inputSchema.`);
+  }
+}
 var ToolRegistry = class {
   toolsByName = /* @__PURE__ */ new Map();
   toolsByCliPath = /* @__PURE__ */ new Map();
   constructor(tools = allTools) {
-    for (const tool of tools) {
+    for (const tool of tools.map(withListLimit)) {
       const path2 = tool.cliPath.join(" ");
       if (this.toolsByName.has(tool.name) || this.toolsByCliPath.has(path2)) {
         throw new AiHubError("AI_HUB_TOOL_DUPLICATE", `Duplicate tool registration: ${tool.name}.`);
       }
+      assertListLimitSchema(tool);
       this.toolsByName.set(tool.name, tool);
       this.toolsByCliPath.set(path2, tool);
     }
@@ -2693,7 +2740,8 @@ var ToolRegistry = class {
     const tool = this.byName(name, options);
     if (tool.operation === "write") throw new AiHubError("AI_HUB_WRITE_CONFIRMATION_REQUIRED", `Tool "${name}" must be executed through confirmation.`);
     const validInput = tool.validate(input);
-    return tool.handler(validInput, context);
+    const response = await tool.handler(validInput, context);
+    return tool.unpagedListLimit ? truncateUnpagedListResponse(response, tool.unpagedListLimit, validInput) : response;
   }
   async prepareWrite(name, input, context, confirmations) {
     const tool = this.byName(name);
@@ -2722,8 +2770,8 @@ var ToolRegistry = class {
     }));
   }
 };
-function createToolRegistry() {
-  return new ToolRegistry();
+function createToolRegistry(tools) {
+  return new ToolRegistry(tools);
 }
 
 // ../core/src/tools/write-executor.ts
@@ -2750,6 +2798,53 @@ var ToolWriteExecutor = class {
   }
 };
 
+// ../core/src/tools/mcp-toolset.ts
+var MCP_TOOLSETS = ["default", "full"];
+var DEFAULT_MCP_TOOLSET = "default";
+var DEFAULT_MCP_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "market_get_symbol_overview",
+  "market_list_symbols",
+  "market_search_symbols",
+  "market_get_symbol_info",
+  "market_get_depth_summary",
+  "market_get_ticker",
+  "market_get_ticker_summary",
+  "market_get_trades_summary",
+  "market_get_klines_summary",
+  "spot_get_order",
+  "spot_batch_place_orders",
+  "spot_batch_cancel_orders",
+  "spot_get_open_orders",
+  "spot_get_fills",
+  "spot_market_buy",
+  "spot_market_sell",
+  "spot_limit_order",
+  "spot_cancel_order",
+  "wallet_universal_transfer",
+  "wallet_get_universal_transfer_history",
+  "wallet_get_deposit_history",
+  "wallet_get_deposit_address",
+  "wallet_get_withdraw_address",
+  "wallet_get_transferable_assets"
+]);
+function parseMcpToolset(value) {
+  if (value === void 0) return DEFAULT_MCP_TOOLSET;
+  if (MCP_TOOLSETS.includes(value)) return value;
+  throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `--toolset must be one of: ${MCP_TOOLSETS.join(", ")}.`);
+}
+function selectMcpToolset(tools, toolset) {
+  return toolset === "full" ? [...tools] : tools.filter((tool) => DEFAULT_MCP_TOOL_NAMES.has(tool.name));
+}
+
+// ../core/src/mcp-response-mode.ts
+var MCP_RESPONSE_MODES = ["compact", "compat"];
+var DEFAULT_MCP_RESPONSE_MODE = "compact";
+function parseMcpResponseMode(value) {
+  if (value === void 0) return DEFAULT_MCP_RESPONSE_MODE;
+  if (MCP_RESPONSE_MODES.includes(value)) return value;
+  throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `--response-mode must be one of: ${MCP_RESPONSE_MODES.join(", ")}.`);
+}
+
 // ../core/src/setup.ts
 import { execFileSync } from "child_process";
 import * as fs from "fs";
@@ -2760,7 +2855,8 @@ var MCP_CLIENT_NAMES = {
   cursor: "Cursor",
   "claude-desktop": "Claude Desktop",
   "claude-code": "Claude Code",
-  codex: "Codex"
+  codex: "Codex",
+  openclaw: "OpenClaw"
 };
 var SUPPORTED_MCP_CLIENTS = Object.keys(MCP_CLIENT_NAMES);
 function runtime() {
@@ -2795,21 +2891,23 @@ function findMicrosoftStoreClaudePath(value, home) {
     return void 0;
   }
 }
-function getMcpClientConfigPath(client, value = runtime()) {
-  if (client === "cursor") return path.join(value.home, ".cursor", "mcp.json");
+function getMcpClientConfigPaths(client, value = runtime()) {
+  if (client === "cursor") return [path.join(value.home, ".cursor", "mcp.json")];
   if (value.platform === "win32") {
-    return findMicrosoftStoreClaudePath(value.localAppData, value.home) ?? path.join(windowsAppData(value.appData, value.home), "Claude", "claude_desktop_config.json");
+    return [findMicrosoftStoreClaudePath(value.localAppData, value.home) ?? path.join(windowsAppData(value.appData, value.home), "Claude", "claude_desktop_config.json")];
   }
   if (value.platform === "darwin") {
-    return path.join(value.home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    const legacyPath = path.join(value.home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    const modernPath = path.join(value.home, "Library", "Application Support", "Claude-3p", "claude_desktop_config.json");
+    return fs.existsSync(modernPath) ? [legacyPath, modernPath] : [legacyPath];
   }
-  return path.join(value.xdgConfigHome ?? path.join(value.home, ".config"), "Claude", "claude_desktop_config.json");
+  return [path.join(value.xdgConfigHome ?? path.join(value.home, ".config"), "Claude", "claude_desktop_config.json")];
 }
-function buildServerSpec(profile, launch) {
+function buildServerSpec(profile, toolset, responseMode, launch) {
   return {
     name: serverName(profile),
     command: launch.command,
-    args: [...launch.args, ...profile ? ["--profile", profile] : []]
+    args: [...launch.args, ...profile ? ["--profile", profile] : [], "--toolset", toolset, "--response-mode", responseMode]
   };
 }
 function serverName(profile) {
@@ -2869,8 +2967,9 @@ function jsonFileAdapter(id) {
     id,
     name: MCP_CLIENT_NAMES[id],
     install(server, value) {
-      mergeJsonMcpConfig(getMcpClientConfigPath(id, value), server);
-      process.stdout.write(`Configured ${this.name}: ${getMcpClientConfigPath(id, value)}
+      const configPaths = getMcpClientConfigPaths(id, value);
+      for (const configPath of configPaths) mergeJsonMcpConfig(configPath, server);
+      process.stdout.write(`Configured ${this.name}: ${configPaths.join(", ")}
 Restart ${this.name} to apply changes.
 `);
     }
@@ -2897,11 +2996,33 @@ function cliAdapter(id) {
     }
   };
 }
+function openClawAdapter() {
+  return {
+    id: "openclaw",
+    name: MCP_CLIENT_NAMES.openclaw,
+    install(server, value) {
+      const args = [
+        "mcp",
+        "add",
+        server.name,
+        "--command",
+        server.command,
+        ...server.args.flatMap((argument) => ["--arg", argument])
+      ];
+      executeClientRegistration("openclaw", args, value);
+      process.stdout.write(
+        `Configured ${this.name} with local stdio MCP server "${server.name}". Run \`openclaw mcp doctor ${server.name} --probe\` to verify it.
+`
+      );
+    }
+  };
+}
 var MCP_CLIENT_ADAPTERS = {
   cursor: jsonFileAdapter("cursor"),
   "claude-desktop": jsonFileAdapter("claude-desktop"),
   "claude-code": cliAdapter("claude-code"),
-  codex: cliAdapter("codex")
+  codex: cliAdapter("codex"),
+  openclaw: openClawAdapter()
 };
 function runMcpSetup(options, value = runtime()) {
   const adapter = MCP_CLIENT_ADAPTERS[options.client];
@@ -2909,11 +3030,13 @@ function runMcpSetup(options, value = runtime()) {
     throw new Error(`Unknown MCP client "${options.client}". Supported clients: ${SUPPORTED_MCP_CLIENTS.join(", ")}.`);
   }
   const profile = options.profile ? validateProfileName(options.profile) : void 0;
-  adapter.install(buildServerSpec(profile, options.launch), value);
+  const toolset = parseMcpToolset(options.toolset ?? DEFAULT_MCP_TOOLSET);
+  const responseMode = parseMcpResponseMode(options.responseMode ?? DEFAULT_MCP_RESPONSE_MODE);
+  adapter.install(buildServerSpec(profile, toolset, responseMode, options.launch), value);
 }
 function printMcpSetupUsage() {
   process.stdout.write(
-    `Usage: ${MCP_BINARY} setup --client <client> [--profile <name>]
+    `Usage: ${MCP_BINARY} setup --client <client> [--profile <name>] [--toolset <default|full>] [--response-mode <compact|compat>]
 
 Supported clients:
 ` + SUPPORTED_MCP_CLIENTS.map((client) => `  ${client.padEnd(16)} ${MCP_CLIENT_NAMES[client]}`).join("\n") + "\n"
@@ -2945,9 +3068,37 @@ var READ_RESULT_OUTPUT_SCHEMA = {
 function result(data) {
   return { content: [{ type: "text", text: JSON.stringify(data) }] };
 }
-function toMcpReadResult(data) {
+function numberField(value, ...names) {
+  for (const name of names) {
+    const candidate = value[name];
+    if (typeof candidate === "number" && Number.isFinite(candidate)) return candidate;
+  }
+  return void 0;
+}
+function compactReadText(data) {
+  const envelope = data;
+  const dataType = typeof envelope?.dataType === "string" ? envelope.dataType : "unknown";
+  const compact = { dataType };
+  if (typeof envelope?.count === "number") compact.count = envelope.count;
+  if (dataType === "object" && envelope.value && typeof envelope.value === "object" && !Array.isArray(envelope.value)) {
+    const value = envelope.value;
+    const items = Array.isArray(value.items) ? value.items : void 0;
+    const returnedCount = numberField(value, "returnedCount", "returnedSymbols") ?? items?.length;
+    const totalCount = numberField(value, "totalCount", "totalSymbols", "matchedSymbols");
+    if (returnedCount !== void 0) compact.returnedCount = returnedCount;
+    if (totalCount !== void 0) compact.totalCount = totalCount;
+    if (typeof value.nextOffset === "number" || value.nextOffset === null) compact.nextOffset = value.nextOffset;
+    if (value.truncated === true) compact.truncated = true;
+  }
+  compact.summary = "Full result is available in structuredContent.";
+  return JSON.stringify({ ok: true, data: compact });
+}
+function toMcpReadResult(data, responseMode = DEFAULT_MCP_RESPONSE_MODE) {
   const payload = { ok: true, data };
-  return { content: [{ type: "text", text: JSON.stringify(payload) }], structuredContent: payload };
+  return {
+    content: [{ type: "text", text: responseMode === "compat" ? JSON.stringify(payload) : compactReadText(data) }],
+    structuredContent: payload
+  };
 }
 function formatMcpData(data) {
   if (Array.isArray(data)) {
@@ -2980,9 +3131,6 @@ function toMcpTool(tool) {
     }
   };
 }
-function isMcpVisible(tool) {
-  return tool.mcpVisible !== false;
-}
 function prepareToolName(tool) {
   const [prefix, ...rest] = tool.name.split("_");
   return `${prefix ?? "spot"}_prepare_${rest.join("_")}`;
@@ -2996,8 +3144,9 @@ function toPrepareMcpTool(tool) {
     annotations: { readOnlyHint: false, destructiveHint: tool.riskLevel === "high", idempotentHint: true, openWorldHint: false }
   };
 }
-function createServer(profileName, readOnly) {
-  const registry = createToolRegistry();
+function createServer(profileName, readOnly, toolset = DEFAULT_MCP_TOOLSET, responseMode = DEFAULT_MCP_RESPONSE_MODE) {
+  const allTools2 = createToolRegistry();
+  const registry = createToolRegistry(selectMcpToolset(allTools2.list(), toolset));
   const writeExecutor = new ToolWriteExecutor(registry);
   const server = new Server(
     { name: "ai-hub-agent-trade", version: "0.1.11" },
@@ -3015,7 +3164,7 @@ function createServer(profileName, readOnly) {
         inputSchema: { type: "object", additionalProperties: false },
         annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
       },
-      ...registry.list({ readOnly }).filter(isMcpVisible).flatMap((tool) => tool.operation === "write" ? [toPrepareMcpTool(tool)] : [toMcpTool(tool)]),
+      ...registry.list({ readOnly }).flatMap((tool) => tool.operation === "write" ? [toPrepareMcpTool(tool)] : [toMcpTool(tool)]),
       ...readOnly ? [] : [{
         name: CONFIRM_ACTION_TOOL,
         title: "Confirm Prepared Action",
@@ -3027,40 +3176,41 @@ function createServer(profileName, readOnly) {
   }));
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
-      const context = await createToolExecutionContext(profileName);
       if (request.params.name === CAPABILITIES_TOOL) {
-        const visibleTools = registry.list({ readOnly }).filter(isMcpVisible);
+        const context2 = await createToolExecutionContext(profileName);
+        const visibleTools = registry.list({ readOnly });
         const toolCounts = visibleTools.reduce((counts, tool2) => {
           counts[tool2.operation] = (counts[tool2.operation] ?? 0) + 1;
           return counts;
         }, {});
-        return result({
-          ok: true,
-          data: {
-            profile: { name: context.profile.name, host: new URL(context.profile.openApiBaseUrl).host, configVersion: context.profile.configVersion },
-            readOnly,
-            serviceVersion: "0.1.11",
-            toolCounts
-          }
-        });
+        return toMcpReadResult(formatMcpData({
+          profile: { name: context2.profile.name, host: new URL(context2.profile.openApiBaseUrl).host, configVersion: context2.profile.configVersion },
+          toolset,
+          responseMode,
+          modules: [...new Set(visibleTools.map((tool2) => tool2.module))].sort(),
+          readOnly,
+          serviceVersion: "0.1.11",
+          toolCounts
+        }), responseMode);
       }
       if (request.params.name === CONFIRM_ACTION_TOOL) {
+        if (readOnly) throw new AiHubError("AI_HUB_TOOL_NOT_AVAILABLE", `Tool "${CONFIRM_ACTION_TOOL}" is not available in this server session.`);
         const input = request.params.arguments ?? {};
         if (typeof input.confirmationId !== "string" || typeof input.userConfirmation !== "string" || !input.userConfirmation.trim()) {
           throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "confirmationId and a non-empty userConfirmation are required.");
         }
-        return result({ ok: true, data: await writeExecutor.confirm(input.confirmationId, input.userConfirmation, context) });
+        const context2 = await createToolExecutionContext(profileName);
+        return result({ ok: true, data: await writeExecutor.confirm(input.confirmationId, input.userConfirmation, context2) });
       }
-      const preparedTool = registry.list({ readOnly: false }).find((tool2) => tool2.operation === "write" && prepareToolName(tool2) === request.params.name);
+      const preparedTool = readOnly ? void 0 : registry.list().find((tool2) => tool2.operation === "write" && prepareToolName(tool2) === request.params.name);
       if (preparedTool) {
-        return result({ ok: true, data: await writeExecutor.prepare(preparedTool.name, request.params.arguments ?? {}, context) });
+        const context2 = await createToolExecutionContext(profileName);
+        return result({ ok: true, data: await writeExecutor.prepare(preparedTool.name, request.params.arguments ?? {}, context2) });
       }
       const tool = registry.byName(request.params.name, { readOnly });
-      if (!isMcpVisible(tool)) {
-        throw new AiHubError("AI_HUB_TOOL_NOT_AVAILABLE", `Tool "${request.params.name}" is not available through MCP. Use the corresponding bounded summary or symbol-browsing tool instead.`);
-      }
+      const context = await createToolExecutionContext(profileName);
       const data = await registry.execute(request.params.name, request.params.arguments ?? {}, context, { readOnly });
-      return toMcpReadResult(formatMcpData(data));
+      return toMcpReadResult(formatMcpData(data), responseMode);
     } catch (error) {
       return toMcpErrorResult(error);
     }
@@ -3078,7 +3228,7 @@ function readOption(args, option) {
 }
 function printUsage() {
   process.stdout.write(
-    "AI Hub Agent Trade MCP\n\nUsage:\n  ai-hub-trade-mcp [--profile <name>] [--read-only]\n  ai-hub-trade-mcp setup --client <client> [--profile <name>]\n\nThe default command starts the local stdio MCP server.\nUse setup to register it with Cursor, Claude Desktop, Claude Code, or Codex.\n"
+    "AI Hub Agent Trade MCP\n\nUsage:\n  ai-hub-trade-mcp [--profile <name>] [--toolset <default|full>] [--response-mode <compact|compat>] [--read-only]\n  ai-hub-trade-mcp setup --client <client> [--profile <name>] [--toolset <default|full>] [--response-mode <compact|compat>]\n\nThe default command starts the local stdio MCP server.\nUse setup to register it with Cursor, Claude Desktop, Claude Code, Codex, or OpenClaw.\n"
   );
 }
 async function main(argv) {
@@ -3089,6 +3239,8 @@ async function main(argv) {
   if (argv[0] === "setup") {
     const client = readOption(argv.slice(1), "--client");
     const profile = readOption(argv.slice(1), "--profile");
+    const toolset2 = parseMcpToolset(readOption(argv.slice(1), "--toolset"));
+    const responseMode2 = parseMcpResponseMode(readOption(argv.slice(1), "--response-mode"));
     if (!client) {
       printMcpSetupUsage();
       return;
@@ -3098,12 +3250,14 @@ async function main(argv) {
     }
     const entrypoint = process.argv[1];
     if (!entrypoint) throw new AiHubError("AI_HUB_UNEXPECTED_ERROR", "Cannot locate the local MCP server entrypoint for client setup.");
-    runMcpSetup({ client, profile, launch: { command: process.execPath, args: [entrypoint] } });
+    runMcpSetup({ client, profile, toolset: toolset2, responseMode: responseMode2, launch: { command: process.execPath, args: [entrypoint] } });
     return;
   }
   const profileName = readOption(argv, "--profile");
   const readOnly = argv.includes("--read-only");
-  const server = createServer(profileName, readOnly);
+  const toolset = parseMcpToolset(readOption(argv, "--toolset"));
+  const responseMode = parseMcpResponseMode(readOption(argv, "--response-mode"));
+  const server = createServer(profileName, readOnly, toolset, responseMode);
   await server.connect(new StdioServerTransport());
 }
 function isDirectExecution() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aihubspot/agent-trade-mcp",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Local stdio MCP server for AI Hub spot trading tools",
   "license": "UNLICENSED",
   "repository": {