@liquiditytech/rapidx-cli 1.0.26

package/dist/cli/envelope.js

@@ -0,0 +1,29 @@
+import { makeEvidence } from "../core/index.js";
+export function ok(data, evidenceText, status = "PASS", source = "local_check", auditId) {
+    return {
+        ok: status === "PASS",
+        status,
+        data,
+        ...(auditId ? { auditId } : {}),
+        evidence: [makeEvidence(evidenceText, source)]
+    };
+}
+export function fail(code, message, status = "FAIL", evidenceText = "rapidx cli") {
+    return {
+        ok: false,
+        status,
+        code,
+        message,
+        evidence: [makeEvidence(evidenceText)]
+    };
+}
+export function failWithData(code, message, data, status = "FAIL", evidenceText = "rapidx cli") {
+    return {
+        ok: false,
+        status,
+        code,
+        message,
+        data,
+        evidence: [makeEvidence(evidenceText)]
+    };
+}

package/dist/cli/help.js

@@ -0,0 +1,34 @@
+import { RAPIDX_VERSION } from "../core/index.js";
+export function formatCliHelp() {
+    return [
+        "RapidX CLI",
+        "",
+        "Usage: rapidx <domain> <action> [--input '<json>'] [--json]",
+        "",
+        "Examples:",
+        "  rapidx schema --json",
+        "  rapidx update check --json",
+        "  rapidx self-check --input '{\"scope\":\"deep\"}' --json",
+        "  rapidx market get-ticker --input '{\"symbol\":\"BINANCE_PERP_BTC_USDT\"}' --json",
+        "  rapidx market get-ticker --symbol BINANCE_PERP_BTC_USDT --json",
+        "  rapidx order preview --input '{\"symbol\":\"BINANCE_PERP_BTC_USDT\",\"side\":\"BUY\",\"orderType\":\"LIMIT\",\"price\":\"1\",\"quantity\":\"0.001\",\"maxNotional\":\"1\",\"clientOrderId\":\"example\"}' --json",
+        "  rapidx order cancel-preview --input '{\"orderId\":\"<order-id>\"}' --json",
+        "  rapidx trade verify-live --input '{\"symbol\":\"BINANCE_PERP_BTC_USDT\",\"side\":\"BUY\",\"maxNotional\":\"10\",\"clientOrderId\":\"verify-001\",\"explicitUserConsent\":true}' --json",
+        "  rapidx mcp serve",
+        "",
+        "Domains:",
+        "  schema, doctor, auth, config, update, self-check, invocation",
+        "  market, account, order, trade, position, algo",
+        "",
+        "Use --input for structured JSON. Named options such as --symbol and --depth are also accepted for simple inputs."
+    ].join("\n");
+}
+export function formatCliVersion() {
+    return RAPIDX_VERSION;
+}
+export function isHelpArg(arg) {
+    return arg === "--help" || arg === "-h";
+}
+export function isVersionArg(arg) {
+    return arg === "--version" || arg === "-v";
+}

package/dist/cli/invocation-checker.js

@@ -0,0 +1,39 @@
+const COMPLEX_SHELL_PATTERNS = [
+    /\bcd\s+\S+\s+&&\s+/,
+    /\s&&\s/,
+    /\s\|\s/,
+    /\s;\s/,
+    /<<\s*\w+/,
+    /\b(?:sh|bash|zsh)\s+-c\b/,
+    /\bbtc-mcp-call\.js\b/,
+    /(?:^|\s)(?:node|python|python3)\s+\/(?:tmp|private\/tmp)\//
+];
+export function checkInvocationMode(input) {
+    if (input.preflightError && /exec preflight|complex interpreter invocation/i.test(input.preflightError)) {
+        return {
+            compliant: false,
+            code: "RCLI25001",
+            reason: "Host exec preflight blocked the command; use direct MCP tools or the rapidx bin without shell chaining."
+        };
+    }
+    const commandLine = input.commandLine ?? "";
+    const matched = COMPLEX_SHELL_PATTERNS.find((pattern) => pattern.test(commandLine));
+    if (matched) {
+        return {
+            compliant: false,
+            code: "RCLI13001",
+            reason: `Complex shell invocation is not allowed: ${matched.source}`
+        };
+    }
+    if (/\bnode\s+.*bridge/i.test(commandLine)) {
+        return {
+            compliant: false,
+            code: "RCLI13002",
+            reason: "Bridge scripts are not part of the supported CLI contract."
+        };
+    }
+    return {
+        compliant: true,
+        reason: "Invocation is direct."
+    };
+}

