@senpi/runtime 1.0.95-dev.20260408174401

package/dist/senpi/client.js

@@ -0,0 +1,779 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { MCP_BASE_URL } from "./constants.js";
+import { isRecord, unwrapEnvelope, asString, asNumber } from "../utils/response.js";
+import { extractMinClearingHouseTime, createClearingHouseStalenessGuard } from "../utils/clearing-house-staleness.js";
+import { normalizeDslCoinDex, reconcileDexFromClearingHouseKey } from "../utils/perp-coin.js";
+import { createLogger } from "../utils/logger.js";
+const logger = createLogger("[senpi][client]");
+/**
+ * execution_get_order_status payloads vary: flat `{ filled, status }` vs Hyperliquid-style
+ * `{ status: "order", order: { status: "filled", order: {...} } }`. Top-level `status` may be a
+ * discriminant ("order"), not the fill state — do not treat it as filled unless it is "filled".
+ */
+function parseExecutionOrderFilled(obj) {
+    if (obj.filled === true)
+        return true;
+    const top = obj.status;
+    if (typeof top === "string" && top.toUpperCase() === "FILLED")
+        return true;
+    const wrap = obj.order;
+    if (isRecord(wrap)) {
+        if (wrap.filled === true)
+            return true;
+        const os = wrap.status;
+        if (typeof os === "string" && os.toUpperCase() === "FILLED")
+            return true;
+    }
+    return false;
+}
+export class SenpiClient {
+    // Injected mode
+    injectedTransport;
+    // Self-managed mode
+    config;
+    mcpClient = null;
+    clearingHouseStaleness = createClearingHouseStalenessGuard();
+    // Exponential backoff defaults for retrying stale clearingHouse responses.
+    staleRetryMaxAttempts = 3;
+    staleRetryBaseDelayMs = 4_000;
+    constructor(transportOrConfig) {
+        if (typeof transportOrConfig === 'function') {
+            this.injectedTransport = transportOrConfig;
+            this.config = null;
+        }
+        else {
+            this.injectedTransport = null;
+            this.config = transportOrConfig;
+        }
+    }
+    async connect() {
+        if (this.injectedTransport)
+            return; // no-op in injected mode
+        const apiKey = this.config?.apiKey?.trim() ||
+            process.env.SENPI_API_KEY?.trim() ||
+            '';
+        if (!apiKey) {
+            throw new Error('SenpiClient requires apiKey or SENPI_API_KEY env var');
+        }
+        const url = this.config?.mcpUrl
+            ? new URL(this.config.mcpUrl)
+            : process.env.SENPI_MCP_URL
+                ? new URL(process.env.SENPI_MCP_URL)
+                : new URL(MCP_BASE_URL);
+        const transport = new StreamableHTTPClientTransport(url, {
+            requestInit: {
+                headers: { Authorization: `Bearer ${apiKey}` },
+            },
+        });
+        const client = new Client({
+            name: this.config?.clientName ?? 'senpi-client',
+            version: this.config?.clientVersion ?? '0.0.1',
+        });
+        await client.connect(transport);
+        this.mcpClient = client;
+    }
+    async disconnect() {
+        if (this.injectedTransport)
+            return; // no-op in injected mode
+        if (this.mcpClient) {
+            try {
+                this.mcpClient.close();
+            }
+            catch {
+                // ignore on teardown
+            }
+            this.mcpClient = null;
+        }
+    }
+    async callTool(toolName, args) {
+        // Injected mode: delegate directly
+        if (this.injectedTransport) {
+            return this.injectedTransport(toolName, args);
+        }
+        // Self-managed mode: call via MCP client
+        if (!this.mcpClient) {
+            throw new Error('SenpiClient not connected — call connect() first');
+        }
+        const result = await this.mcpClient.callTool({ name: toolName, arguments: args });
+        if (result.content && Array.isArray(result.content) && result.content.length > 0) {
+            const part = result.content[0];
+            if (part && 'text' in part && typeof part.text === 'string') {
+                try {
+                    return JSON.parse(part.text);
+                }
+                catch {
+                    return part.text;
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Returns an adapter compatible with SenpiToolClient so the same connection
+     * can be used for scanner provider MCP tool calls (e.g. leaderboard_get_markets).
+     */
+    asToolClient() {
+        return {
+            callTool: (name, args) => this.callTool(name, args),
+        };
+    }
+    async createPosition(request) {
+        console.log('[SenpiClient] createPosition request:', JSON.stringify(request, null, 2));
+        const raw = await this.callTool('create_position', {
+            strategyWalletAddress: request.strategyWalletAddress,
+            orders: request.orders,
+            ...(request.reason != null ? { reason: request.reason } : {}),
+        });
+        console.log('[SenpiClient] createPosition raw response:', JSON.stringify(raw, null, 2));
+        return parseCreatePositionResult(raw);
+    }
+    /**
+     * Fetch market prices. Main DEX is passed as dex: ""; use dex: "xyz" for xyz.
+     * If assets is omitted, the MCP returns all asset prices for that dex.
+     */
+    async getMarketPrices(params) {
+        const raw = await this.callTool("market_get_prices", {
+            dex: params.dex || "",
+            ...(params.assets != null && params.assets.length > 0 ? { assets: params.assets } : {}),
+        });
+        const unwrapped = unwrapEnvelope(raw) ?? raw;
+        if (unwrapped == null || typeof unwrapped !== "object")
+            return null;
+        const obj = unwrapped;
+        const prices = (obj.prices ?? obj);
+        const out = {};
+        for (const [k, v] of Object.entries(prices)) {
+            const n = typeof v === "number" ? v : typeof v === "string" ? Number(v) : NaN;
+            if (Number.isFinite(n))
+                out[k] = n;
+        }
+        return Object.keys(out).length > 0 ? out : null;
+    }
+    /**
+     * Set/update SL (and optionally TP) on an open position. Uses MCP edit_position.
+     * For XYZ DEX pass dex: "xyz" so coin is sent as "xyz:COIN"; otherwise main DEX uses plain coin.
+     */
+    async editPosition(wallet, payload) {
+        const coin = payload.dex === "xyz" && payload.coin && !payload.coin.startsWith("xyz:")
+            ? `xyz:${payload.coin}`
+            : payload.coin;
+        const stopLoss = payload.stopLoss != null
+            ? { price: payload.stopLoss.triggerPx }
+            : undefined;
+        const args = {
+            strategyWalletAddress: wallet,
+            coin,
+            ...(stopLoss != null ? { stopLoss } : {}),
+        };
+        const raw = await this.callTool("edit_position", args);
+        logger.info("edit_position raw response", {
+            wallet,
+            coin,
+            rawKeys: isRecord(raw) ? Object.keys(raw) : [],
+            rawShape: isRecord(raw) ? JSON.stringify(raw).slice(0, 500) : String(raw),
+        });
+        const result = (unwrapEnvelope(raw) ?? raw);
+        if (result && typeof result === "object" && !Array.isArray(result)) {
+            const ro = result;
+            const slOrderId = extractSlOrderId(ro, raw);
+            logger.info("edit_position parsed", {
+                wallet,
+                coin,
+                slOrderId,
+                unwrappedKeys: Object.keys(ro),
+                hasStopLossOrderResult: "StopLossOrderResult" in ro || "stopLossOrderResult" in ro,
+            });
+            if (slOrderId != null && Number.isFinite(slOrderId)) {
+                return { ...result, slOrderId };
+            }
+            const actions = ro.actionsPerformed;
+            if (Array.isArray(actions) && (actions.includes("stop_loss_updated") || actions.includes("stop_loss_placed"))) {
+                logger.warn("edit_position reported SL update but slOrderId not found in response; state will have slOrderId=null", {
+                    keys: Object.keys(ro),
+                    rawKeys: isRecord(raw) ? Object.keys(raw) : [],
+                });
+            }
+        }
+        return result;
+    }
+    async getOrderStatus(wallet, orderId) {
+        const raw = await this.callTool("execution_get_order_status", { user: wallet, orderId });
+        if (raw == null || typeof raw !== "object")
+            return null;
+        const unwrapped = unwrapEnvelope(raw) ?? raw;
+        if (unwrapped == null || typeof unwrapped !== "object" || Array.isArray(unwrapped))
+            return null;
+        const obj = unwrapped;
+        return { filled: parseExecutionOrderFilled(obj) };
+    }
+    /**
+     * Fetch full clearing house state for a wallet (main + xyz DEXes) from MCP.
+     *
+     * Retries with exponential backoff when the API returns stale data (timestamp
+     * older than previously observed). Non-stale failures (null response, error
+     * envelopes) are returned immediately without retrying.
+     */
+    async getClearingHouseState(wallet) {
+        for (let attempt = 1; attempt <= this.staleRetryMaxAttempts; attempt++) {
+            const result = await this.fetchClearingHouseStateOnce(wallet);
+            if (result.outcome !== "stale")
+                return result.data;
+            // Last attempt — don't wait, just return null.
+            if (attempt === this.staleRetryMaxAttempts) {
+                logger.warn("getClearingHouseState: all retries exhausted, response still stale", {
+                    wallet,
+                    attempts: attempt,
+                });
+                return null;
+            }
+            const delayMs = this.staleRetryBaseDelayMs * Math.pow(2, attempt - 1);
+            logger.warn("getClearingHouseState: stale response, retrying", {
+                wallet,
+                attempt,
+                nextRetryMs: delayMs,
+                responseTime: result.responseTime,
+                lastClearingHouseTime: this.clearingHouseStaleness.getLastTime(wallet),
+            });
+            await this.delay(delayMs);
+        }
+        return null;
+    }
+    /**
+     * Single fetch + validate attempt. Returns a tagged result so the caller can
+     * distinguish stale responses (retryable) from other failures (not retryable).
+     */
+    async fetchClearingHouseStateOnce(wallet) {
+        const raw = await this.callTool("strategy_get_clearinghouse_state", { strategy_wallet: wallet });
+        const unwrapped = unwrapEnvelope(raw);
+        if (unwrapped == null || typeof unwrapped !== "object")
+            return { outcome: "error", data: null };
+        const obj = unwrapped;
+        if (obj.success === false) {
+            logger.warn("getClearingHouseState: API returned error envelope", {
+                wallet,
+                error: obj.error,
+            });
+            return { outcome: "error", data: null };
+        }
+        const responseTime = extractMinClearingHouseTime(obj);
+        if (this.clearingHouseStaleness.isStale(wallet, responseTime)) {
+            return { outcome: "stale", data: null, responseTime };
+        }
+        return { outcome: "ok", data: obj };
+    }
+    /** Overridable delay for testing. */
+    delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Fetch position (szi, entryPx, leverage) from clearing house for a wallet+coin.
+     * Uses getClearingHouseState so one MCP call returns both main and xyz (and other) DEX positions;
+     * then looks up the position for the given coin (and optional dex).
+     */
+    async getPosition(wallet, coin, dex) {
+        const state = await this.getClearingHouseState(wallet);
+        if (state == null)
+            return null;
+        return findPositionInClearingHouseStateOrFallback(state, coin, dex);
+    }
+    /**
+     * Resolve several assets from one clearing house fetch (single `strategy_get_clearinghouse_state` call).
+     */
+    async getPositionsForAssets(wallet, assets, dex) {
+        const normalized = assets.map((a) => a.trim()).filter((a) => a.length > 0);
+        if (normalized.length === 0)
+            return [];
+        const state = await this.getClearingHouseState(wallet);
+        if (state == null) {
+            return normalized.map((asset) => ({ asset, position: null }));
+        }
+        return normalized.map((asset) => ({
+            asset,
+            position: findPositionInClearingHouseStateOrFallback(state, asset, dex),
+        }));
+    }
+    async closePosition(wallet, coin, params) {
+        const effectiveCoin = params.dex === "xyz" && coin && !coin.startsWith("xyz:") ? `xyz:${coin}` : coin;
+        return this.callTool("close_position", {
+            strategyWalletAddress: wallet,
+            coin: effectiveCoin,
+            ...(params.reason ? { reason: params.reason } : {}),
+        });
+    }
+    /**
+     * List open positions for reconciliation by parsing `strategy_get_clearinghouse_state` (same source as
+     * {@link getPosition} / getPositionsForAssets). Does not call `list_open_positions`.
+     * DEX keys `main` map to reconciler dex `""` to match DSL state paths; `xyz` stays `xyz`.
+     */
+    async listOpenPositions(wallet) {
+        const state = await this.getClearingHouseState(wallet);
+        if (state == null) {
+            logger.warn("listOpenPositions: clearing house state null", { wallet });
+            throw new Error("strategy_get_clearinghouse_state: empty or invalid response");
+        }
+        if (!clearingHouseStateLooksParsable(state)) {
+            logger.warn("listOpenPositions: clearing house response not recognizable", {
+                wallet,
+                keys: Object.keys(state),
+            });
+            throw new Error("strategy_get_clearinghouse_state: unexpected response shape");
+        }
+        return openPositionsFromClearingHouseState(state);
+    }
+    // ─── New MCP methods ────────────────────────────────────────────────────────
+    async getStrategy(wallet) {
+        const raw = await this.callTool("strategy_get", { strategy_wallet: wallet });
+        const data = unwrapEnvelope(raw);
+        if (!isRecord(data))
+            return null;
+        return {
+            strategyId: asString(data.strategyId) ?? asString(data.id) ?? "",
+            name: asString(data.name) ?? "",
+            status: asString(data.status) ?? "",
+            traderAddress: asString(data.traderAddress) ?? "",
+            initialBudget: asNumber(data.initialBudget) ?? 0,
+            totalPnl: asNumber(data.totalPnl) ?? 0,
+            pnlPercentage: asNumber(data.pnlPercentage) ?? 0,
+            createdAt: asString(data.createdAt) ?? "",
+        };
+    }
+    async listStrategies(filters) {
+        const args = {};
+        if (filters?.strategyAddresses)
+            args.strategy_addresses = filters.strategyAddresses;
+        if (filters?.status)
+            args.status = filters.status;
+        if (filters?.strategyIds)
+            args.strategy_ids = filters.strategyIds;
+        if (filters?.strategyType)
+            args.strategy_type = filters.strategyType;
+        const raw = await this.callTool("strategy_list", args);
+        const data = unwrapEnvelope(raw);
+        const strategies = isRecord(data) && Array.isArray(data.strategies)
+            ? data.strategies
+            : [];
+        return strategies.filter(isRecord).map((s) => ({
+            id: asString(s.id) ?? "",
+            strategyWalletAddress: asString(s.strategyWalletAddress) ?? "",
+            traderAddress: asString(s.traderAddress) ?? "",
+            status: asString(s.status) ?? "",
+            strategyType: asString(s.strategyType) ?? "",
+            strategyName: asString(s.strategyName) ?? asString(s.name) ?? "",
+            createdAt: asString(s.createdAt) ?? "",
+            totalFunded: asNumber(s.totalFunded) ?? 0,
+        }));
+    }
+    async getOpenOrders(wallet) {
+        const raw = await this.callTool("strategy_get_open_orders", { strategy_wallet: wallet });
+        const data = unwrapEnvelope(raw);
+        const arr = Array.isArray(data) ? data : (isRecord(data) && Array.isArray(data.orders) ? data.orders : []);
+        return arr.filter(isRecord).map((o) => ({
+            orderId: asNumber(o.orderId) ?? 0,
+            coin: asString(o.coin) ?? "",
+            side: (asString(o.side) ?? "BUY"),
+            size: asNumber(o.size) ?? asNumber(o.sz) ?? 0,
+            price: asNumber(o.price) ?? asNumber(o.limitPx) ?? 0,
+            orderType: asString(o.orderType) ?? asString(o.type) ?? "",
+            status: asString(o.status) ?? "",
+            timestamp: asNumber(o.timestamp) ?? 0,
+        }));
+    }
+    async getTraderHistory(wallet, opts) {
+        const args = { traderAddress: wallet, latest: true };
+        if (opts?.limit != null)
+            args.limit = opts.limit;
+        if (opts?.offset != null)
+            args.offset = opts.offset;
+        if (opts?.sort_by != null)
+            args.sort_by = opts.sort_by;
+        if (opts?.sort_direction != null)
+            args.sort_direction = opts.sort_direction;
+        const raw = await this.callTool("discovery_get_trader_history", args);
+        const data = unwrapEnvelope(raw);
+        const arr = Array.isArray(data) ? data : (isRecord(data) && Array.isArray(data.trades) ? data.trades : []);
+        return arr.filter(isRecord).map((t) => {
+            const szi = asNumber(t.szi) ?? 0;
+            return {
+                coin: asString(t.coin) ?? "",
+                direction: (szi >= 0 ? "LONG" : "SHORT"),
+                entryPx: asNumber(t.entryPx) ?? 0,
+                closePx: asNumber(t.closePx) ?? 0,
+                szi,
+                realizedPnl: asNumber(t.realizedPnl) ?? 0,
+                closedTime: asNumber(t.closedTime) ?? asNumber(t.closeTime) ?? 0,
+                openTime: asNumber(t.openTime) ?? 0,
+                totalFees: asNumber(t.totalFees) ?? 0,
+            };
+        });
+    }
+    async topUp(wallet, amount) {
+        const raw = await this.callTool("strategy_top_up", { strategy_wallet: wallet, amount });
+        const data = unwrapEnvelope(raw);
+        if (!isRecord(data))
+            return { success: false };
+        return { success: data.success === true, message: asString(data.message) ?? undefined };
+    }
+    async withdrawFunds(wallet, amount) {
+        const raw = await this.callTool("strategy_withdraw_funds", { strategy_wallet: wallet, amount });
+        const data = unwrapEnvelope(raw);
+        if (!isRecord(data))
+            return { success: false };
+        return { success: data.success === true, message: asString(data.message) ?? undefined };
+    }
+    async closeStrategy(wallet) {
+        const raw = await this.callTool("strategy_close", { strategy_wallet: wallet });
+        const data = unwrapEnvelope(raw);
+        if (!isRecord(data))
+            return { success: false };
+        return { success: data.success === true, message: asString(data.message) ?? undefined };
+    }
+    async closePositions(wallet, positions) {
+        return this.callTool("strategy_close_positions", {
+            strategy_wallet: wallet,
+            positions,
+        });
+    }
+    async cancelOrder(wallet, orderId) {
+        return this.callTool("cancel_order", {
+            strategyWalletAddress: wallet,
+            orderId,
+        });
+    }
+    async getAssetTradingLimits(wallet, coin, dex) {
+        try {
+            const args = { strategy_wallet: wallet, coin };
+            if (dex != null)
+                args.dex = dex;
+            const raw = await this.callTool("strategy_get_asset_trading_limits", args);
+            const data = unwrapEnvelope(raw) ?? raw;
+            if (!isRecord(data))
+                return null;
+            const leverage = data.leverage;
+            const value = leverage != null ? asNumber(leverage.value) : asNumber(data.maxLeverage);
+            if (value == null)
+                return null;
+            return { maxLeverage: value };
+        }
+        catch (err) {
+            logger.warn("getAssetTradingLimits failed", { wallet, coin, err });
+            return null;
+        }
+    }
+    async listInstruments() {
+        const raw = await this.callTool("market_list_instruments", {});
+        const unwrapped = unwrapEnvelope(raw) ?? raw;
+        if (unwrapped == null || typeof unwrapped !== "object")
+            return [];
+        const obj = unwrapped;
+        const instrumentsRaw = obj.instruments;
+        if (!Array.isArray(instrumentsRaw))
+            return [];
+        const result = [];
+        for (const row of instrumentsRaw) {
+            if (!isRecord(row))
+                continue;
+            const name = asString(row.name);
+            const maxLeverage = asNumber(row.max_leverage);
+            if (name != null && maxLeverage != null) {
+                result.push({ name, maxLeverage });
+            }
+        }
+        return result;
+    }
+    async getPnlHistory(wallet, opts) {
+        const args = { strategy_wallet: wallet };
+        if (opts?.period != null)
+            args.period = opts.period;
+        return this.callTool("strategy_get_pnl_and_account_value_history", args);
+    }
+}
+// ─── Response parsing ────────────────────────────────────────────────────────
+/**
+ * Extract SL order ID from edit_position response. Tries multiple common shapes
+ * so state gets slOrderId even when MCP returns it under different keys.
+ * MCP may return: data.ordersUpdated.stopLoss.orderId or StopLossOrderResult.orderId.
+ */
+function extractSlOrderId(unwrapped, raw) {
+    const from = (v) => (v != null && Number.isFinite(asNumber(v)) ? asNumber(v) : null);
+    const fromObj = (obj, key) => obj && typeof obj === "object" && key in obj ? from(obj[key]) : null;
+    const ou = unwrapped.ordersUpdated;
+    const stopLossObj = ou && typeof ou === "object" && "stopLoss" in ou ? ou.stopLoss : undefined;
+    let n = from(unwrapped.slOrderId)
+        ?? (ou && "slOrderId" in ou ? from(ou.slOrderId) : null)
+        ?? from(unwrapped.stopLossOrderId)
+        ?? from(ou?.stopLossOrderId)
+        ?? fromObj(stopLossObj, "orderId")
+        ?? fromObj(unwrapped.StopLossOrderResult, "orderId")
+        ?? fromObj(unwrapped.stopLossOrderResult, "orderId");
+    if (n != null)
+        return n;
+    if (isRecord(raw) && isRecord(raw.data)) {
+        const data = raw.data;
+        const dataOu = data.ordersUpdated;
+        const dataStopLoss = dataOu && typeof dataOu === "object" && "stopLoss" in dataOu ? dataOu.stopLoss : undefined;
+        n =
+            from(data.slOrderId)
+                ?? from(dataOu?.slOrderId)
+                ?? from(data.stopLossOrderId)
+                ?? fromObj(dataStopLoss, "orderId")
+                ?? fromObj(data.StopLossOrderResult, "orderId")
+                ?? fromObj(data.stopLossOrderResult, "orderId");
+        if (n != null)
+            return n;
+    }
+    return null;
+}
+function parseCreatePositionResult(raw) {
+    const data = unwrapEnvelope(raw);
+    if (!isRecord(data)) {
+        return { success: false, orders: [], error: 'Invalid response shape' };
+    }
+    const success = typeof data.success === 'boolean' ? data.success : false;
+    const error = typeof data.error === 'string' ? data.error
+        : typeof data.message === 'string' ? data.message
+            : null;
+    const rawOrders = Array.isArray(data.results) ? data.results : (Array.isArray(data.orders) ? data.orders : []);
+    const orders = [];
+    for (const row of rawOrders) {
+        if (!isRecord(row))
+            continue;
+        // MCP response nests fill data under mainOrder
+        const mainOrder = isRecord(row.mainOrder) ? row.mainOrder : row;
+        // error can be an object { code, description } or a string
+        const rowError = isRecord(row.error)
+            ? asString(row.error.description) ?? asString(row.error.code)
+            : asString(row.error);
+        orders.push({
+            coin: asString(row.coin) ?? asString(mainOrder.coin) ?? '',
+            direction: asDirection(row.direction) ?? asDirection(mainOrder.direction) ?? 'LONG',
+            leverage: asNumber(row.leverage) ?? asNumber(mainOrder.leverage) ?? 0,
+            marginAmount: asNumber(row.marginAmount) ?? asNumber(row.marginUsed) ?? 0,
+            entryPrice: asNumber(mainOrder.avgPrice) ?? asNumber(mainOrder.entryPrice) ?? asNumber(row.avgPrice),
+            size: asNumber(mainOrder.filledSize) ?? asNumber(mainOrder.size) ?? asNumber(row.filledSize),
+            filled: String(mainOrder.status).toUpperCase() === 'FILLED' || (typeof row.filled === 'boolean' ? row.filled : false),
+            orderId: stringifyId(mainOrder.orderId) ?? stringifyId(row.orderId),
+            executionAsMaker: typeof mainOrder.executionAsMaker === 'boolean' ? mainOrder.executionAsMaker : null,
+            error: rowError,
+        });
+    }
+    return { success, orders, error };
+}
+// ─── Clearing house state lookup ─────────────────────────────────────────────
+function positionFromRaw(obj) {
+    const rawSzi = asNumber(obj.szi) ?? asNumber(obj.size);
+    const entryPx = asNumber(obj.entryPx) ?? asNumber(obj.entryPrice) ?? asNumber(obj.avgPrice);
+    if (rawSzi == null || entryPx == null || !Number.isFinite(rawSzi) || !Number.isFinite(entryPx)) {
+        return null;
+    }
+    const mag = Math.abs(rawSzi);
+    if (mag === 0)
+        return null;
+    const explicitDir = asDirection(obj.direction);
+    // When the venue includes an explicit direction, trust it for the sign of `szi`. Some MCP responses
+    // briefly keep the old signed szi after a flip while `direction` already reflects the new side.
+    const szi = explicitDir === "LONG" ? mag : explicitDir === "SHORT" ? -mag : rawSzi;
+    let leverage = asNumber(obj.leverage);
+    if (leverage == null && isRecord(obj.leverage) && typeof obj.leverage.value === "number") {
+        leverage = obj.leverage.value;
+    }
+    const result = { szi, entryPx };
+    if (leverage != null && Number.isFinite(leverage))
+        result.leverage = leverage;
+    return result;
+}
+/** Compare using {@link normalizeDslCoinDex} (base coin + dex bucket). */
+function coinMatches(pos, searchCoin, rowDex, searchDex) {
+    const raw = asString(pos.coin) ?? asString(pos.asset) ?? "";
+    const a = normalizeDslCoinDex(raw, rowDex);
+    const bDex = searchDex === undefined || searchDex === null ? rowDex : searchDex;
+    const b = normalizeDslCoinDex(searchCoin, bDex);
+    return a.coin === b.coin && a.dex === b.dex;
+}
+/**
+ * True if the payload looks like Senpi/Hyperliquid clearing house (so an empty list means no positions,
+ * not an unrelated JSON object).
+ */
+function clearingHouseStateLooksParsable(state) {
+    if (Array.isArray(state.positions ?? state.positionsList))
+        return true;
+    for (const v of Object.values(state)) {
+        if (!isRecord(v))
+            continue;
+        if (Array.isArray(v.assetPositions))
+            return true;
+        if (v.crossMarginSummary != null || v.withdrawable != null)
+            return true;
+    }
+    return false;
+}
+/**
+ * Collect non-zero-size positions from clearing house state for reconciliation.
+ */
+function openPositionsFromClearingHouseState(state) {
+    const out = [];
+    const flat = state.positions ?? state.positionsList;
+    if (Array.isArray(flat)) {
+        for (const p of flat) {
+            if (!isRecord(p))
+                continue;
+            const pos = isRecord(p.position) ? p.position : p;
+            const parsed = positionFromRaw(pos);
+            if (!parsed || parsed.szi === 0)
+                continue;
+            const coinRaw = asString(pos.coin) ?? asString(pos.asset) ?? "";
+            if (!coinRaw)
+                continue;
+            const dexField = asString(p.dex) ?? "";
+            const reconcileDex = reconcileDexFromClearingHouseKey(dexField);
+            const { coin, dex } = normalizeDslCoinDex(coinRaw, reconcileDex);
+            out.push({
+                coin,
+                dex,
+                szi: parsed.szi,
+                entryPx: parsed.entryPx,
+                ...(parsed.leverage != null ? { leverage: parsed.leverage } : {}),
+            });
+        }
+        return out;
+    }
+    for (const key of Object.keys(state)) {
+        const dexState = state[key];
+        if (!isRecord(dexState))
+            continue;
+        const assetPositions = dexState.assetPositions;
+        if (!Array.isArray(assetPositions))
+            continue;
+        const reconcileDex = reconcileDexFromClearingHouseKey(key);
+        for (const item of assetPositions) {
+            if (!isRecord(item))
+                continue;
+            const pos = isRecord(item.position) ? item.position : item;
+            const parsed = positionFromRaw(pos);
+            if (!parsed || parsed.szi === 0)
+                continue;
+            const coinRaw = asString(pos.coin) ?? asString(pos.asset) ?? "";
+            if (!coinRaw)
+                continue;
+            const { coin, dex } = normalizeDslCoinDex(coinRaw, reconcileDex);
+            out.push({
+                coin,
+                dex,
+                szi: parsed.szi,
+                entryPx: parsed.entryPx,
+                ...(parsed.leverage != null ? { leverage: parsed.leverage } : {}),
+            });
+        }
+    }
+    return out;
+}
+/**
+ * Find a position for the given coin (and optional dex) in clearing house state.
+ * Senpi MCP (strategy_get_clearinghouse_state) returns { main, xyz } where each value is
+ * ClearinghouseState: { assetPositions: [ { type, position: { coin, szi, entryPx, leverage } } ] }.
+ * Also supports flat { positions: [ { coin, dex?, ... } ] } or per-DEX arrays.
+ */
+function findPositionInClearingHouseState(state, coin, dex) {
+    // Single flat list with optional dex on each item
+    const positions = state.positions ?? state.positionsList;
+    if (Array.isArray(positions)) {
+        for (const p of positions) {
+            if (!isRecord(p))
+                continue;
+            const pos = isRecord(p.position) ? p.position : p;
+            const reconcileDex = reconcileDexFromClearingHouseKey(asString(p.dex) ?? "");
+            if (!coinMatches(pos, coin, reconcileDex, dex))
+                continue;
+            if (dex != null && dex !== "" && reconcileDex !== dex)
+                continue;
+            const result = positionFromRaw(pos);
+            if (result)
+                return result;
+        }
+        return null;
+    }
+    // Per-DEX keys (main, xyz): each value is ClearinghouseState with assetPositions.
+    // Never use state[dex] literally — MCP may use "XYZ" vs "xyz"; match by reconciled dex.
+    const keysToSearch = dex != null && dex !== ""
+        ? Object.keys(state).filter((k) => reconcileDexFromClearingHouseKey(k) === dex)
+        : Object.keys(state);
+    for (const key of keysToSearch) {
+        const dexState = state[key];
+        if (dexState == null || typeof dexState !== "object")
+            continue;
+        const dexObj = dexState;
+        const assetPositions = dexObj.assetPositions;
+        if (!Array.isArray(assetPositions))
+            continue;
+        const rowDex = reconcileDexFromClearingHouseKey(key);
+        for (const item of assetPositions) {
+            if (!isRecord(item))
+                continue;
+            const pos = isRecord(item.position) ? item.position : item;
+            if (!coinMatches(pos, coin, rowDex, dex))
+                continue;
+            const result = positionFromRaw(pos);
+            if (result)
+                return result;
+        }
+    }
+    return null;
+}
+/**
+ * Prefer {@link findPositionInClearingHouseState}; if it misses with a dex filter, MCP may use a
+ * different top-level bucket name (`hip3`, builder deployers, etc.) while DSL still uses `xyz`.
+ * Then scan all rows from {@link openPositionsFromClearingHouseState} and match by base coin
+ * (case-insensitive), preferring reconciled dex when multiple rows exist.
+ */
+function findPositionInClearingHouseStateOrFallback(state, coin, dex) {
+    const direct = findPositionInClearingHouseState(state, coin, dex);
+    if (direct)
+        return direct;
+    if (!clearingHouseStateLooksParsable(state))
+        return null;
+    const q = normalizeDslCoinDex(coin.trim(), dex ?? "");
+    const rows = openPositionsFromClearingHouseState(state);
+    let candidates = rows.filter((r) => {
+        const n = normalizeDslCoinDex(r.coin, r.dex ?? "");
+        return n.coin.toUpperCase() === q.coin.toUpperCase();
+    });
+    if (candidates.length === 0)
+        return null;
+    if (q.dex) {
+        const byDex = candidates.filter((r) => normalizeDslCoinDex(r.coin, r.dex ?? "").dex === q.dex);
+        if (byDex.length >= 1)
+            candidates = byDex;
+        // If no bucket matches DSL dex (e.g. only `hip3`), keep all base-coin matches for single-position disambiguation.
+    }
+    const pick = candidates.length === 1
+        ? candidates[0]
+        : candidates.find((r) => normalizeDslCoinDex(r.coin, r.dex ?? "").dex === q.dex) ?? candidates[0];
+    const szi = pick.szi;
+    const entryPx = pick.entryPx;
+    if (szi == null || entryPx == null || !Number.isFinite(szi) || !Number.isFinite(entryPx))
+        return null;
+    return {
+        szi,
+        entryPx,
+        ...(pick.leverage != null && Number.isFinite(pick.leverage) ? { leverage: pick.leverage } : {}),
+    };
+}
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function asDirection(value) {
+    if (value === "LONG" || value === "SHORT")
+        return value;
+    if (typeof value === "string") {
+        const u = value.trim().toUpperCase();
+        if (u === "LONG" || u === "SHORT")
+            return u;
+    }
+    return null;
+}
+function stringifyId(value) {
+    if (typeof value === 'string')
+        return value;
+    if (typeof value === 'number' && Number.isFinite(value))
+        return String(value);
+    return null;
+}
+//# sourceMappingURL=client.js.map