@liquiditytech/rapidx-cli 1.0.28 → 1.0.30

package/dist/cli/commands/account.js

@@ -1,4 +1,4 @@
-import { executeRapidXCapability, findCapabilityById, normalizeUnknownError } from "../../core/index.js";
+import { executeRapidXCapability, findCapabilityById, normalizeUnknownError, publicErrorDetails } from "../../core/index.js";
 import { writeCliAudit } from "../audit.js";
 import { fail, ok } from "../envelope.js";
 import { enforceCliPreviewGate } from "./trade-gate.js";
@@ -29,6 +29,6 @@ export async function runAccountCommand(action, input) {
     }
     catch (error) {
         const productError = normalizeUnknownError(error, "RCLI01001");
-        return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx account ${action}`);
+        return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx account ${action}`, publicErrorDetails(productError));
     }
 }

package/dist/cli/commands/algo.js

@@ -1,4 +1,4 @@
-import { executeRapidXCapability, findCapabilityById, normalizeUnknownError } from "../../core/index.js";
+import { executeRapidXCapability, findCapabilityById, normalizeUnknownError, publicErrorDetails } from "../../core/index.js";
 import { writeCliAudit } from "../audit.js";
 import { fail, ok } from "../envelope.js";
 import { enforceCliPreviewGate } from "./trade-gate.js";
@@ -30,6 +30,6 @@ export async function runAlgoCommand(action, input) {
     }
     catch (error) {
         const productError = normalizeUnknownError(error, "RCLI12001");
-        return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx algo ${action}`);
+        return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx algo ${action}`, publicErrorDetails(productError));
     }
 }

package/dist/cli/commands/market.js

@@ -1,4 +1,4 @@
-import { executeRapidXCapability, normalizeUnknownError } from "../../core/index.js";
+import { executeRapidXCapability, normalizeUnknownError, publicErrorDetails } from "../../core/index.js";
 import { ok } from "../envelope.js";
 import { fail } from "../envelope.js";
 const MARKET_CAPABILITY_BY_ACTION = {
@@ -21,6 +21,6 @@ export async function runMarketCommand(action, input) {
     }
     catch (error) {
         const productError = normalizeUnknownError(error, "RCLI12001");
-        return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx market ${action}`);
+        return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx market ${action}`, publicErrorDetails(productError));
     }
 }

package/dist/cli/commands/order.js

@@ -1,4 +1,4 @@
-import { consumePreview, createTargetedTradePreview, createTradePreview, defaultSafetyPolicy, executeRapidXCapability, findCapabilityById, loadPreviewStoreFromFile, makeSafetyState, normalizeUnknownError, resolvePreviewStoreFile, savePreviewStoreToFile, verifyPreview } from "../../core/index.js";
+import { consumePreview, createTargetedTradePreview, createTradePreview, defaultSafetyPolicy, executeRapidXCapability, findCapabilityById, loadPreviewStoreFromFile, makeSafetyState, normalizeUnknownError, publicErrorDetails, resolvePreviewStoreFile, runPreviewPreflight, savePreviewStoreToFile, verifyPreview } from "../../core/index.js";
 import { fail, ok } from "../envelope.js";
 import { writeCliAudit } from "../audit.js";
 const safetyState = makeSafetyState();
@@ -12,12 +12,13 @@ export async function runOrderCommand(action, input) {
         }
         try {
             const preview = createTradePreview(capability, input, { ...defaultSafetyPolicy(), tradingEnabled: true, readOnly: false }, safetyState, previewStore);
+            Object.assign(preview, await runPreviewPreflight("order.place", input));
             savePreviewStoreToFile(previewStoreFile, previewStore);
             return ok(preview, `rapidx order ${action}`);
         }
         catch (error) {
             const productError = normalizeUnknownError(error, "RCLI20002");
-            return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx order ${action}`);
+            return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx order ${action}`, publicErrorDetails(productError));
         }
     }
     const previewTarget = previewTargetForAction(action);