package/dist/cli/mcp-entry.js

@@ -0,0 +1,4 @@
+export async function startMcpServer() {
+    const { startStdioServer } = await import("../mcp/server.js");
+    await startStdioServer();
+}

package/dist/cli/parser.js

@@ -0,0 +1,87 @@
+import { readFileSync } from "node:fs";
+export function parseArgv(argv, options = {}) {
+    const commandParts = [];
+    const parsedOptions = {};
+    let input = {};
+    const namedInput = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!token) {
+            continue;
+        }
+        if (!token.startsWith("--")) {
+            commandParts.push(token);
+            continue;
+        }
+        const name = token.slice(2);
+        if (name === "input") {
+            const value = argv[index + 1];
+            index += 1;
+            if (!value) {
+                throw new Error("--input requires a value.");
+            }
+            input = readInput(value);
+            parsedOptions.input = value;
+            continue;
+        }
+        const normalizedName = normalizeOptionName(name);
+        const next = argv[index + 1];
+        let parsedValue;
+        if (next && !next.startsWith("--")) {
+            parsedValue = next;
+            parsedOptions[normalizedName] = next;
+            index += 1;
+        }
+        else {
+            parsedValue = true;
+            parsedOptions[normalizedName] = true;
+        }
+        if (!RESERVED_OPTIONS.has(normalizedName)) {
+            namedInput[normalizedName] = coerceNamedInputValue(normalizedName, parsedValue);
+        }
+    }
+    if (Object.keys(input).length === 0 && options.stdin && options.stdin.trim()) {
+        input = JSON.parse(options.stdin);
+    }
+    if (Object.keys(namedInput).length > 0) {
+        input = { ...input, ...namedInput };
+    }
+    return {
+        commandParts,
+        command: commandParts.join(" "),
+        options: parsedOptions,
+        input
+    };
+}
+function readInput(value) {
+    const raw = value.startsWith("@") ? readFileSync(value.slice(1), "utf8") : value;
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("CLI input must be a JSON object.");
+    }
+    return parsed;
+}
+const RESERVED_OPTIONS = new Set(["help", "version", "json", "input"]);
+const NUMBER_OPTIONS = new Set(["depth", "limit", "pageSize", "leverage", "maxCacheAgeSeconds"]);
+const BOOLEAN_OPTIONS = new Set(["postOnly", "reduceOnly", "readOnly", "explicitUserConsent", "force", "checkUpdates"]);
+function normalizeOptionName(name) {
+    return name.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+function coerceNamedInputValue(name, value) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (NUMBER_OPTIONS.has(name)) {
+        const numeric = Number(value);
+        return Number.isFinite(numeric) ? numeric : value;
+    }
+    if (BOOLEAN_OPTIONS.has(name)) {
+        if (value === "true") {
+            return true;
+        }
+        if (value === "false") {
+            return false;
+        }
+    }
+    return value;
+}

package/dist/core/audit/redaction.js

@@ -0,0 +1,56 @@
+import { CORE_ERRORS, ProductError } from "../errors/product-error.js";
+export const SENSITIVE_KEYS = [
+    "accessKey",
+    "secretKey",
+    "access_key",
+    "secret_key",
+    "token",
+    "apiKey",
+    "password",
+    "credential",
+    "credentials"
+];
+const SENSITIVE_KEY_SET = new Set(SENSITIVE_KEYS.map((key) => key.toLowerCase()));
+const SECRET_LIKE_PATTERN = /(sk|pk|secret|token|key)_[A-Za-z0-9_-]{16,}|[A-Fa-f0-9]{48,}/;
+export function isSensitiveKey(key) {
+    return SENSITIVE_KEY_SET.has(key.toLowerCase());
+}
+export function redactSecrets(input) {
+    let redactedCount = 0;
+    let riskDetected = false;
+    function visit(value, keyHint) {
+        if (keyHint && isSensitiveKey(keyHint)) {
+            redactedCount += 1;
+            return "[REDACTED]";
+        }
+        if (typeof value === "string") {
+            if (SECRET_LIKE_PATTERN.test(value)) {
+                riskDetected = true;
+                return "[REDACTED]";
+            }
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => visit(item));
+        }
+        if (value && typeof value === "object") {
+            const entries = Object.entries(value).map(([key, child]) => [key, visit(child, key)]);
+            return Object.fromEntries(entries);
+        }
+        return value;
+    }
+    return {
+        value: visit(input),
+        redactedCount,
+        riskDetected
+    };
+}
+export function assertNoSensitiveText(text) {
+    if (SECRET_LIKE_PATTERN.test(text)) {
+        throw new ProductError({
+            code: CORE_ERRORS.SECRET_REDACTION_RISK,
+            status: "FAIL",
+            message: "Potential secret material detected in output."
+        });
+    }
+}

