@liquiditytech/rapidx-cli 1.0.28 → 1.0.29

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, resolvePreviewStoreFile, runPreviewPreflight, savePreviewStoreToFile, verifyPreview } from "../../core/index.js";
 import { fail, ok } from "../envelope.js";
 import { writeCliAudit } from "../audit.js";
 const safetyState = makeSafetyState();
@@ -12,6 +12,7 @@ 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}`);
         }
@@ -28,6 +29,7 @@ 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}`);
         }

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, resolvePreviewStoreFile, runPreviewPreflight, savePreviewStoreToFile } from "../../core/index.js";
 import { fail, ok } from "../envelope.js";
 const safetyState = makeSafetyState();
 export async function runTradeCommand(action, input) {
@@ -17,6 +17,7 @@ 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");
     }

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

@@ -32,7 +32,7 @@ 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"]));
         case "order.list":
@@ -49,10 +49,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 +71,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 +98,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 +111,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 +119,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 +163,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 +220,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 +232,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 +259,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),
@@ -377,6 +407,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/rapid-x-client.js

@@ -65,10 +65,10 @@ 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 } : {}) }
                 });
@@ -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,25 @@ 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;
+    }
+    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 +169,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 +180,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.3";
 export const RAPIDX_SKILLS_SCHEMA_VERSION = "1.0.0";
 export function buildCompatibilityReport(input = {}) {
     const checks = [

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

@@ -1,10 +1,10 @@
-import { ProductError } from "../errors/product-error.js";
+import { CORE_ERRORS, 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. Recommended format: BINANCE_PERP_<BASE>_<QUOTE>.",
+    description: "RapidX symbol. Recommended format: BINANCE_PERP_<BASE>_<QUOTE>. OKX_PERP_<BASE>_<QUOTE> is supported; OKX_SWAP_<BASE>_<QUOTE> is accepted as an input alias and normalized to OKX_PERP.",
     examples: ["BINANCE_PERP_BTC_USDT", "BINANCE_PERP_ETH_USDT"]
 };
 const sideSchema = {
@@ -15,7 +15,7 @@ const sideSchema = {
 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."
+    description: "Order type. MARKET is allowed when the write operation passes preview and consent checks; preview includes immediate-execution and slippage risk notes."
 };
 const priceSchema = {
     type: "string",
@@ -55,6 +55,19 @@ const acceptedRiskTextSchema = {
     description: "Human confirmation text bound to the exact symbol, side, maxNotional, real-order risk, and cancel/cleanup behavior.",
     examples: ["I authorize a real verification order for BINANCE_PERP_BTC_USDT BUY maxNotional 10 with cancel cleanup."]
 };
+const automationModeSchema = {
+    type: "boolean",
+    description: "Set true only when the human user has explicitly enabled RapidX automation mode in chat for this preview."
+};
+const automationConsentTextSchema = {
+    type: "string",
+    description: "Human chat authorization text for automation mode. The agent must not invent this text.",
+    examples: ["I enable RapidX automation mode for BINANCE_PERP_BTC_USDT with maxNotional 100 and accept automated preview-submit execution."]
+};
+const automationScopeSchema = {
+    type: "string",
+    description: "Optional automation scope label, for example single-preview, strategy-session, or the user's exact scope phrase."
+};
 const previewIdSchema = {
     type: "string",
     description: "Preview id returned by the matching preview tool or command.",
@@ -82,6 +95,7 @@ const accountBalanceModeSchema = {
 };
 const positionSideSchema = {
     type: "string",
+    enum: ["LONG", "SHORT"],
     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 = {
@@ -121,6 +135,7 @@ export function inputSchemaForName(name) {
                 price: priceSchema,
                 quantity: quantitySchema,
                 amount: amountSchema,
+                positionSide: positionSideSchema,
                 timeInForce: stringSchema,
                 postOnly: booleanSchema,
                 reduceOnly: booleanSchema,
@@ -140,6 +155,7 @@ export function inputSchemaForName(name) {
                 takeProfitLimitPrice: stringSchema,
                 algoType: stringSchema,
                 consentId: stringSchema,
+                ...automationProperties(),
                 ...compatibilityProperties()
             }, ["targetCapabilityId"]);
         case "PreviewOrderInput":
@@ -147,6 +163,7 @@ export function inputSchemaForName(name) {
                 ...objectSchema({
                     ...tradeCreateProperties(),
                     consentId: stringSchema,
+                    ...automationProperties(),
                     ...compatibilityProperties()
                 }, ["symbol", "side", "orderType", "maxNotional", "clientOrderId"]),
                 oneOf: [{ required: ["quantity"] }, { required: ["amount"] }]
@@ -166,7 +183,7 @@ export function inputSchemaForName(name) {
             };
         case "AmendOrderPreviewInput":
             return {
-                ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, price: priceSchema, quantity: quantitySchema, ...compatibilityProperties() }),
+                ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, price: priceSchema, quantity: quantitySchema, ...automationProperties(), ...compatibilityProperties() }),
                 allOf: [
                     { anyOf: [{ required: ["orderId"] }, { required: ["clientOrderId"] }] },
                     { anyOf: [{ required: ["price"] }, { required: ["quantity"] }] }
@@ -174,7 +191,7 @@ export function inputSchemaForName(name) {
             };
         case "CancelOrderPreviewInput":
             return {
-                ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, ...compatibilityProperties() }),
+                ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, ...automationProperties(), ...compatibilityProperties() }),
                 anyOf: [{ required: ["orderId"] }, { required: ["clientOrderId"] }]
             };
         case "AmendOrderInput":
@@ -193,7 +210,7 @@ export function inputSchemaForName(name) {
         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"]);
+            return objectSchema({ symbol: symbolSchema, leverage: numberSchema, positionSide: positionSideSchema, 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":
@@ -201,7 +218,6 @@ export function inputSchemaForName(name) {
                 ...objectSchema({
                     ...tradeCreateProperties(),
                     algoType: stringSchema,
-                    positionSide: stringSchema,
                     conditionType: algoConditionTypeSchema,
                     triggerPrice: stringSchema,
                     triggerType: triggerTypeSchema,
@@ -221,7 +237,7 @@ export function inputSchemaForName(name) {
                     "previewId",
                     "continueConsentId"
                 ]),
-                oneOf: [{ required: ["quantity"] }, { required: ["amount"] }]
+                anyOf: [{ required: ["quantity"] }, { required: ["amount"] }, { required: ["conditionType"] }]
             };
         case "AlgoAmendInput":
             return objectSchema({
@@ -244,6 +260,7 @@ export function inputSchemaForName(name) {
                 side: sideSchema,
                 maxNotional: maxNotionalSchema,
                 clientOrderId: clientOrderIdSchema,
+                positionSide: positionSideSchema,
                 explicitUserConsent: explicitUserConsentSchema,
                 acceptedRiskText: acceptedRiskTextSchema
             }, ["symbol", "side", "maxNotional", "clientOrderId", "explicitUserConsent", "acceptedRiskText"]);
@@ -326,15 +343,27 @@ export function assertInputMatchesSchema(schemaName, input, options = {}) {
             collectAnyOfProblem(group.anyOf, input, problems);
         }
     }
+    collectSchemaSpecificProblems(schemaName, input, problems);
     if (problems.length > 0) {
         throw new ProductError({
-            code: "RCORE00001",
-            status: "FAIL",
+            code: CORE_ERRORS.SCHEMA_INVALID,
+            status: "INVALID_INPUT",
             message: `Input schema validation failed: ${problems.join("; ")}.`
         });
     }
     void allowedFields;
 }
+function collectSchemaSpecificProblems(schemaName, input, problems) {
+    if (schemaName !== "AlgoPlaceInput") {
+        return;
+    }
+    if (String(input.conditionType ?? "").toUpperCase() !== "ENTIRE_CLOSE_POSITION") {
+        return;
+    }
+    if (!hasValue(input.stopLossPrice) && !hasValue(input.takeProfitPrice)) {
+        problems.push("TPSL ENTIRE_CLOSE_POSITION requires stopLossPrice or takeProfitPrice");
+    }
+}
 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 ");
@@ -362,7 +391,15 @@ function tradeCreateProperties() {
         postOnly: booleanSchema,
         reduceOnly: booleanSchema,
         maxNotional: maxNotionalSchema,
-        clientOrderId: clientOrderIdSchema
+        clientOrderId: clientOrderIdSchema,
+        positionSide: positionSideSchema
+    };
+}
+function automationProperties() {
+    return {
+        automationMode: automationModeSchema,
+        automationConsentText: automationConsentTextSchema,
+        automationScope: automationScopeSchema
     };
 }
 function compatibilityProperties() {

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

@@ -27,6 +27,8 @@ export const CORE_ERRORS = {
     MISSING_API_HOST: "RCORE01003",
     SECRET_REDACTION_RISK: "RCORE90002",
     UPSTREAM_REJECTED: "RCORE22001",
+    PERMISSION_SCOPE_ERROR: "RCORE01004",
+    NOT_FOUND: "RCORE22004",
     UPSTREAM_TIMEOUT: "RCORE23002",
     UPSTREAM_RATE_LIMITED: "RCORE23003",
     SCHEMA_INVALID: "RCORE30001"

package/dist/core/index.js

@@ -16,6 +16,7 @@ export * from "./client/symbol.js";
 export * from "./safety/policy.js";
 export * from "./safety/raw-api.js";
 export * from "./trading/preview.js";
+export * from "./trading/preview-preflight.js";
 export * from "./update/check-update.js";
 export * from "./self-check/run-self-check.js";
 export * from "./self-check/live-read-only-probes.js";

package/dist/core/safety/policy.js

@@ -78,8 +78,8 @@ export function evaluateSafety(capability, input, policy, state = makeSafetyStat
             return { allowed: false, code: "RCORE00001", reason: "mode must be BOTH or NET.", paramsHash };
         }
     }
-    if (String(input.orderType ?? "").toUpperCase() === "MARKET" && (policy.marketOrderPolicy ?? "BLOCK_BY_DEFAULT") === "BLOCK_BY_DEFAULT") {
-        return { allowed: false, code: "RCORE20002", reason: "Market orders are blocked by default.", paramsHash };
+    if (String(input.orderType ?? "").toUpperCase() === "MARKET" && (policy.marketOrderPolicy ?? "ALLOW") === "BLOCK_BY_DEFAULT") {
+        return { allowed: false, code: "RCORE20002", reason: "Market orders are blocked by safety policy.", paramsHash };
     }
     if (requiresNotionalLimit(capability)) {
         const maxNotional = input.maxNotional ?? policy.maxNotional;
@@ -114,7 +114,7 @@ function requiredTradeFields(capability, input) {
             requireString(input, "orderType", missing);
             requireString(input, "clientOrderId", missing);
             requireString(input, "maxNotional", missing);
-            if (!hasString(input, "quantity") && !hasString(input, "amount")) {
+            if (!hasString(input, "quantity") && !hasString(input, "amount") && !isEntireCloseAlgo(capability, input)) {
                 missing.push("quantity or amount");
             }
             if (String(input.orderType ?? "").toUpperCase() === "LIMIT") {
@@ -194,6 +194,9 @@ function stringValue(value) {
 function hasString(input, field) {
     return typeof input[field] === "string" && input[field].length > 0;
 }
+function isEntireCloseAlgo(capability, input) {
+    return capability.capabilityId === "algo.place" && String(input.conditionType ?? "").toUpperCase() === "ENTIRE_CLOSE_POSITION";
+}
 function requireString(input, field, missing) {
     if (!hasString(input, field)) {
         missing.push(field);

package/dist/core/self-check/live-trading-verification-probes.js

@@ -13,6 +13,7 @@ export function buildLiveTradingVerificationProbes(input = {}) {
                 orderType: "LIMIT",
                 price: orderInput.price,
                 quantity: orderInput.quantity,
+                positionSide: orderInput.positionSide,
                 maxNotional: orderInput.maxNotional,
                 clientOrderId: orderInput.clientOrderId,
                 postOnly: true,
@@ -34,7 +35,7 @@ export function buildLiveTradingVerificationProbes(input = {}) {
                 previewId: `internal-${order.orderId}`,
                 continueConsentId: continueConsentId(order.orderId, "cancel")
             });
-            const data = extractDataObject(result);
+            const data = extractDataObject(extractWrappedResponse(result));
             const status = normalizeOrderStatus(stringField(data, "orderState") ?? stringField(data, "action") ?? "");
             if (status === "CANCELED") {
                 return { orderId: order.orderId, status };
@@ -186,6 +187,12 @@ function extractDataObject(result) {
     }
     return {};
 }
+function extractWrappedResponse(result) {
+    if (result && typeof result === "object" && !Array.isArray(result) && Object.prototype.hasOwnProperty.call(result, "response")) {
+        return result.response;
+    }
+    return result;
+}
 function extractArrayData(result) {
     const data = extractData(result);
     if (Array.isArray(data)) {