@@ -28,12 +29,13 @@ export async function runOrderCommand(action, input) {
         }
         try {
             const preview = createTargetedTradePreview(targetCapability, input, { ...defaultSafetyPolicy(), tradingEnabled: true, readOnly: false }, safetyState, previewStore);
+            Object.assign(preview, await runPreviewPreflight(previewTarget, input));
             savePreviewStoreToFile(previewStoreFile, previewStore);
             return ok(preview, `rapidx order ${action}`);
         }
         catch (error) {
             const productError = normalizeUnknownError(error, "RCLI20002");
-            return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx order ${action}`);
+            return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx order ${action}`, publicErrorDetails(productError));
         }
     }
     const capability = findCapabilityById(`order.${action}`);
@@ -67,7 +69,7 @@ export async function runOrderCommand(action, input) {
     }
     catch (error) {
         const productError = normalizeUnknownError(error, "RCLI12001");
-        return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx order ${action}`);
+        return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx order ${action}`, publicErrorDetails(productError));
     }
 }
 function previewTargetForAction(action) {

package/dist/cli/commands/position.js

@@ -1,4 +1,4 @@
-import { executeRapidXCapability, findCapabilityById, normalizeUnknownError } from "../../core/index.js";
+import { executeRapidXCapability, findCapabilityById, normalizeUnknownError, publicErrorDetails } from "../../core/index.js";
 import { writeCliAudit } from "../audit.js";
 import { fail, ok } from "../envelope.js";
 import { enforceCliPreviewGate } from "./trade-gate.js";
@@ -30,6 +30,6 @@ export async function runPositionCommand(action, input) {
     }
     catch (error) {
         const productError = normalizeUnknownError(error, "RCLI12001");
-        return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx position ${action}`);
+        return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx position ${action}`, publicErrorDetails(productError));
     }
 }

package/dist/cli/commands/trade.js

@@ -1,4 +1,4 @@
-import { createTargetedTradePreview, defaultSafetyPolicy, findCapabilityById, loadPreviewStoreFromFile, makeSafetyState, normalizeUnknownError, resolvePreviewStoreFile, savePreviewStoreToFile } from "../../core/index.js";
+import { createTargetedTradePreview, defaultSafetyPolicy, findCapabilityById, loadPreviewStoreFromFile, makeSafetyState, normalizeUnknownError, publicErrorDetails, resolvePreviewStoreFile, runPreviewPreflight, savePreviewStoreToFile } from "../../core/index.js";
 import { fail, ok } from "../envelope.js";
 const safetyState = makeSafetyState();
 export async function runTradeCommand(action, input) {
@@ -17,12 +17,13 @@ export async function runTradeCommand(action, input) {
     const previewStore = loadPreviewStoreFromFile(previewStoreFile);
     try {
         const preview = createTargetedTradePreview(targetCapability, input, { ...defaultSafetyPolicy(), tradingEnabled: true, readOnly: false }, safetyState, previewStore);
+        Object.assign(preview, await runPreviewPreflight(targetCapability.capabilityId, input));
         savePreviewStoreToFile(previewStoreFile, previewStore);
         return ok(preview, "rapidx trade preview");
     }
     catch (error) {
         const productError = normalizeUnknownError(error, "RCLI20002");
-        return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, "rapidx trade preview");
+        return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, "rapidx trade preview", publicErrorDetails(productError));
     }
 }
 function isPreviewCapability(capabilityId) {

package/dist/cli/envelope.js

@@ -8,12 +8,13 @@ export function ok(data, evidenceText, status = "PASS", source = "local_check",
         evidence: [makeEvidence(evidenceText, source)]
     };
 }