package/dist/core/audit/writer.js

@@ -0,0 +1,27 @@
+import { randomUUID } from "node:crypto";
+import { redactSecrets } from "./redaction.js";
+import { CORE_ERRORS, ProductError } from "../errors/product-error.js";
+export class AuditWriter {
+    stream;
+    constructor(stream = process.stderr) {
+        this.stream = stream;
+    }
+    write(event) {
+        const auditId = randomUUID();
+        const redacted = redactSecrets({
+            auditId,
+            timestamp: event.timestamp ?? new Date().toISOString(),
+            ...event
+        });
+        if (redacted.riskDetected) {
+            throw new ProductError({
+                code: CORE_ERRORS.SECRET_REDACTION_RISK,
+                status: "FAIL",
+                message: "Audit payload contained secret-like material."
+            });
+        }
+        const line = JSON.stringify(redacted.value);
+        this.stream.write(`${line}\n`);
+        return { auditId, line };
+    }
+}

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

@@ -0,0 +1,400 @@
+import { ProductError } from "../errors/product-error.js";
+import { parseRapidXSymbol } from "./symbol.js";
+import { RapidXClient } from "./rapid-x-client.js";
+import { findCapabilityById } from "../contracts/capabilities.js";
+import { assertInputMatchesSchema } from "../contracts/input-schema.js";
+export async function executeRapidXCapability(capabilityId, input = {}, options = {}) {
+    const capability = findCapabilityById(capabilityId);
+    if (!capability) {
+        throw new ProductError({
+            code: "RCORE30002",
+            status: "FAIL",
+            message: `No capability registered for ${capabilityId}`
+        });
+    }
+    assertInputMatchesSchema(capability.inputSchema, input);
+    if (capabilityId.startsWith("market.")) {
+        return executeMarketCapability(capabilityId, input, options.fetchFn ?? fetch);
+    }
+    const client = options.client ?? new RapidXClient();
+    switch (capabilityId) {
+        case "account.overview":
+            return client.get("/api/v1/trading/account");
+        case "account.balance":
+            return executeAccountBalanceCapability(client, input);
+        case "account.set-position-mode":
+            return client.post("/api/v1/trading/account", {
+                positionMode: String(input.mode),
+                exchangeType: String(input.exchange)
+            });
+        case "order.place":
+            return client.post("/api/v1/trading/order", orderPlaceBody(input));
+        case "order.amend":
+            return client.put("/api/v1/trading/order", orderAmendBody(input));
+        case "order.cancel":
+            return client.delete("/api/v1/trading/order", orderCancelBody(input));
+        case "order.get":
+            return client.get("/api/v1/trading/order", optionalParams(input, ["orderId", "clientOrderId", "symbol"]));
+        case "order.list":
+            return client.get("/api/v1/trading/orders", { pageSize: stringValue(input.pageSize, "1000"), ...optionalParams(input, ["symbol"]) });
+        case "order.history":
+            return client.get("/api/v1/trading/history/orders", { pageSize: stringValue(input.pageSize, "100"), ...optionalParams(input, ["symbol", "startTime", "endTime"]) });
+        case "position.list":
+            return executePositionListCapability(client, input);
+        case "position.history":
+            return client.get("/api/v1/trading/history/position", {
+                pageSize: stringValue(input.pageSize, "100"),
+                ...positionHistoryParams(input)
+            });
+        case "position.close":
+            return executePositionCloseCapability(client, input);
+        case "position.set-leverage":
+            return client.post("/api/v1/trading/position/leverage", {
+                sym: String(input.symbol),
+                leverage: String(input.leverage)
+            });
+        case "algo.place":
+            return client.post("/api/v1/algo/order", algoPlaceBody(input));
+        case "algo.amend":
+            return client.put("/api/v1/algo/order", algoAmendBody(input));
+        case "algo.cancel":
+            return client.delete("/api/v1/algo/order", optionalParams(input, ["algoOrderId", "clientOrderId"]));
+        case "algo.list":
+            return client.get("/api/v1/algo/openOrders", algoListParams(input));
+        default:
+            throw new ProductError({
+                code: "RCORE30002",
+                status: "FAIL",
+                message: `No RapidX executor registered for ${capabilityId}`
+            });
+    }
+}
+async function executeMarketCapability(capabilityId, input, fetchFn) {
+    const symbol = stringValue(input.symbol ?? input.sym, "BINANCE_PERP_BTC_USDT");
+    const parsed = parseRapidXSymbol(symbol);
+    if (capabilityId === "market.funding-rate" || capabilityId === "market.mark-price" || capabilityId === "market.symbol-info") {
+        const client = new RapidXClient({ fetchFn });
+        const path = capabilityId === "market.funding-rate"
+            ? "/api/v1/market/fundingRate"
+            : capabilityId === "market.mark-price"
+                ? "/api/v1/market/markPrice"
+                : "/api/v1/trading/sym/info";
+        return client.get(path, optionalParams({ sym: symbol }, ["sym"]));
+    }
+    if (parsed.exchange === "OKX") {
+        return executeOkxMarketCapability(capabilityId, symbol, parsed.okxInstId ?? "", input, fetchFn);
+    }
+    if (parsed.exchange !== "BINANCE") {
+        throw new ProductError({
+            code: "RCORE12001",
+            status: "FAIL",
+            message: `Unsupported market exchange: ${parsed.exchange}`
+        });
+    }
+    const base = parsed.isPerp ? "https://fapi.binance.com" : "https://api.binance.com";
+    switch (capabilityId) {
+        case "market.ticker": {
+            const raw = await fetchJson(fetchFn, `${base}${parsed.isPerp ? "/fapi/v1/ticker/24hr" : "/api/v3/ticker/24hr"}`, { symbol: parsed.binanceSymbol });
+            return {
+                symbol,
+                lastPrice: raw.lastPrice,
+                priceChange: raw.priceChange,
+                priceChangePercent: raw.priceChangePercent,
+                highPrice: raw.highPrice,
+                lowPrice: raw.lowPrice,
+                volume: raw.volume,
+                quoteVolume: raw.quoteVolume
+            };
+        }
+        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);
+        }
+        case "market.klines": {
+            const raw = await fetchJson(fetchFn, `${base}${parsed.isPerp ? "/fapi/v1/klines" : "/api/v3/klines"}`, {
+                symbol: parsed.binanceSymbol,
+                interval: stringValue(input.interval, "1h"),
+                limit: stringValue(input.limit, "100")
+            });
+            return { 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 });
+        }
+        default:
+            throw new ProductError({ code: "RCORE30002", status: "FAIL", message: `Unknown market capability: ${capabilityId}` });
+    }
+}
+function executeAccountBalanceCapability(client, input) {
+    const mode = String(input.mode ?? "portfolio").toLowerCase();
+    const params = optionalParams(input, ["currency"]);
+    if (mode === "account") {
+        return client.get("/api/v1/account/balance", params);
+    }
+    return client.get("/api/v1/trading/portfolio/assets", params);
+}
+async function executePositionListCapability(client, input) {
+    const params = {};
+    if (input.symbol !== undefined && input.symbol !== null && input.symbol !== "") {
+        params.sym = String(input.symbol);
+    }
+    const response = await client.get("/api/v1/trading/position", params);
+    return filterPositionResponse(response, params.sym);
+}
+async function executePositionCloseCapability(client, input) {
+    const response = await client.delete("/api/v1/trading/position", positionCloseBody(input));
+    return {
+        closePosition: true,
+        sourceCapability: "position.close",
+        reduceOnlyRequested: input.reduceOnly === true,
+        request: compactObject({
+            symbol: input.symbol,
+            positionSide: input.positionSide,
+            maxNotional: input.maxNotional
+        }),
+        readbackNote: "position.close uses RapidX close-position API; order.get reduceOnly may not reflect this close-position request. Verify final exposure with position.list.",
+        response
+    };
+}
+async function executeOkxMarketCapability(capabilityId, symbol, instId, input, fetchFn) {
+    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 };
+        }
+        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);
+        }
+        case "market.open-interest": {
+            const data = await fetchOkx(fetchFn, "/api/v5/public/open-interest", { instId });
+            return { symbol, ...(data[0] ?? {}) };
+        }
+        default:
+            throw new ProductError({ code: "RCORE30002", status: "FAIL", message: `OKX adapter not registered for ${capabilityId}` });
+    }
+}
+async function fetchJson(fetchFn, url, params = {}) {
+    const parsed = new URL(url);
+    for (const [key, value] of Object.entries(params)) {
+        parsed.searchParams.set(key, value);
+    }
+    const response = await fetchFn(parsed.toString(), { method: "GET", signal: AbortSignal.timeout(15_000) });
+    const text = await response.text();
+    if (!response.ok) {
+        throw new ProductError({ code: "RCORE02001", status: "FAIL", message: `Public market API error ${response.status}` });
+    }
+    return JSON.parse(text);
+}
+async function fetchOkx(fetchFn, path, params) {
+    const payload = await fetchJson(fetchFn, `https://www.okx.com${path}`, params);
+    if (payload.code !== "0") {
+        throw new ProductError({ code: "RCORE22001", status: "FAIL", message: `OKX API error: ${payload.code} ${payload.msg ?? ""}`.trim() });
+    }
+    return payload.data ?? [];
+}
+function normalizeOrderbook(symbol, bidsRaw, asksRaw) {
+    const bids = bidsRaw.map(([price, quantity]) => ({ price, quantity }));
+    const asks = asksRaw.map(([price, quantity]) => ({ price, quantity }));
+    return {
+        symbol,
+        bestBid: bids[0] ?? null,
+        bestAsk: asks[0] ?? null,
+        bids,
+        asks
+    };
+}
+function orderPlaceBody(input) {
+    const body = requiredParams(input, ["symbol", "side", "orderType", "clientOrderId"]);
+    const quantity = input.quantity ?? input.qty;
+    if (quantity !== undefined) {
+        body.orderQty = String(quantity);
+    }
+    if (input.amount !== undefined) {
+        body.quoteOrderQty = String(input.amount);
+    }
+    if (input.price !== undefined) {
+        body.limitPrice = String(input.price);
+    }
+    if (input.timeInForce !== undefined) {
+        body.timeInForce = String(input.timeInForce);
+    }
+    if (input.postOnly === true) {
+        body.timeInForce = "GTX";
+    }
+    if (input.reduceOnly !== undefined) {
+        body.reduceOnly = input.reduceOnly === true ? "TRUE" : "FALSE";
+    }
+    return {
+        sym: String(body.symbol),
+        side: String(body.side),
+        orderType: String(body.orderType),
+        clientOrderId: String(body.clientOrderId),
+        ...omitKeys(body, ["symbol"])
+    };
+}
+function orderAmendBody(input) {
+    const body = optionalParams(input, ["orderId", "clientOrderId"]);
+    if (input.quantity !== undefined) {
+        body.replaceQty = String(input.quantity);
+    }
+    if (input.price !== undefined) {
+        body.replacePrice = String(input.price);
+    }
+    return body;
+}
+function orderCancelBody(input) {
+    return optionalParams(input, ["orderId", "clientOrderId"]);
+}
+function positionCloseBody(input) {
+    const body = {
+        sym: String(input.symbol)
+    };
+    if (input.positionSide !== undefined && input.positionSide !== null && input.positionSide !== "") {
+        body.positionSide = String(input.positionSide);
+    }
+    return body;
+}
+function algoPlaceBody(input) {
+    const body = {
+        ...orderPlaceBody(input),
+        algoOrderType: String(input.algoType)
+    };
+    appendMappedOptionalParams(body, input, [
+        ["positionSide", "positionSide"],
+        ["conditionType", "conditionType"],
+        ["triggerPrice", "conditionalTriggerPrice"],
+        ["triggerType", "conditionalTriggerType"],
+        ["takeProfitPrice", "tpTriggerPrice"],
+        ["takeProfitLimitPrice", "tpPrice"],
+        ["stopLossPrice", "slTriggerPrice"],
+        ["stopLossLimitPrice", "slPrice"]
+    ]);
+    return body;
+}
+function algoAmendBody(input) {
+    const body = optionalParams(input, ["algoOrderId", "clientOrderId"]);
+    appendMappedOptionalParams(body, input, [
+        ["triggerPrice", "conditionalTriggerPrice"],
+        ["triggerType", "conditionalTriggerType"],
+        ["takeProfitPrice", "tpTriggerPrice"],
+        ["takeProfitLimitPrice", "tpPrice"],
+        ["stopLossPrice", "slTriggerPrice"],
+        ["stopLossLimitPrice", "slPrice"]
+    ]);
+    return body;
+}
+function algoListParams(input) {
+    const params = {};
+    if (input.symbol !== undefined && input.symbol !== null && input.symbol !== "") {
+        params.sym = String(input.symbol);
+    }
+    return params;
+}
+function positionHistoryParams(input) {
+    const params = optionalParams(input, ["startTime", "endTime"]);
+    if (input.symbol !== undefined && input.symbol !== null && input.symbol !== "") {
+        params.sym = String(input.symbol);
+    }
+    return params;
+}
+function requiredParams(input, keys) {
+    const result = {};
+    for (const key of keys) {
+        if (input[key] === undefined || input[key] === null || input[key] === "") {
+            throw new ProductError({ code: "RCORE00001", status: "FAIL", message: `${key} is required.` });
+        }
+        result[key] = String(input[key]);
+    }
+    return result;
+}
+function optionalParams(input, keys) {
+    const result = {};
+    for (const key of keys) {
+        if (input[key] !== undefined && input[key] !== null && input[key] !== "") {
+            result[key] = String(input[key]);
+        }
+    }
+    return result;
+}
+function filterPositionResponse(response, symbol) {
+    if (!symbol) {
+        return response;
+    }
+    if (Array.isArray(response)) {
+        return {
+            data: response.filter((item) => positionMatchesSymbol(item, symbol)),
+            requestedSymbol: symbol,
+            filterApplied: "client"
+        };
+    }
+    if (!isRecord(response)) {
+        return response;
+    }
+    if (Array.isArray(response.data)) {
+        return {
+            ...response,
+            data: response.data.filter((item) => positionMatchesSymbol(item, symbol)),
+            requestedSymbol: symbol,
+            filterApplied: "client"
+        };
+    }
+    if (isRecord(response.data) && Array.isArray(response.data.list)) {
+        return {
+            ...response,
+            data: {
+                ...response.data,
+                list: response.data.list.filter((item) => positionMatchesSymbol(item, symbol))
+            },
+            requestedSymbol: symbol,
+            filterApplied: "client"
+        };
+    }
+    if (Array.isArray(response.list)) {
+        return {
+            ...response,
+            list: response.list.filter((item) => positionMatchesSymbol(item, symbol)),
+            requestedSymbol: symbol,
+            filterApplied: "client"
+        };
+    }
+    return {
+        ...response,
+        requestedSymbol: symbol,
+        filterApplied: "not_applicable"
+    };
+}
+function positionMatchesSymbol(item, symbol) {
+    if (!isRecord(item)) {
+        return false;
+    }
+    return [item.sym, item.symbol, item.instrumentId, item.instrument].some((value) => value === symbol);
+}
+function compactObject(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined && value !== null && value !== ""));
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value, fallback) {
+    return value === undefined || value === null || value === "" ? fallback : String(value);
+}
+function appendMappedOptionalParams(target, input, mappings) {
+    for (const [from, to] of mappings) {
+        const value = input[from];
+        if (value !== undefined && value !== null && value !== "") {
+            target[to] = String(value);
+        }
+    }
+}
+function omitKeys(input, keys) {
+    const blocked = new Set(keys);
+    return Object.fromEntries(Object.entries(input).filter(([key]) => !blocked.has(key)));
+}