@liquiditytech/rapidx-cli 1.0.26

package/dist/core/contracts/input-schema.js

@@ -0,0 +1,370 @@
+import { ProductError } from "../errors/product-error.js";
+const stringSchema = { type: "string" };
+const booleanSchema = { type: "boolean" };
+const numberSchema = { type: "number" };
+const symbolSchema = {
+    type: "string",
+    description: "RapidX symbol, for example BINANCE_PERP_BTC_USDT or OKX_SWAP_BTC_USDT.",
+    examples: ["BINANCE_PERP_BTC_USDT", "OKX_SWAP_BTC_USDT"]
+};
+const sideSchema = {
+    type: "string",
+    enum: ["BUY", "SELL"],
+    description: "Order side. Use BUY to buy/open long or buy back short; use SELL to sell/reduce long or open short."
+};
+const orderTypeSchema = {
+    type: "string",
+    enum: ["LIMIT", "MARKET"],
+    description: "Order type. LIMIT is the expected default for agent-driven trading; MARKET may be blocked by safety policy."
+};
+const priceSchema = {
+    type: "string",
+    description: "Limit price as a decimal string in quote currency.",
+    unit: "quote currency",
+    examples: ["65000"]
+};
+const quantitySchema = {
+    type: "string",
+    description: "Base asset quantity as a decimal string. For contract venues, this is the RapidX order quantity accepted by the symbol.",
+    unit: "base asset or contract quantity",
+    examples: ["0.001"]
+};
+const amountSchema = {
+    type: "string",
+    description: "Quote amount as a decimal string when placing by quote notional instead of quantity.",
+    unit: "quote currency",
+    examples: ["10"]
+};
+const maxNotionalSchema = {
+    type: "string",
+    description: "Safety upper bound for this operation, expressed as a decimal string in quote currency. This is not the target order amount.",
+    unit: "quote currency",
+    examples: ["10"]
+};
+const clientOrderIdSchema = {
+    type: "string",
+    description: "Caller-generated idempotency key for the order request.",
+    examples: ["agent-test-20260529-001"]
+};
+const previewIdSchema = {
+    type: "string",
+    description: "Preview id returned by the matching preview tool or command.",
+    examples: ["rpv_00000000-0000-4000-8000-000000000000"]
+};
+const continueConsentIdSchema = {
+    type: "string",
+    description: "Submit confirmation id. Prefer using preview.confirmation.submitToken returned by the matching preview result.",
+    examples: ["confirm_rpv_00000000-0000-4000-8000-000000000000"]
+};
+const targetCapabilityIdSchema = {
+    type: "string",
+    description: "Target trade-write capabilityId to preview, for example order.cancel, position.set-leverage, or position.close.",
+    examples: ["order.cancel", "position.set-leverage", "position.close"]
+};
+const orderIdSchema = {
+    type: "string",
+    description: "RapidX order id returned by order.place, order.list, or order.get.",
+    examples: ["1234567890"]
+};
+const accountBalanceModeSchema = {
+    type: "string",
+    enum: ["portfolio", "account"],
+    description: "Balance source. portfolio uses /api/v1/trading/portfolio/assets; account uses /api/v1/account/balance."
+};
+const positionSideSchema = {
+    type: "string",
+    description: "Position side when the account is in hedge mode, for example LONG or SHORT. Omit in one-way NET mode unless RapidX returns a specific side."
+};
+const closePositionReduceOnlySchema = {
+    type: "boolean",
+    description: "Must be true for position.close. Do not pass side; RapidX determines BUY or SELL from the current position."
+};
+const algoConditionTypeSchema = { type: "string", enum: ["CONDITIONAL", "OCO", "ENTIRE_CLOSE_POSITION", "PARTIAL_CLOSE_POSITION"] };
+const triggerTypeSchema = { type: "string", enum: ["LAST_PRICE", "MARK_PRICE"] };
+export function inputSchemaForName(name) {
+    switch (name) {
+        case "EmptyInput":
+            return objectSchema({});
+        case "SymbolInput":
+            return objectSchema({ symbol: symbolSchema }, ["symbol"]);
+        case "OrderbookInput":
+            return objectSchema({ symbol: symbolSchema, depth: numberSchema }, ["symbol"]);
+        case "KlinesInput":
+            return objectSchema({ symbol: symbolSchema, interval: stringSchema, limit: numberSchema }, ["symbol"]);
+        case "AccountBalanceInput":
+            return objectSchema({ mode: accountBalanceModeSchema, currency: stringSchema });
+        case "OrderLookupInput":
+            return objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, symbol: symbolSchema });
+        case "OrderListInput":
+        case "OrderHistoryInput":
+            return objectSchema({ symbol: symbolSchema, pageSize: numberSchema, startTime: stringSchema, endTime: stringSchema });
+        case "PositionListInput":
+        case "AlgoListInput":
+            return objectSchema({ symbol: symbolSchema });
+        case "PositionHistoryInput":
+            return objectSchema({ symbol: symbolSchema, pageSize: numberSchema, startTime: stringSchema, endTime: stringSchema });
+        case "TradePreviewInput":
+            return objectSchema({
+                targetCapabilityId: targetCapabilityIdSchema,
+                symbol: symbolSchema,
+                side: sideSchema,
+                orderType: orderTypeSchema,
+                price: priceSchema,
+                quantity: quantitySchema,
+                amount: amountSchema,
+                timeInForce: stringSchema,
+                postOnly: booleanSchema,
+                reduceOnly: booleanSchema,
+                maxNotional: maxNotionalSchema,
+                clientOrderId: clientOrderIdSchema,
+                leverage: numberSchema,
+                mode: { type: "string", enum: ["BOTH", "NET"] },
+                exchange: stringSchema,
+                orderId: orderIdSchema,
+                algoOrderId: stringSchema,
+                triggerPrice: stringSchema,
+                triggerType: triggerTypeSchema,
+                conditionType: algoConditionTypeSchema,
+                stopLossPrice: stringSchema,
+                stopLossLimitPrice: stringSchema,
+                takeProfitPrice: stringSchema,
+                takeProfitLimitPrice: stringSchema,
+                algoType: stringSchema,
+                consentId: stringSchema,
+                ...compatibilityProperties()
+            }, ["targetCapabilityId"]);
+        case "PreviewOrderInput":
+            return {
+                ...objectSchema({
+                    ...tradeCreateProperties(),
+                    consentId: stringSchema,
+                    ...compatibilityProperties()
+                }, ["symbol", "side", "orderType", "maxNotional", "clientOrderId"]),
+                oneOf: [{ required: ["quantity"] }, { required: ["amount"] }]
+            };
+        case "PlaceOrderInput":
+            return {
+                ...objectSchema({ ...tradeCreateProperties(), previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, [
+                    "symbol",
+                    "side",
+                    "orderType",
+                    "maxNotional",
+                    "clientOrderId",
+                    "previewId",
+                    "continueConsentId"
+                ]),
+                oneOf: [{ required: ["quantity"] }, { required: ["amount"] }]
+            };
+        case "AmendOrderPreviewInput":
+            return {
+                ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, price: priceSchema, quantity: quantitySchema, ...compatibilityProperties() }),
+                allOf: [
+                    { anyOf: [{ required: ["orderId"] }, { required: ["clientOrderId"] }] },
+                    { anyOf: [{ required: ["price"] }, { required: ["quantity"] }] }
+                ]
+            };
+        case "CancelOrderPreviewInput":
+            return {
+                ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, ...compatibilityProperties() }),
+                anyOf: [{ required: ["orderId"] }, { required: ["clientOrderId"] }]
+            };
+        case "AmendOrderInput":
+            return {
+                ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, price: priceSchema, quantity: quantitySchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["previewId", "continueConsentId"]),
+                allOf: [
+                    { anyOf: [{ required: ["orderId"] }, { required: ["clientOrderId"] }] },
+                    { anyOf: [{ required: ["price"] }, { required: ["quantity"] }] }
+                ]
+            };
+        case "CancelOrderInput":
+            return {
+                ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["previewId", "continueConsentId"]),
+                anyOf: [{ required: ["orderId"] }, { required: ["clientOrderId"] }]
+            };
+        case "ClosePositionInput":
+            return objectSchema({ symbol: symbolSchema, positionSide: positionSideSchema, reduceOnly: closePositionReduceOnlySchema, maxNotional: maxNotionalSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["symbol", "reduceOnly", "maxNotional", "previewId", "continueConsentId"]);
+        case "SetLeverageInput":
+            return objectSchema({ symbol: symbolSchema, leverage: numberSchema, positionSide: stringSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["symbol", "leverage", "previewId", "continueConsentId"]);
+        case "SetPositionModeInput":
+            return objectSchema({ mode: { type: "string", enum: ["BOTH", "NET"] }, exchange: stringSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["mode", "exchange", "previewId", "continueConsentId"]);
+        case "AlgoPlaceInput":
+            return {
+                ...objectSchema({
+                    ...tradeCreateProperties(),
+                    algoType: stringSchema,
+                    positionSide: stringSchema,
+                    conditionType: algoConditionTypeSchema,
+                    triggerPrice: stringSchema,
+                    triggerType: triggerTypeSchema,
+                    stopLossPrice: stringSchema,
+                    stopLossLimitPrice: stringSchema,
+                    takeProfitPrice: stringSchema,
+                    takeProfitLimitPrice: stringSchema,
+                    previewId: previewIdSchema,
+                    continueConsentId: continueConsentIdSchema
+                }, [
+                    "symbol",
+                    "side",
+                    "orderType",
+                    "maxNotional",
+                    "clientOrderId",
+                    "algoType",
+                    "previewId",
+                    "continueConsentId"
+                ]),
+                oneOf: [{ required: ["quantity"] }, { required: ["amount"] }]
+            };
+        case "AlgoAmendInput":
+            return objectSchema({
+                algoOrderId: stringSchema,
+                clientOrderId: clientOrderIdSchema,
+                triggerPrice: stringSchema,
+                triggerType: triggerTypeSchema,
+                stopLossPrice: stringSchema,
+                stopLossLimitPrice: stringSchema,
+                takeProfitPrice: stringSchema,
+                takeProfitLimitPrice: stringSchema,
+                previewId: previewIdSchema,
+                continueConsentId: continueConsentIdSchema
+            }, ["previewId", "continueConsentId"]);
+        case "AlgoCancelInput":
+            return objectSchema({ algoOrderId: stringSchema, clientOrderId: clientOrderIdSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["previewId", "continueConsentId"]);
+        case "TradingVerificationInput":
+            return objectSchema({ symbol: symbolSchema, side: sideSchema, maxNotional: maxNotionalSchema, clientOrderId: clientOrderIdSchema, explicitUserConsent: booleanSchema, acceptedRiskText: stringSchema }, ["symbol", "side", "maxNotional", "clientOrderId"]);
+        case "ConfigGetInput":
+        case "ConfigUnsetInput":
+            return objectSchema({ key: stringSchema }, ["key"]);
+        case "ConfigSetInput":
+            return objectSchema({ key: stringSchema, value: stringSchema }, ["key", "value"]);
+        case "AuthInput":
+            return objectSchema({ source: stringSchema, credentialSource: stringSchema, accessKey: stringSchema, secretKey: stringSchema });
+        case "DoctorInput":
+            return objectSchema({ commandLine: stringSchema, preflightError: stringSchema });
+        case "InvocationCheckInput":
+            return objectSchema({ commandLine: stringSchema, preflightError: stringSchema });
+        case "UpdateCheckInput":
+            return objectSchema({ force: booleanSchema, manifestUrl: stringSchema, maxCacheAgeSeconds: numberSchema });
+        case "SchemaQuery":
+            return objectSchema({ consumer: stringSchema, consumerVersion: stringSchema, includeExamples: booleanSchema });
+        case "SelfCheckInput":
+            return objectSchema({ scope: stringSchema, readOnly: booleanSchema, checkUpdates: booleanSchema });
+        default:
+            return objectSchema({});
+    }
+}
+export function assertInputMatchesSchema(schemaName, input, options = {}) {
+    const schema = inputSchemaForName(schemaName);
+    const allowedFields = new Set(Object.keys(schema.properties));
+    for (const field of options.allowedExtraFields ?? []) {
+        allowedFields.add(field);
+    }
+    const ignoredRequiredFields = new Set(options.ignoredRequiredFields ?? []);
+    const problems = [];
+    for (const [key, value] of Object.entries(input)) {
+        const fieldSchema = schema.properties[key];
+        if (!fieldSchema) {
+            if (!schema.additionalProperties && !allowedFields.has(key)) {
+                if (schemaName === "ClosePositionInput" && key === "side") {
+                    problems.push("position.close does not accept side; close side is determined by the current position");
+                }
+                else if (schemaName === "ClosePositionInput" && key === "quantity") {
+                    problems.push("position.close does not accept quantity; RapidX close-position closes the target symbol/positionSide. Use a reduce-only order for partial close");
+                }
+                else {
+                    problems.push(`unknown field: ${key}`);
+                }
+            }
+            continue;
+        }
+        if (!matchesType(value, fieldSchema)) {
+            problems.push(`invalid type for ${key}`);
+        }
+        if (fieldSchema.enum && typeof value === "string" && !fieldSchema.enum.includes(value)) {
+            problems.push(`invalid value for ${key}`);
+        }
+    }
+    for (const field of schema.required ?? []) {
+        if (ignoredRequiredFields.has(field)) {
+            continue;
+        }
+        if (!hasValue(input[field])) {
+            problems.push(`missing required field: ${field}`);
+        }
+    }
+    if (schema.oneOf && !schema.oneOf.some((candidate) => (candidate.required ?? []).every((field) => hasValue(input[field])))) {
+        const labels = schema.oneOf.map((candidate) => (candidate.required ?? []).join(", ")).join(" or ");
+        problems.push(`missing one of: ${labels}`);
+    }
+    if (schema.anyOf) {
+        collectAnyOfProblem(schema.anyOf, input, problems);
+    }
+    for (const group of schema.allOf ?? []) {
+        if (group.required) {
+            for (const field of group.required) {
+                if (!hasValue(input[field])) {
+                    problems.push(`missing required field: ${field}`);
+                }
+            }
+        }
+        if (group.anyOf) {
+            collectAnyOfProblem(group.anyOf, input, problems);
+        }
+    }
+    if (problems.length > 0) {
+        throw new ProductError({
+            code: "RCORE00001",
+            status: "FAIL",
+            message: `Input schema validation failed: ${problems.join("; ")}.`
+        });
+    }
+    void allowedFields;
+}
+function collectAnyOfProblem(rules, input, problems) {
+    if (!rules.some((candidate) => (candidate.required ?? []).every((field) => hasValue(input[field])))) {
+        const labels = rules.map((candidate) => (candidate.required ?? []).join(", ")).join(" or ");
+        problems.push(`missing any of: ${labels}`);
+    }
+}
+function objectSchema(properties, required) {
+    return {
+        type: "object",
+        additionalProperties: false,
+        properties,
+        ...(required ? { required } : {})
+    };
+}
+function tradeCreateProperties() {
+    return {
+        symbol: symbolSchema,
+        side: sideSchema,
+        orderType: orderTypeSchema,
+        price: priceSchema,
+        quantity: quantitySchema,
+        amount: amountSchema,
+        notional: stringSchema,
+        timeInForce: stringSchema,
+        postOnly: booleanSchema,
+        reduceOnly: booleanSchema,
+        maxNotional: maxNotionalSchema,
+        clientOrderId: clientOrderIdSchema
+    };
+}
+function compatibilityProperties() {
+    return {
+        mcpSchemaVersion: stringSchema,
+        skillsVersion: stringSchema,
+        skillsSchemaVersion: stringSchema
+    };
+}
+function matchesType(value, schema) {
+    if (value === undefined || value === null) {
+        return true;
+    }
+    if (!schema.type) {
+        return true;
+    }
+    return typeof value === schema.type;
+}
+function hasValue(value) {
+    return value !== undefined && value !== null && value !== "";
+}

package/dist/core/contracts/types.js

@@ -0,0 +1 @@
+export const SCHEMA_VERSION = "2026-05-23";

package/dist/core/errors/product-error.js

@@ -0,0 +1,74 @@
+export class ProductError extends Error {
+    code;
+    status;
+    details;
+    constructor(options) {
+        super(options.message);
+        this.name = "ProductError";
+        this.code = options.code;
+        this.status = options.status;
+        if (options.details) {
+            this.details = options.details;
+        }
+    }
+    toEnvelope(evidence = []) {
+        return {
+            ok: false,
+            status: this.status,
+            code: this.code,
+            message: this.message,
+            evidence
+        };
+    }
+}
+export const CORE_ERRORS = {
+    MISSING_CREDENTIAL: "RCORE01001",
+    INVALID_CREDENTIAL: "RCORE01002",
+    MISSING_API_HOST: "RCORE01003",
+    SECRET_REDACTION_RISK: "RCORE90002",
+    UPSTREAM_REJECTED: "RCORE22001",
+    UPSTREAM_TIMEOUT: "RCORE23002",
+    UPSTREAM_RATE_LIMITED: "RCORE23003",
+    SCHEMA_INVALID: "RCORE30001"
+};
+export function normalizeUnknownError(error, fallbackCode = "RCORE00001") {
+    if (error instanceof ProductError) {
+        return error;
+    }
+    if (isUpstreamNetworkError(error)) {
+        return new ProductError({
+            code: CORE_ERRORS.UPSTREAM_TIMEOUT,
+            status: "FAIL",
+            message: "Upstream request failed before receiving a response."
+        });
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return new ProductError({
+        code: fallbackCode,
+        status: "FAIL",
+        message
+    });
+}
+function isUpstreamNetworkError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    if (error.name === "AbortError" || error.name === "TimeoutError") {
+        return true;
+    }
+    if (error.message === "fetch failed" || error.message.includes("network")) {
+        return true;
+    }
+    const cause = error.cause;
+    if (!cause || typeof cause !== "object") {
+        return false;
+    }
+    const code = cause.code;
+    return typeof code === "string" && [
+        "ECONNRESET",
+        "ECONNREFUSED",
+        "ENOTFOUND",
+        "ETIMEDOUT",
+        "EAI_AGAIN"
+    ].includes(code);
+}

package/dist/core/index.js

@@ -0,0 +1,24 @@
+export * from "./contracts/types.js";
+export * from "./contracts/capabilities.js";
+export * from "./contracts/events.js";
+export * from "./contracts/input-schema.js";
+export * from "./contracts/evidence.js";
+export * from "./contracts/compatibility.js";
+export * from "./config/credential.js";
+export * from "./config/resolve.js";
+export * from "./audit/redaction.js";
+export * from "./audit/writer.js";
+export * from "./errors/product-error.js";
+export * from "./client/signing.js";
+export * from "./client/rapid-x-client.js";
+export * from "./client/capability-executor.js";
+export * from "./client/symbol.js";
+export * from "./safety/policy.js";
+export * from "./safety/raw-api.js";
+export * from "./trading/preview.js";
+export * from "./update/check-update.js";
+export * from "./self-check/run-self-check.js";
+export * from "./self-check/live-read-only-probes.js";
+export * from "./self-check/live-trading-verification-probes.js";
+export * from "./trading/trading-verification.js";
+export * from "./version.js";