-export function fail(code, message, status = "FAIL", evidenceText = "rapidx cli") {
+export function fail(code, message, status = "FAIL", evidenceText = "rapidx cli", details) {
     return {
         ok: false,
         status,
         code,
         message,
+        ...(details ? { details } : {}),
         evidence: [makeEvidence(evidenceText)]
     };
 }

package/dist/core/client/capability-executor.js

@@ -1,6 +1,7 @@
 import { ProductError } from "../errors/product-error.js";
 import { parseRapidXSymbol } from "./symbol.js";
 import { RapidXClient } from "./rapid-x-client.js";
+import { assertOrderLookupReference, assertValidOrderId } from "./order-id.js";
 import { findCapabilityById } from "../contracts/capabilities.js";
 import { assertInputMatchesSchema } from "../contracts/input-schema.js";
 export async function executeRapidXCapability(capabilityId, input = {}, options = {}) {
@@ -32,9 +33,9 @@ export async function executeRapidXCapability(capabilityId, input = {}, options
         case "order.amend":
             return client.put("/api/v1/trading/order", orderAmendBody(input));
         case "order.cancel":
-            return client.delete("/api/v1/trading/order", orderCancelBody(input));
+            return executeOrderCancelCapability(client, input);
         case "order.get":
-            return client.get("/api/v1/trading/order", optionalParams(input, ["orderId", "clientOrderId", "symbol"]));
+            return client.get("/api/v1/trading/order", orderReadParams(input));
         case "order.list":
             return client.get("/api/v1/trading/orders", { pageSize: stringValue(input.pageSize, "1000"), ...optionalParams(input, ["symbol"]) });
         case "order.history":
@@ -49,10 +50,11 @@ export async function executeRapidXCapability(capabilityId, input = {}, options
         case "position.close":
             return executePositionCloseCapability(client, input);
         case "position.set-leverage":
-            return client.post("/api/v1/trading/position/leverage", {
+            return client.post("/api/v1/trading/position/leverage", compactObject({
                 sym: String(input.symbol),
-                leverage: String(input.leverage)
-            });
+                leverage: String(input.leverage),
+                positionSide: input.positionSide
+            }));
         case "algo.place":
             return client.post("/api/v1/algo/order", algoPlaceBody(input));
         case "algo.amend":
@@ -70,8 +72,9 @@ export async function executeRapidXCapability(capabilityId, input = {}, options
     }
 }
 async function executeMarketCapability(capabilityId, input, fetchFn) {
-    const symbol = stringValue(input.symbol ?? input.sym, "BINANCE_PERP_BTC_USDT");
-    const parsed = parseRapidXSymbol(symbol);
+    const inputSymbol = stringValue(input.symbol ?? input.sym, "BINANCE_PERP_BTC_USDT");
+    const parsed = parseRapidXSymbol(inputSymbol);
+    const symbol = parsed.canonicalSymbol;
     if (capabilityId === "market.funding-rate" || capabilityId === "market.mark-price" || capabilityId === "market.symbol-info") {
         const client = new RapidXClient({ fetchFn });
         const path = capabilityId === "market.funding-rate"
@@ -96,6 +99,7 @@ async function executeMarketCapability(capabilityId, input, fetchFn) {
         case "market.ticker": {
             const raw = await fetchJson(fetchFn, `${base}${parsed.isPerp ? "/fapi/v1/ticker/24hr" : "/api/v3/ticker/24hr"}`, { symbol: parsed.binanceSymbol });
             return {
+                ...symbolMetadata(symbol, inputSymbol, parsed.binanceSymbol),
                 symbol,
                 lastPrice: raw.lastPrice,
                 priceChange: raw.priceChange,
@@ -108,7 +112,7 @@ async function executeMarketCapability(capabilityId, input, fetchFn) {
         }
         case "market.orderbook": {
             const raw = await fetchJson(fetchFn, `${base}${parsed.isPerp ? "/fapi/v1/depth" : "/api/v3/depth"}`, { symbol: parsed.binanceSymbol, limit: stringValue(input.depth, "20") });
-            return normalizeOrderbook(symbol, raw.bids, raw.asks);
+            return normalizeOrderbook(symbol, raw.bids, raw.asks, symbolMetadata(symbol, inputSymbol, parsed.binanceSymbol));
         }
         case "market.klines": {
             const raw = await fetchJson(fetchFn, `${base}${parsed.isPerp ? "/fapi/v1/klines" : "/api/v3/klines"}`, {
@@ -116,13 +120,14 @@ async function executeMarketCapability(capabilityId, input, fetchFn) {
                 interval: stringValue(input.interval, "1h"),
                 limit: stringValue(input.limit, "100")
             });
-            return { symbol, interval: stringValue(input.interval, "1h"), count: raw.length, candles: raw };
+            return { ...symbolMetadata(symbol, inputSymbol, parsed.binanceSymbol), symbol, interval: stringValue(input.interval, "1h"), count: raw.length, candles: raw };
         }
         case "market.open-interest": {
             if (!parsed.isPerp) {
                 throw new ProductError({ code: "RCORE00001", status: "FAIL", message: "open interest only supports perpetual symbols" });
             }
-            return fetchJson(fetchFn, `${base}/fapi/v1/openInterest`, { symbol: parsed.binanceSymbol });
+            const raw = await fetchJson(fetchFn, `${base}/fapi/v1/openInterest`, { symbol: parsed.binanceSymbol });
+            return { ...raw, ...symbolMetadata(symbol, inputSymbol, String(raw.symbol ?? parsed.binanceSymbol)), symbol };
         }
         default:
             throw new ProductError({ code: "RCORE30002", status: "FAIL", message: `Unknown market capability: ${capabilityId}` });
@@ -159,23 +164,39 @@ async function executePositionCloseCapability(client, input) {
         response
     };
 }
+async function executeOrderCancelCapability(client, input) {
+    const response = await client.delete("/api/v1/trading/order", orderCancelBody(input));
+    const lastObservedOrderState = normalizeCancelOrderState(extractOrderState(response));
+    const terminalStateConfirmed = isCancelTerminalState(lastObservedOrderState);
+    return {
+        cancelAccepted: true,
+        terminalStateConfirmed,
+        ...compactObject({ lastObservedOrderState }),
+        recommendedAction: terminalStateConfirmed
+            ? "verify final status with order/get or order/list when needed"
+            : "poll order/get until CANCELED, REJECTED, EXPIRED, or timeout",
+        response
+    };
+}
 async function executeOkxMarketCapability(capabilityId, symbol, instId, input, fetchFn) {
+    const inputSymbol = stringValue(input.symbol ?? input.sym, symbol);
     switch (capabilityId) {
         case "market.ticker": {
             const data = await fetchOkx(fetchFn, "/api/v5/market/ticker", { instId });
             const raw = data[0] ?? {};
-            return { symbol, lastPrice: raw.last, highPrice: raw.high24h, lowPrice: raw.low24h, volume: raw.vol24h, quoteVolume: raw.volCcy24h };
+            return { ...symbolMetadata(symbol, inputSymbol, String(raw.instId ?? instId)), symbol, lastPrice: raw.last, highPrice: raw.high24h, lowPrice: raw.low24h, volume: raw.vol24h, quoteVolume: raw.volCcy24h };
         }
         case "market.orderbook": {
             const data = await fetchOkx(fetchFn, "/api/v5/market/books", { instId, sz: stringValue(input.depth, "20") });
             const raw = data[0] ?? { bids: [], asks: [] };
             const bids = Array.isArray(raw.bids) ? raw.bids : [];
             const asks = Array.isArray(raw.asks) ? raw.asks : [];
-            return normalizeOrderbook(symbol, bids, asks);
+            return normalizeOrderbook(symbol, bids, asks, symbolMetadata(symbol, inputSymbol, instId));
         }
         case "market.open-interest": {
             const data = await fetchOkx(fetchFn, "/api/v5/public/open-interest", { instId });
-            return { symbol, ...(data[0] ?? {}) };
+            const raw = data[0] ?? {};
+            return { ...raw, ...symbolMetadata(symbol, inputSymbol, String(raw.instId ?? instId)), symbol };
         }
         default:
             throw new ProductError({ code: "RCORE30002", status: "FAIL", message: `OKX adapter not registered for ${capabilityId}` });
@@ -200,10 +221,11 @@ async function fetchOkx(fetchFn, path, params) {
     }
     return payload.data ?? [];
 }
-function normalizeOrderbook(symbol, bidsRaw, asksRaw) {
+function normalizeOrderbook(symbol, bidsRaw, asksRaw, metadata = {}) {
     const bids = bidsRaw.map(([price, quantity]) => ({ price, quantity }));
     const asks = asksRaw.map(([price, quantity]) => ({ price, quantity }));
     return {
+        ...metadata,
         symbol,
         bestBid: bids[0] ?? null,
         bestAsk: asks[0] ?? null,
@@ -211,6 +233,12 @@ function normalizeOrderbook(symbol, bidsRaw, asksRaw) {
         asks
     };
 }
+function symbolMetadata(symbol, inputSymbol, originalSymbol) {
+    return compactObject({
+        inputSymbol: inputSymbol !== symbol ? inputSymbol : undefined,
+        originalSymbol: originalSymbol !== symbol ? originalSymbol : undefined
+    });
+}
 function orderPlaceBody(input) {
     const body = requiredParams(input, ["symbol", "side", "orderType", "clientOrderId"]);
     const quantity = input.quantity ?? input.qty;
@@ -232,6 +260,9 @@ function orderPlaceBody(input) {
     if (input.reduceOnly !== undefined) {
         body.reduceOnly = input.reduceOnly === true ? "TRUE" : "FALSE";
     }
+    if (input.positionSide !== undefined && input.positionSide !== null && input.positionSide !== "") {
+        body.positionSide = String(input.positionSide);
+    }
     return {
         sym: String(body.symbol),
         side: String(body.side),
@@ -241,6 +272,7 @@ function orderPlaceBody(input) {
     };
 }
 function orderAmendBody(input) {
+    assertValidOrderId(input.orderId);
     const body = optionalParams(input, ["orderId", "clientOrderId"]);
     if (input.quantity !== undefined) {
         body.replaceQty = String(input.quantity);
@@ -251,8 +283,13 @@ function orderAmendBody(input) {
     return body;
 }
 function orderCancelBody(input) {
+    assertValidOrderId(input.orderId);
     return optionalParams(input, ["orderId", "clientOrderId"]);
 }
+function orderReadParams(input) {
+    assertOrderLookupReference(input);
+    return optionalParams(input, ["orderId", "clientOrderId", "symbol"]);
+}
 function positionCloseBody(input) {
     const body = {
         sym: String(input.symbol)
@@ -377,6 +414,44 @@ function positionMatchesSymbol(item, symbol) {
     }
     return [item.sym, item.symbol, item.instrumentId, item.instrument].some((value) => value === symbol);
 }
+function extractOrderState(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const directState = value.orderState ?? value.state ?? value.status;
+    if (directState !== undefined && directState !== null && directState !== "") {
+        return String(directState);
+    }
+    if (isRecord(value.data)) {
+        const nestedState = extractOrderState(value.data);
+        if (nestedState) {
+            return nestedState;
+        }
+    }
+    if (isRecord(value.order)) {
+        const nestedState = extractOrderState(value.order);
+        if (nestedState) {
+            return nestedState;
+        }
+    }
+    return undefined;
+}
+function normalizeCancelOrderState(state) {
+    if (!state) {
+        return undefined;
+    }
+    const normalized = state.trim().toUpperCase().replace(/[-\s]+/g, "_");
+    if (["CANCELLED", "CANCEL_COMPLETE", "CANCEL_SUCCESS", "CANCELED"].includes(normalized)) {
+        return "CANCELED";
+    }
+    if (["CANCEL_PENDING", "PENDING_CANCEL", "CANCELING"].includes(normalized)) {
+        return "CANCEL_PENDING";
+    }
+    return normalized;
+}
+function isCancelTerminalState(state) {
+    return state === "CANCELED" || state === "REJECTED" || state === "EXPIRED";
+}
 function compactObject(input) {
     return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined && value !== null && value !== ""));
 }

package/dist/core/client/order-id.js

@@ -0,0 +1,24 @@
+import { CORE_ERRORS, ProductError } from "../errors/product-error.js";
+export function assertValidOrderId(orderId) {
+    if (orderId === undefined || orderId === null || orderId === "") {
+        return;
+    }
+    if (!/^\d{16}$/.test(String(orderId))) {
+        throw new ProductError({
+            code: CORE_ERRORS.INVALID_ORDER_ID,
+            status: "INVALID_INPUT",
+            message: "orderId must be 16 digits."
+        });
+    }
+}
+export function assertOrderLookupReference(input) {
+    assertValidOrderId(input.orderId);
+    if ((input.orderId === undefined || input.orderId === null || input.orderId === "")
+        && (input.clientOrderId === undefined || input.clientOrderId === null || input.clientOrderId === "")) {
+        throw new ProductError({
+            code: "RCORE00001",
+            status: "INVALID_INPUT",
+            message: "orderId or clientOrderId is required."
+        });
+    }
+}

package/dist/core/client/rapid-x-client.js

@@ -65,12 +65,12 @@ export class RapidXClient {
                     await delay(this.readOnlyRetryDelayMs * (2 ** (attempt - 1)));
                     continue;
                 }
-                const hint = upstreamHttpErrorHint(path, response.status);
+                const hint = upstreamHttpErrorHint(path, response.status, text);
                 throw new ProductError({
-                    code: upstreamHttpErrorCode(response.status),
-                    status: "FAIL",
+                    code: upstreamHttpErrorCode(path, response.status, text),
+                    status: upstreamHttpErrorStatus(path, response.status, text),
                     message: hint ? `RapidX upstream error ${response.status}. ${hint}` : `RapidX upstream error ${response.status}`,
-                    details: { status: response.status, body: text.slice(0, 500), attempts: attempt, ...(hint ? { hint } : {}) }
+                    details: { upstreamStatus: response.status, status: response.status, body: text.slice(0, 500), attempts: attempt, ...(hint ? { hint } : {}) }
                 });
             }
             if (!text) {
@@ -111,13 +111,19 @@ function resolveBaseUrl(explicitBaseUrl) {
 function firstNonEmpty(...values) {
     return values.find((value) => value !== undefined && value.length > 0);
 }
-function upstreamHttpErrorHint(path, status) {
-    if (path === "/api/v1/account/balance" && status >= 500) {
+function upstreamHttpErrorHint(path, status, body) {
+    if (isAccountBalanceScopeError(path, status, body)) {
         return "account balance mode=account requires account-level credentials; portfolio keys should use mode=portfolio.";
     }
     return undefined;
 }
-function upstreamHttpErrorCode(status) {
+function upstreamHttpErrorCode(path, status, body) {
+    if (isAccountBalanceScopeError(path, status, body)) {
+        return CORE_ERRORS.PERMISSION_SCOPE_ERROR;
+    }
+    if (status === 404) {
+        return CORE_ERRORS.NOT_FOUND;
+    }
     if (status === 429) {
         return CORE_ERRORS.UPSTREAM_RATE_LIMITED;
     }
@@ -126,6 +132,28 @@ function upstreamHttpErrorCode(status) {
     }
     return CORE_ERRORS.INVALID_CREDENTIAL;
 }
+function upstreamHttpErrorStatus(path, status, body) {
+    if (isAccountBalanceScopeError(path, status, body)) {
+        return "PERMISSION_SCOPE_ERROR";
+    }
+    if (status === 404) {
+        return "NOT_FOUND";
+    }
+    return "FAIL";
+}
+function isAccountBalanceScopeError(path, status, body) {
+    if (path !== "/api/v1/account/balance" || status < 400) {
+        return false;
+    }
+    if (status >= 500) {
+        return true;
+    }
+    const lowerBody = body.toLowerCase();
+    return lowerBody.includes("account-level")
+        || lowerBody.includes("permission scope")
+        || lowerBody.includes("credential scope")
+        || (lowerBody.includes("portfolio") && lowerBody.includes("account"));
+}
 function delay(ms) {
     if (ms <= 0) {
         return Promise.resolve();
@@ -144,9 +172,10 @@ function assertRapidXBusinessSuccess(payload) {
     const upstreamMessage = typeof body.message === "string" && body.message.length > 0
         ? `: ${body.message}`
         : "";
+    const classification = classifyBusinessError(code, typeof body.message === "string" ? body.message : "");
     throw new ProductError({
-        code: CORE_ERRORS.UPSTREAM_REJECTED,
-        status: "FAIL",
+        code: classification.code,
+        status: classification.status,
         message: `RapidX upstream business error ${code}${upstreamMessage}`,
         details: {
             upstreamCode: code,
@@ -154,3 +183,10 @@ function assertRapidXBusinessSuccess(payload) {
         }
     });
 }
+function classifyBusinessError(upstreamCode, upstreamMessage) {
+    const lowerMessage = upstreamMessage.toLowerCase();
+    if (lowerMessage.includes("not found") || lowerMessage.includes("not exist") || lowerMessage.includes("does not exist")) {
+        return { code: CORE_ERRORS.NOT_FOUND, status: "NOT_FOUND" };
+    }
+    return { code: CORE_ERRORS.UPSTREAM_REJECTED, status: "BUSINESS_ERROR" };
+}

package/dist/core/client/symbol.js

@@ -10,18 +10,22 @@ export function parseRapidXSymbol(symbol) {
         });
     }
     const exchange = exchangeRaw.toUpperCase();
-    const type = typeRaw.toUpperCase();
+    const requestedType = typeRaw.toUpperCase();
+    const type = requestedType === "SWAP" && exchange === "OKX" ? "PERP" : requestedType;
     if (type !== "PERP" && type !== "SPOT") {
         throw new ProductError({
             code: "RCORE12001",
             status: "FAIL",
-            message: `Unsupported RapidX symbol type: ${typeRaw}`
+            message: `Unsupported RapidX symbol type: ${typeRaw}. Use PERP or SPOT; for OKX perpetual swaps, use OKX_PERP_<BASE>_<QUOTE> or OKX_SWAP_<BASE>_<QUOTE> as an input alias.`
         });
     }
     const base = baseRaw.toUpperCase();
     const quote = quoteRaw.toUpperCase();
     const isPerp = type === "PERP";
+    const canonicalSymbol = `${exchange}_${type}_${base}_${quote}`;
     const parsed = {
+        inputSymbol: symbol,
+        canonicalSymbol,
         exchange,
         base,
         quote,

package/dist/core/contracts/capabilities.js

@@ -1,4 +1,5 @@
 import { SCHEMA_VERSION } from "./types.js";
+import { inputSchemaForName } from "./input-schema.js";
 export const CAPABILITIES = [
     { capabilityId: "config.get", cliCommand: "rapidx config get", operationType: "READ", riskLevel: "read", inputSchema: "ConfigGetInput", outputSchema: "ConfigResult", previewRequired: false },
     { capabilityId: "config.set", cliCommand: "rapidx config set", operationType: "DIAGNOSTIC", riskLevel: "write-config", inputSchema: "ConfigSetInput", outputSchema: "ConfigResult", previewRequired: false },
@@ -43,9 +44,11 @@ export const CAPABILITIES = [
     { capabilityId: "invocation.check", cliCommand: "rapidx invocation check", operationType: "DIAGNOSTIC", riskLevel: "read", inputSchema: "InvocationCheckInput", outputSchema: "InvocationCompliance", previewRequired: false }
 ];
 export function getSchemaResult() {
+    const schemaNames = [...new Set(CAPABILITIES.map((capability) => capability.inputSchema))].sort();
     return {
         schemaVersion: SCHEMA_VERSION,
-        capabilities: [...CAPABILITIES]
+        capabilities: [...CAPABILITIES],
+        inputSchemas: Object.fromEntries(schemaNames.map((name) => [name, inputSchemaForName(name)]))
     };
 }
 export function listMcpCapabilities() {

package/dist/core/contracts/compatibility.js

@@ -1,7 +1,7 @@
 import { SCHEMA_VERSION } from "./types.js";
 import { RAPIDX_VERSION } from "../version.js";
 export const RAPIDX_SKILLS_DISTRIBUTION = "github";
-export const RAPIDX_SKILLS_VERSION = "1.0.2";
+export const RAPIDX_SKILLS_VERSION = "1.0.4";
 export const RAPIDX_SKILLS_SCHEMA_VERSION = "1.0.0";
 export function buildCompatibilityReport(input = {}) {
     const checks = [