@pgnio/helios-mcp 0.2.9 → 0.5.0

package/dist/index.d.mts

@@ -10,6 +10,8 @@ declare const agentDeviceStartInputSchema: z.ZodObject<{
         "orders:cancel": "orders:cancel";
     }>>;
     constraints: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    verified: z.ZodOptional<z.ZodBoolean>;
+    requireApprovalProof: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 declare const agentDeviceStartOutputSchema: z.ZodObject<{
     deviceCode: z.ZodString;
@@ -67,11 +69,6 @@ declare const openPositionsSnapshotSchema: z.ZodObject<{
         liquidationPrice: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
-declare const portfolioInputSchema: z.ZodObject<{
-    provider: z.ZodEnum<{
-        hyperliquid: "hyperliquid";
-    }>;
-}, z.core.$strip>;
 declare const portfolioSnapshotSchema: z.ZodObject<{
     provider: z.ZodLiteral<"hyperliquid">;
     totalBalance: z.ZodNumber;
@@ -118,6 +115,11 @@ declare const portfolioSnapshotSchema: z.ZodObject<{
         createdAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
+declare const portfolioInputSchema: z.ZodObject<{
+    provider: z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+    }>;
+}, z.core.$strip>;
 declare const ledgerFillsInputSchema: z.ZodObject<{
     window: z.ZodOptional<z.ZodEnum<{
         "24h": "24h";
@@ -373,6 +375,7 @@ declare const submitTradeIntentInputSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     idempotencyKey: z.ZodOptional<z.ZodString>;
+    idempotencyWindowSeconds: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 declare const submitTradeIntentResultSchema: z.ZodObject<{
     status: z.ZodLiteral<"submitted">;
@@ -437,6 +440,7 @@ declare const closePositionInputSchema: z.ZodObject<{
     }>>;
     symbol: z.ZodString;
     maxSlippageBps: z.ZodOptional<z.ZodNumber>;
+    fraction: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 declare const closePositionResultSchema: z.ZodObject<{
     status: z.ZodLiteral<"submitted">;
@@ -448,7 +452,11 @@ declare const closePositionResultSchema: z.ZodObject<{
         hyperliquid: "hyperliquid";
     }>>;
     symbol: z.ZodString;
-    mode: z.ZodLiteral<"FULL">;
+    mode: z.ZodEnum<{
+        FULL: "FULL";
+        PARTIAL: "PARTIAL";
+    }>;
+    fraction: z.ZodOptional<z.ZodNumber>;
     maxSlippageBps: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 declare const setTpSlInputSchema: z.ZodObject<{
@@ -537,6 +545,433 @@ declare const cancelOrderResultSchema: z.ZodObject<{
     symbol: z.ZodString;
     oid: z.ZodNumber;
 }, z.core.$strip>;
+/** Moves a resting order (data-bridge positions.modifyOrder): its limit price, or trigger price for a trigger order. */
+declare const modifyOrderInputSchema: z.ZodObject<{
+    symbol: z.ZodString;
+    oid: z.ZodNumber;
+    price: z.ZodNumber;
+    size: z.ZodNumber;
+}, z.core.$strip>;
+declare const modifyOrderResultSchema: z.ZodObject<{
+    status: z.ZodLiteral<"modified">;
+    symbol: z.ZodString;
+    oid: z.ZodNumber;
+    price: z.ZodNumber;
+    size: z.ZodNumber;
+}, z.core.$strip>;
+/** One paper fill as the paper engine records it (data-bridge services/paper/engine.ts PaperFill). */
+declare const paperFillSchema: z.ZodObject<{
+    ts: z.ZodNumber;
+    coin: z.ZodString;
+    kind: z.ZodString;
+    side: z.ZodNullable<z.ZodEnum<{
+        BUY: "BUY";
+        SELL: "SELL";
+    }>>;
+    size: z.ZodNumber;
+    price: z.ZodNumber;
+    fee: z.ZodNumber;
+    pnl: z.ZodNumber;
+}, z.core.$strip>;
+/** A paper portfolio: the live shape plus the paper account's own totals. */
+declare const paperPortfolioSchema: z.ZodObject<{
+    provider: z.ZodLiteral<"hyperliquid">;
+    totalBalance: z.ZodNumber;
+    availableBalance: z.ZodNumber;
+    totalMargin: z.ZodNumber;
+    unrealizedPnl: z.ZodNumber;
+    positions: z.ZodArray<z.ZodObject<{
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            LONG: "LONG";
+            SHORT: "SHORT";
+        }>;
+        size: z.ZodNumber;
+        entryPrice: z.ZodNumber;
+        markPrice: z.ZodNumber;
+        unrealizedPnl: z.ZodNumber;
+        margin: z.ZodNumber;
+        leverage: z.ZodNumber;
+        liquidationPrice: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    protectiveOrders: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        binanceOrderId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        clientOrderId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        positionSide: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            LONG: "LONG";
+            SHORT: "SHORT";
+            BOTH: "BOTH";
+        }>>>, z.ZodTransform<"LONG" | "SHORT" | "BOTH", "LONG" | "SHORT" | "BOTH" | null | undefined>>;
+        status: z.ZodString;
+        kind: z.ZodEnum<{
+            STOP_LOSS: "STOP_LOSS";
+            TAKE_PROFIT: "TAKE_PROFIT";
+        }>;
+        groupId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        stopPrice: z.ZodPipe<z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>, z.ZodTransform<string | null | undefined, string | number | null | undefined>>;
+        parentClientOrderId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        assetId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        createdAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    cash: z.ZodOptional<z.ZodNumber>;
+    realizedPnl: z.ZodOptional<z.ZodNumber>;
+    feesPaid: z.ZodOptional<z.ZodNumber>;
+    fundingPaid: z.ZodOptional<z.ZodNumber>;
+    liquidations: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const agentMarketInputSchema: z.ZodObject<{
+    coins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        rank: "rank";
+        volume: "volume";
+        move1h: "move1h";
+        move24h: "move24h";
+        funding: "funding";
+        lean: "lean";
+        edge: "edge";
+    }>>;
+    filter: z.ZodOptional<z.ZodEnum<{
+        turning: "turning";
+        falling: "falling";
+        stretched_up: "stretched_up";
+        stretched_down: "stretched_down";
+        sm_long: "sm_long";
+        sm_short: "sm_short";
+        discount: "discount";
+    }>>;
+}, z.core.$strip>;
+declare const agentMarketSchema: z.ZodObject<{
+    asOf: z.ZodNullable<z.ZodString>;
+    smAsOf: z.ZodNullable<z.ZodNumber>;
+    market: z.ZodObject<{
+        os: z.ZodNullable<z.ZodNumber>;
+        mti: z.ZodNullable<z.ZodNumber>;
+        Mti: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    total: z.ZodNumber;
+    offset: z.ZodNumber;
+    rows: z.ZodArray<z.ZodObject<{
+        coin: z.ZodString;
+        rank: z.ZodNullable<z.ZodNumber>;
+        px: z.ZodNullable<z.ZodNumber>;
+        r15m: z.ZodNullable<z.ZodNumber>;
+        r1h: z.ZodNullable<z.ZodNumber>;
+        r24h: z.ZodNullable<z.ZodNumber>;
+        volUsd: z.ZodNullable<z.ZodNumber>;
+        fundAprPct: z.ZodNullable<z.ZodNumber>;
+        oiUsd: z.ZodNullable<z.ZodNumber>;
+        setup: z.ZodNullable<z.ZodEnum<{
+            "turning up from breakdown": "turning up from breakdown";
+            "falling, no turn yet": "falling, no turn yet";
+            "stretched up": "stretched up";
+            "stretched down": "stretched down";
+            neutral: "neutral";
+        }>>;
+        maxLev: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        spreadBps: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        slip10kBps: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        slip100kBps: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        depth1pctUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        sm: z.ZodNullable<z.ZodObject<{
+            side: z.ZodNullable<z.ZodEnum<{
+                long: "long";
+                short: "short";
+            }>>;
+            share: z.ZodNumber;
+            edgePct: z.ZodNullable<z.ZodNumber>;
+            discount: z.ZodNullable<z.ZodEnum<{
+                strict: "strict";
+                fill: "fill";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    next: z.ZodNullable<z.ZodNumber>;
+    unknown: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const smartMoneyBoardInputSchema: z.ZodObject<{
+    view: z.ZodOptional<z.ZodEnum<{
+        discount: "discount";
+        conviction: "conviction";
+        flows: "flows";
+        pileins: "pileins";
+    }>>;
+    side: z.ZodOptional<z.ZodEnum<{
+        any: "any";
+        long: "long";
+        short: "short";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const smartMoneyBoardSchema: z.ZodObject<{
+    asOf: z.ZodNullable<z.ZodNumber>;
+    view: z.ZodEnum<{
+        discount: "discount";
+        conviction: "conviction";
+        flows: "flows";
+        pileins: "pileins";
+    }>;
+    wallets: z.ZodNumber;
+    known: z.ZodNumber;
+    rows: z.ZodArray<z.ZodObject<{
+        coin: z.ZodString;
+        side: z.ZodNullable<z.ZodEnum<{
+            long: "long";
+            short: "short";
+        }>>;
+        share: z.ZodNumber;
+        lean: z.ZodNumber;
+        sideUsd: z.ZodNumber;
+        heads: z.ZodNumber;
+        traders: z.ZodNumber;
+        entry: z.ZodNullable<z.ZodNumber>;
+        mark: z.ZodNullable<z.ZodNumber>;
+        edgePct: z.ZodNullable<z.ZodNumber>;
+        flow1hUsd: z.ZodNumber;
+        discount: z.ZodNullable<z.ZodEnum<{
+            strict: "strict";
+            fill: "fill";
+        }>>;
+        setup: z.ZodNullable<z.ZodEnum<{
+            "turning up from breakdown": "turning up from breakdown";
+            "falling, no turn yet": "falling, no turn yet";
+            "stretched up": "stretched up";
+            "stretched down": "stretched down";
+            neutral: "neutral";
+        }>>;
+        r24h: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    pileIns: z.ZodArray<z.ZodObject<{
+        coin: z.ZodString;
+        side: z.ZodEnum<{
+            long: "long";
+            short: "short";
+        }>;
+        dir: z.ZodEnum<{
+            in: "in";
+            out: "out";
+        }>;
+        traders: z.ZodNumber;
+        totalUsd: z.ZodNumber;
+        weight: z.ZodNumber;
+        names: z.ZodArray<z.ZodString>;
+        first: z.ZodNumber;
+        last: z.ZodNumber;
+    }, z.core.$strip>>;
+    note: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const smartMoneyMovesInputSchema: z.ZodObject<{
+    since: z.ZodOptional<z.ZodString>;
+    coin: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        entries: "entries";
+        exits: "exits";
+    }>>;
+    minUsd: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const smMoveSchema: z.ZodObject<{
+    id: z.ZodString;
+    t: z.ZodNumber;
+    coin: z.ZodString;
+    kind: z.ZodEnum<{
+        open: "open";
+        add: "add";
+        reduce: "reduce";
+        close: "close";
+        flip: "flip";
+    }>;
+    side: z.ZodEnum<{
+        long: "long";
+        short: "short";
+    }>;
+    usd: z.ZodNumber;
+    px: z.ZodNumber;
+    lev: z.ZodNullable<z.ZodNumber>;
+    pnl: z.ZodNullable<z.ZodNumber>;
+    pnlPct: z.ZodNullable<z.ZodNumber>;
+    nick: z.ZodString;
+    rank: z.ZodNumber;
+    style: z.ZodString;
+    win: z.ZodNullable<z.ZodNumber>;
+    w: z.ZodNumber;
+}, z.core.$strip>;
+declare const smartMoneyMovesSchema: z.ZodObject<{
+    order: z.ZodEnum<{
+        newest: "newest";
+        oldest: "oldest";
+    }>;
+    moves: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        t: z.ZodNumber;
+        coin: z.ZodString;
+        kind: z.ZodEnum<{
+            open: "open";
+            add: "add";
+            reduce: "reduce";
+            close: "close";
+            flip: "flip";
+        }>;
+        side: z.ZodEnum<{
+            long: "long";
+            short: "short";
+        }>;
+        usd: z.ZodNumber;
+        px: z.ZodNumber;
+        lev: z.ZodNullable<z.ZodNumber>;
+        pnl: z.ZodNullable<z.ZodNumber>;
+        pnlPct: z.ZodNullable<z.ZodNumber>;
+        nick: z.ZodString;
+        rank: z.ZodNumber;
+        style: z.ZodString;
+        win: z.ZodNullable<z.ZodNumber>;
+        w: z.ZodNumber;
+    }, z.core.$strip>>;
+    next: z.ZodNullable<z.ZodString>;
+    more: z.ZodBoolean;
+    gap: z.ZodBoolean;
+    note: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const smartMoneyCoinSchema: z.ZodObject<{
+    coin: z.ZodString;
+    asOf: z.ZodNullable<z.ZodNumber>;
+    sm: z.ZodNullable<z.ZodObject<{
+        coin: z.ZodString;
+        mark: z.ZodNullable<z.ZodNumber>;
+        long: z.ZodObject<{
+            usd: z.ZodNumber;
+            heads: z.ZodNumber;
+            traders: z.ZodNumber;
+            entry: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        short: z.ZodObject<{
+            usd: z.ZodNumber;
+            heads: z.ZodNumber;
+            traders: z.ZodNumber;
+            entry: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+        lean: z.ZodNumber;
+        side: z.ZodNullable<z.ZodEnum<{
+            long: "long";
+            short: "short";
+        }>>;
+        share: z.ZodNumber;
+        edgePct: z.ZodNullable<z.ZodNumber>;
+        flow1hUsd: z.ZodNumber;
+        conviction: z.ZodNullable<z.ZodNumber>;
+        discount: z.ZodNullable<z.ZodEnum<{
+            strict: "strict";
+            fill: "fill";
+        }>>;
+        pileIn: z.ZodNullable<z.ZodObject<{
+            coin: z.ZodString;
+            side: z.ZodEnum<{
+                long: "long";
+                short: "short";
+            }>;
+            dir: z.ZodEnum<{
+                in: "in";
+                out: "out";
+            }>;
+            traders: z.ZodNumber;
+            totalUsd: z.ZodNumber;
+            weight: z.ZodNumber;
+            names: z.ZodArray<z.ZodString>;
+            first: z.ZodNumber;
+            last: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    market: z.ZodNullable<z.ZodObject<{
+        coin: z.ZodString;
+        rank: z.ZodNullable<z.ZodNumber>;
+        px: z.ZodNullable<z.ZodNumber>;
+        r15m: z.ZodNullable<z.ZodNumber>;
+        r1h: z.ZodNullable<z.ZodNumber>;
+        r24h: z.ZodNullable<z.ZodNumber>;
+        volUsd: z.ZodNullable<z.ZodNumber>;
+        fundAprPct: z.ZodNullable<z.ZodNumber>;
+        oiUsd: z.ZodNullable<z.ZodNumber>;
+        setup: z.ZodNullable<z.ZodEnum<{
+            "turning up from breakdown": "turning up from breakdown";
+            "falling, no turn yet": "falling, no turn yet";
+            "stretched up": "stretched up";
+            "stretched down": "stretched down";
+            neutral: "neutral";
+        }>>;
+        maxLev: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        spreadBps: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        slip10kBps: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        slip100kBps: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        depth1pctUsd: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    moves: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        t: z.ZodNumber;
+        coin: z.ZodString;
+        kind: z.ZodEnum<{
+            open: "open";
+            add: "add";
+            reduce: "reduce";
+            close: "close";
+            flip: "flip";
+        }>;
+        side: z.ZodEnum<{
+            long: "long";
+            short: "short";
+        }>;
+        usd: z.ZodNumber;
+        px: z.ZodNumber;
+        lev: z.ZodNullable<z.ZodNumber>;
+        pnl: z.ZodNullable<z.ZodNumber>;
+        pnlPct: z.ZodNullable<z.ZodNumber>;
+        nick: z.ZodString;
+        rank: z.ZodNumber;
+        style: z.ZodString;
+        win: z.ZodNullable<z.ZodNumber>;
+        w: z.ZodNumber;
+    }, z.core.$strip>>;
+    note: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+declare const marketCandlesInputSchema: z.ZodObject<{
+    symbol: z.ZodString;
+    interval: z.ZodEnum<{
+        "1m": "1m";
+        "3m": "3m";
+        "5m": "5m";
+        "15m": "15m";
+        "30m": "30m";
+        "1h": "1h";
+        "2h": "2h";
+        "4h": "4h";
+        "6h": "6h";
+        "8h": "8h";
+        "12h": "12h";
+        "1d": "1d";
+        "1w": "1w";
+        "1M": "1M";
+    }>;
+    endTime: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const marketCandlesSchema: z.ZodObject<{
+    candles: z.ZodArray<z.ZodObject<{
+        t: z.ZodNumber;
+        o: z.ZodNumber;
+        h: z.ZodNumber;
+        l: z.ZodNumber;
+        c: z.ZodNumber;
+        v: z.ZodNumber;
+    }, z.core.$strip>>;
+    complete: z.ZodBoolean;
+}, z.core.$strip>;
 type AgentDeviceStartInput = z.infer<typeof agentDeviceStartInputSchema>;
 type AgentDeviceStartOutput = z.infer<typeof agentDeviceStartOutputSchema>;
 type AgentTokenResponse = z.infer<typeof agentTokenResponseSchema>;
@@ -566,61 +1001,63 @@ type DeleteTpSlResult = z.infer<typeof deleteTpSlResultSchema>;
 type OpenOrder = z.infer<typeof openOrderSchema>;
 type CancelOrderInput = z.infer<typeof cancelOrderInputSchema>;
 type CancelOrderResult = z.infer<typeof cancelOrderResultSchema>;
+type ModifyOrderInput = z.infer<typeof modifyOrderInputSchema>;
+type ModifyOrderResult = z.infer<typeof modifyOrderResultSchema>;
+type PaperFill = z.infer<typeof paperFillSchema>;
+type PaperPortfolio = z.infer<typeof paperPortfolioSchema>;
+type AgentMarketInput = z.infer<typeof agentMarketInputSchema>;
+type AgentMarket = z.infer<typeof agentMarketSchema>;
+type SmartMoneyBoardInput = z.infer<typeof smartMoneyBoardInputSchema>;
+type SmartMoneyBoard = z.infer<typeof smartMoneyBoardSchema>;
+type SmartMoneyMovesInput = z.infer<typeof smartMoneyMovesInputSchema>;
+type SmMove = z.infer<typeof smMoveSchema>;
+type SmartMoneyMoves = z.infer<typeof smartMoneyMovesSchema>;
+type SmartMoneyCoin = z.infer<typeof smartMoneyCoinSchema>;
+type MarketCandlesInput = z.infer<typeof marketCandlesInputSchema>;
+type MarketCandles = z.infer<typeof marketCandlesSchema>;
 
 type FetchLike = typeof fetch;
 interface HeliosAgentAuthClientOptions {
     baseUrl: string;
     fetch?: FetchLike;
-    headers?: HeadersInit;
+    headers?: Record<string, string>;
+    /**
+     * The hosted MCP's shared secret (identity's AGENT_START_SECRET), sent on device/start only. Without it identity
+     * ignores `verified` and labels a well-known app name as unverified. CLIs leave it unset.
+     */
+    startSecret?: string;
+}
+interface StartLoginOptions {
+    /**
+     * The address of the person the login is for (the hosted MCP's req.ip): identity counts hosted starts per address.
+     * Sent only along with the start secret; without one it would mean nothing to identity, so it is left out.
+     */
+    clientIp?: string;
+}
+interface ExchangeDeviceCodeOptions {
+    /** The proof the approval answered with, for a login started with requireApprovalProof. */
+    approvalProof?: string;
 }
 declare class HeliosAgentAuthClient {
     private readonly baseUrl;
     private readonly fetchImpl;
     private readonly headers;
+    private readonly startSecret;
     constructor(options: HeliosAgentAuthClientOptions);
-    startLogin(input: AgentDeviceStartInput): Promise<AgentDeviceStartOutput>;
-    exchangeDeviceCode(deviceCode: string): Promise<AgentTokenResponse>;
+    startLogin(input: AgentDeviceStartInput, options?: StartLoginOptions): Promise<AgentDeviceStartOutput>;
+    exchangeDeviceCode(deviceCode: string, options?: ExchangeDeviceCodeOptions): Promise<AgentTokenResponse>;
     refreshSession(refreshToken: string): Promise<AgentTokenResponse>;
     private post;
     private parseJson;
 }
-
-interface HeliosAgentDataBridgeClientOptions {
-    baseUrl: string;
-    fetch?: FetchLike;
-}
-declare class HeliosAgentDataBridgeClient {
-    private readonly baseUrl;
-    private readonly fetchImpl;
-    constructor(options: HeliosAgentDataBridgeClientOptions);
-    getWalletState(accessToken: string): Promise<WalletState>;
-    getOpenPositions(accessToken: string): Promise<OpenPositionsSnapshot>;
-    getPortfolio(accessToken: string, input: PortfolioInput): Promise<PortfolioSnapshot>;
-    getLedgerFills(accessToken: string, input?: LedgerFillsInput): Promise<LedgerFillsPage>;
-    getLedgerSummary(accessToken: string, input?: LedgerSummaryInput): Promise<LedgerSummary>;
-    getMarketSnapshot(accessToken: string, input?: MarketSnapshotInput): Promise<MarketSnapshot>;
-    getMarketSnapshotChunk(accessToken: string, input?: MarketSnapshotChunkInput): Promise<MarketSnapshotChunk>;
-    getMarketSymbolDetail(accessToken: string, input: MarketSymbolDetailInput): Promise<MarketSymbolDetail>;
-    submitTradeIntent(accessToken: string, input: SubmitTradeIntentInput): Promise<SubmitTradeIntentResult>;
-    closePosition(accessToken: string, input: ClosePositionInput): Promise<ClosePositionResult>;
-    setTpSl(accessToken: string, input: SetTpSlInput): Promise<SetTpSlResult>;
-    deleteTpSl(accessToken: string, input: DeleteTpSlInput): Promise<DeleteTpSlResult>;
-    getOpenOrders(accessToken: string): Promise<OpenOrder[]>;
-    cancelOrder(accessToken: string, input: CancelOrderInput): Promise<CancelOrderResult>;
-    private request;
-    private buildProcedureUrl;
-    private parseJson;
-    /** The result of a mutation older data-bridges answer with nothing; null when there is none. */
-    private tryUnwrapResult;
-    private unwrapResult;
-    private extractErrorCode;
-    private extractErrorMessage;
-    /**
-     * Unwrap a tRPC error envelope, handling the superjson `{ json: ... }` wrapper
-     * that the data-bridge applies via its transformer configuration.
-     */
-    private unwrapTrpcError;
-}
+/**
+ * The Helios hosts a session came from. A session is only sent back to them, so a config that points the server at
+ * another host never hands it the stored tokens. Optional: sessions stored before it was recorded still load.
+ */
+declare const agentSessionIssuerSchema: z.ZodObject<{
+    identityServiceUrl: z.ZodString;
+    dataBridgeUrl: z.ZodString;
+}, z.core.$strip>;
 declare const storedAgentSessionSchema: z.ZodObject<{
     accessToken: z.ZodString;
     refreshToken: z.ZodString;
@@ -636,6 +1073,10 @@ declare const storedAgentSessionSchema: z.ZodObject<{
     accessTokenExpiresAt: z.ZodString;
     createdAt: z.ZodString;
     lastRefreshedAt: z.ZodString;
+    issuer: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        identityServiceUrl: z.ZodString;
+        dataBridgeUrl: z.ZodString;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 declare const agentSessionViewSchema: z.ZodObject<{
     connected: z.ZodBoolean;
@@ -658,6 +1099,7 @@ declare const agentSessionViewSchema: z.ZodObject<{
     accessTokenExpiresAt: z.ZodOptional<z.ZodString>;
     lastRefreshedAt: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+type AgentSessionIssuer = z.infer<typeof agentSessionIssuerSchema>;
 type StoredAgentSession = z.infer<typeof storedAgentSessionSchema>;
 type AgentSessionView = z.infer<typeof agentSessionViewSchema>;
 interface AgentSessionStore {
@@ -666,6 +1108,203 @@ interface AgentSessionStore {
     clearSession(): Promise<void>;
 }
 
+/** A device login waiting for the person to approve it, as a login store keeps it. */
+declare const pendingAgentLoginSchema$1: z.ZodObject<{
+    status: z.ZodLiteral<"pending">;
+    deviceCode: z.ZodString;
+    userCode: z.ZodString;
+    verificationUri: z.ZodString;
+    verificationUriComplete: z.ZodString;
+    expiresInSeconds: z.ZodNumber;
+    pollIntervalSeconds: z.ZodNumber;
+    requestedScope: z.ZodArray<z.ZodEnum<{
+        "account:read": "account:read";
+        "market:read": "market:read";
+        "orders:write": "orders:write";
+        "orders:cancel": "orders:cancel";
+    }>>;
+    startedAt: z.ZodString;
+}, z.core.$strip>;
+type PendingAgentLogin$1 = z.infer<typeof pendingAgentLoginSchema$1>;
+/** A session store that also keeps the device login in progress. */
+interface AgentLoginStore extends AgentSessionStore {
+    getPendingLogin(): Promise<PendingAgentLogin$1 | null>;
+    setPendingLogin(pendingLogin: PendingAgentLogin$1): Promise<void>;
+    clearPendingLogin(): Promise<void>;
+}
+type AgentStartLoginResult = PendingAgentLogin$1;
+type AgentPendingLoginResult = AgentStartLoginResult & {
+    connected: false;
+    message: string;
+};
+type ConnectedResult = AgentSessionView & {
+    status: 'connected';
+    connected: true;
+};
+type AgentEnsureLoginResult = ConnectedResult | AgentPendingLoginResult;
+type AgentPollLoginResult = ConnectedResult | {
+    status: 'pending' | 'rejected' | 'expired' | 'failed';
+    connected: false;
+    message: string;
+};
+interface AgentEnsureLoginOptions {
+    clientName?: string;
+    scope?: AgentDeviceStartInput['scope'];
+    constraints?: AgentDeviceStartInput['constraints'];
+}
+/** What the person or agent is told at each step; each app words them for its own commands. */
+interface AgentAuthMessages {
+    /** The prompt shown with a login in progress: where to approve it and what to do next. */
+    loginPrompt(result: Pick<AgentStartLoginResult, 'verificationUriComplete' | 'userCode' | 'requestedScope'>): string;
+    /** pollLogin with no login in progress and no session. */
+    noLoginInProgress: string;
+    /** pollLogin with a code that isn't the login in progress. */
+    wrongCode: string;
+    /** The server no longer knows the stored device code (invalid_grant), so a fresh login is needed. */
+    staleLogin: string;
+    /** No session, and this service can't start a login (deviceLogin false). */
+    reconnect: string;
+}
+interface AgentAuthServiceOptions {
+    client: HeliosAgentAuthClient;
+    sessionStore: AgentLoginStore;
+    messages: AgentAuthMessages;
+    refreshWindowMs?: number;
+    now?: () => Date;
+    /** The client name a login is started with when the caller gives none. */
+    defaultClientName: string;
+    /**
+     * False on the hosted MCP server (helios.pgn.io/mcp): the AI app signed in through OAuth and holds the tokens, so this
+     * service never starts a device login of its own; an expired or revoked connection is an error the app answers by
+     * reconnecting. Default true.
+     */
+    deviceLogin?: boolean;
+    /**
+     * True: ensureLogin with a scope the stored session wasn't granted drops that session and starts a login for the wider
+     * scope. False: the session is used as it is, and the server refuses what it isn't allowed. Default false.
+     */
+    reloginForMissingScope?: boolean;
+}
+/**
+ * Device login and session refresh for a Helios delegated agent (helios-cli and helios-agent-mcp). Both refresh and the
+ * device-code exchange are single-flight: refresh tokens rotate and a device code is collected once, so a second
+ * concurrent request with the same token or code would be refused and log the agent out.
+ */
+declare class AgentAuthService {
+    protected readonly client: HeliosAgentAuthClient;
+    protected readonly sessionStore: AgentLoginStore;
+    private readonly messages;
+    private readonly refreshWindowMs;
+    private readonly now;
+    private readonly defaultClientName;
+    private readonly deviceLogin;
+    private readonly reloginForMissingScope;
+    /** The refresh in progress, which concurrent callers join. */
+    private refreshInFlight;
+    /** The device-code exchange in progress, which concurrent polls of the same login join. */
+    private exchangeInFlight;
+    constructor(options: AgentAuthServiceOptions);
+    startLogin(input: AgentDeviceStartInput): Promise<AgentStartLoginResult>;
+    resetSessionAndStartLogin(input: AgentDeviceStartInput): Promise<AgentStartLoginResult>;
+    startRelogin(options?: AgentEnsureLoginOptions): Promise<AgentPendingLoginResult>;
+    clearSessionState(): Promise<void>;
+    /** After a 401 from Helios: drops the session and starts a fresh login. Null for any other error. */
+    invalidateIfUnauthorized(error: unknown, options?: AgentEnsureLoginOptions): Promise<AgentPendingLoginResult | null>;
+    /** After a 401 from Helios: refreshes the session even if it isn't near expiry. Null for any other error. */
+    refreshSessionAfterUnauthorized(error: unknown): Promise<StoredAgentSession | null>;
+    ensureLogin(options?: AgentEnsureLoginOptions): Promise<AgentEnsureLoginResult>;
+    /**
+     * Polls the stored pending login. A code, when given, must be that login's device code or the user code shown to the
+     * person: a code from anywhere else (a prompt injection carrying a login someone else approved) is never exchanged, so
+     * it can't swap the stored session for another account's.
+     */
+    pollLogin(code?: string): Promise<AgentPollLoginResult>;
+    whoami(): Promise<AgentSessionView>;
+    getAccessToken(): Promise<string | null>;
+    getPendingLoginState(): Promise<PendingAgentLogin$1 | null>;
+    requireSession(): Promise<StoredAgentSession>;
+    private loginInput;
+    private pendingResult;
+    private getValidSession;
+    /**
+     * Refreshes `seen` (the session the caller read), joining a refresh already in progress. `force` refreshes even a
+     * session that isn't near expiry (Helios just answered 401 to it).
+     */
+    private refreshStoredSession;
+    private refreshOnce;
+    private exchangePendingLogin;
+    private exchangeOnce;
+    private getPendingLogin;
+    private clearPendingLoginIfMatches;
+}
+/**
+ * After a 401 from Helios: refreshes the session and retries once with the new access token. If no refresh is possible,
+ * or the retry is refused too, starts a fresh login and returns it. Rethrows anything else.
+ */
+declare function retryAfterUnauthorizedRefresh<T>(options: {
+    authService: AgentAuthService;
+    error: unknown;
+    loginOptions: AgentEnsureLoginOptions;
+    retry: (accessToken: string) => Promise<T>;
+}): Promise<T | AgentPendingLoginResult | null>;
+
+interface HeliosAgentDataBridgeClientOptions {
+    baseUrl: string;
+    fetch?: FetchLike;
+}
+declare class HeliosAgentDataBridgeClient {
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    constructor(options: HeliosAgentDataBridgeClientOptions);
+    getWalletState(accessToken: string): Promise<WalletState>;
+    getOpenPositions(accessToken: string): Promise<OpenPositionsSnapshot>;
+    getPortfolio(accessToken: string, input: PortfolioInput): Promise<PortfolioSnapshot>;
+    getLedgerFills(accessToken: string, input?: LedgerFillsInput): Promise<LedgerFillsPage>;
+    getLedgerSummary(accessToken: string, input?: LedgerSummaryInput): Promise<LedgerSummary>;
+    getMarketSnapshot(accessToken: string, input?: MarketSnapshotInput): Promise<MarketSnapshot>;
+    getMarketSnapshotChunk(accessToken: string, input?: MarketSnapshotChunkInput): Promise<MarketSnapshotChunk>;
+    getMarketSymbolDetail(accessToken: string, input: MarketSymbolDetailInput): Promise<MarketSymbolDetail>;
+    /** The lean market table: price, two returns, volume, funding, open interest, setup label and the smart money lean. */
+    getAgentMarket(accessToken: string, input?: AgentMarketInput): Promise<AgentMarket>;
+    getMarketCandles(accessToken: string, input: MarketCandlesInput): Promise<MarketCandles>;
+    /** The research wallets' smart money board (conviction, discount, flows or pile-ins). */
+    getSmartMoneyBoard(accessToken: string, input?: SmartMoneyBoardInput): Promise<SmartMoneyBoard>;
+    /** Their trades by nickname: the latest, or only what came after an earlier call's `next`. */
+    getSmartMoneyMoves(accessToken: string, input?: SmartMoneyMovesInput): Promise<SmartMoneyMoves>;
+    /** One coin: their book, its market row and their latest trades on it. */
+    getSmartMoneyCoin(accessToken: string, coin: string): Promise<SmartMoneyCoin>;
+    submitTradeIntent(accessToken: string, input: SubmitTradeIntentInput): Promise<SubmitTradeIntentResult>;
+    closePosition(accessToken: string, input: ClosePositionInput): Promise<ClosePositionResult>;
+    setTpSl(accessToken: string, input: SetTpSlInput): Promise<SetTpSlResult>;
+    deleteTpSl(accessToken: string, input: DeleteTpSlInput): Promise<DeleteTpSlResult>;
+    getOpenOrders(accessToken: string): Promise<OpenOrder[]>;
+    cancelOrder(accessToken: string, input: CancelOrderInput): Promise<CancelOrderResult>;
+    modifyOrder(accessToken: string, input: ModifyOrderInput): Promise<ModifyOrderResult>;
+    getPaperPortfolio(accessToken: string, accountId?: string): Promise<PaperPortfolio>;
+    /** A paper market order; answers with its fills (none when nothing filled). */
+    submitPaperIntent(accessToken: string, input: SubmitTradeIntentInput, accountId?: string): Promise<PaperFill[]>;
+    /** Closes all or part of a paper position; no fills when there was none. */
+    closePaperPosition(accessToken: string, input: ClosePositionInput, accountId?: string): Promise<PaperFill[]>;
+    setPaperTpSl(accessToken: string, input: SetTpSlInput, accountId?: string): Promise<SetTpSlResult>;
+    deletePaperTpSl(accessToken: string, input: DeleteTpSlInput, accountId?: string): Promise<DeleteTpSlResult>;
+    getPaperLedgerFills(accessToken: string, input?: LedgerFillsInput, accountId?: string): Promise<LedgerFillsPage>;
+    /** Starts the paper account over with `startingBalance` USD (data-bridge's default when omitted). */
+    resetPaperAccount(accessToken: string, startingBalance?: number, accountId?: string): Promise<void>;
+    private request;
+    private buildProcedureUrl;
+    private parseJson;
+    /** The result of a mutation older data-bridges answer with nothing; null when there is none. */
+    private tryUnwrapResult;
+    private unwrapResult;
+    private extractErrorCode;
+    private extractErrorMessage;
+    /**
+     * Unwrap a tRPC error envelope, handling the superjson `{ json: ... }` wrapper
+     * that the data-bridge applies via its transformer configuration.
+     */
+    private unwrapTrpcError;
+}
+
 declare function getDefaultHeliosAgentMcpSessionPath(): string;
 declare const pendingAgentLoginSchema: z.ZodObject<{
     status: z.ZodLiteral<"pending">;
@@ -682,19 +1321,30 @@ declare const pendingAgentLoginSchema: z.ZodObject<{
         "orders:cancel": "orders:cancel";
     }>>;
     startedAt: z.ZodString;
+    issuer: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        identityServiceUrl: z.ZodString;
+        dataBridgeUrl: z.ZodString;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 type PendingAgentLogin = z.infer<typeof pendingAgentLoginSchema>;
-interface AgentMcpSessionStore extends AgentSessionStore {
+interface AgentMcpSessionStore extends AgentLoginStore {
     getActiveProvider(): Promise<Provider | null>;
     setActiveProvider(provider: Provider): Promise<void>;
     clearActiveProvider(): Promise<void>;
     getPendingLogin(): Promise<PendingAgentLogin | null>;
     setPendingLogin(pendingLogin: PendingAgentLogin): Promise<void>;
-    clearPendingLogin(): Promise<void>;
+}
+interface FileAgentSessionStoreOptions {
+    /**
+     * The hosts this server sends tokens to. Sessions and logins are stored with it and only read back for the same hosts,
+     * so pointing the server at another Helios (a staging URL, an edited .mcp.json) never sends it the stored tokens.
+     */
+    issuer?: AgentSessionIssuer | null;
 }
 declare class FileAgentSessionStore implements AgentMcpSessionStore {
     private readonly filePath;
-    constructor(filePath?: string);
+    private readonly issuer;
+    constructor(filePath?: string, options?: FileAgentSessionStoreOptions);
     getSession(): Promise<StoredAgentSession | null>;
     getPendingLogin(): Promise<PendingAgentLogin | null>;
     getActiveProvider(): Promise<Provider | null>;
@@ -704,9 +1354,14 @@ declare class FileAgentSessionStore implements AgentMcpSessionStore {
     clearSession(): Promise<void>;
     clearPendingLogin(): Promise<void>;
     clearActiveProvider(): Promise<void>;
+    private isFromIssuer;
+    /**
+     * Read-modify-write under the file's lock: tool calls run concurrently and several MCP processes can share the file,
+     * so without it one write could drop another's (a refreshed session, a pending login).
+     */
+    private update;
     private readState;
     private writeState;
-    private writeStateOrDelete;
     private deleteFile;
 }
 /**
@@ -747,6 +1402,11 @@ declare class HeliosAgentMcpProviderService {
     resolveProvider(explicitProvider?: Provider): Promise<Provider>;
 }
 
+type StartLoginResult = AgentStartLoginResult;
+type EnsureLoginResult = AgentEnsureLoginResult;
+type PendingLoginResult = AgentPendingLoginResult;
+type PollLoginResult = AgentPollLoginResult;
+type EnsureLoginOptions = AgentEnsureLoginOptions;
 interface HeliosAgentMcpAuthServiceOptions {
     client: HeliosAgentAuthClient;
     sessionStore: AgentMcpSessionStore;
@@ -759,73 +1419,10 @@ interface HeliosAgentMcpAuthServiceOptions {
     deviceLogin?: boolean;
 }
 declare const HOSTED_RECONNECT_MESSAGE = "Helios no longer accepts this connection (it expired or was revoked). Reconnect Helios in your AI app to continue.";
-interface StartLoginResult {
-    status: 'pending';
-    deviceCode: string;
-    userCode: string;
-    verificationUri: string;
-    verificationUriComplete: string;
-    expiresInSeconds: number;
-    pollIntervalSeconds: number;
-    requestedScope: AgentDeviceStartInput['scope'];
-    startedAt: string;
-}
-type EnsureLoginResult = (AgentSessionView & {
-    status: 'connected';
-    connected: true;
-}) | (StartLoginResult & {
-    connected: false;
-    message: string;
-});
-type PendingLoginResult = StartLoginResult & {
-    connected: false;
-    message: string;
-};
-type PollLoginResult = (AgentSessionView & {
-    status: 'connected';
-    connected: true;
-}) | {
-    status: 'pending' | 'rejected' | 'expired' | 'failed';
-    connected: false;
-    message: string;
-};
-interface EnsureLoginOptions {
-    clientName?: string;
-    scope?: AgentDeviceStartInput['scope'];
-    constraints?: AgentDeviceStartInput['constraints'];
-}
-declare class HeliosAgentMcpAuthService {
-    private readonly client;
-    private readonly sessionStore;
-    private readonly refreshWindowMs;
-    private readonly now;
-    private readonly deviceLogin;
+/** The shared delegated-agent sign-in (AgentAuthService), worded for MCP tools. */
+declare class HeliosAgentMcpAuthService extends AgentAuthService {
     constructor(options: HeliosAgentMcpAuthServiceOptions);
-    startLogin(input: AgentDeviceStartInput): Promise<StartLoginResult>;
-    resetSessionAndStartLogin(input: AgentDeviceStartInput): Promise<StartLoginResult>;
-    private startDeviceLogin;
-    private buildStartLoginResult;
-    startRelogin(options?: EnsureLoginOptions): Promise<PendingLoginResult>;
-    clearSessionState(): Promise<void>;
-    invalidateIfUnauthorized(error: unknown, options?: EnsureLoginOptions): Promise<PendingLoginResult | null>;
-    refreshSessionAfterUnauthorized(error: unknown): Promise<StoredAgentSession | null>;
-    ensureLogin(options?: EnsureLoginOptions): Promise<EnsureLoginResult>;
-    /** Polls the given login, or the stored pending one when no device code is given. */
-    pollLogin(deviceCode?: string): Promise<PollLoginResult>;
-    whoami(): Promise<AgentSessionView>;
-    getAccessToken(): Promise<string | null>;
-    requireSession(): Promise<StoredAgentSession>;
-    private getValidSession;
-    private refreshStoredSession;
-    private getPendingLogin;
-    private clearPendingLoginIfMatches;
 }
-declare function retryAfterUnauthorizedRefresh<T>(options: {
-    authService: HeliosAgentMcpAuthService;
-    error: unknown;
-    loginOptions: EnsureLoginOptions;
-    retry: (accessToken: string) => Promise<T>;
-}): Promise<T | PendingLoginResult | null>;
 declare function formatHeliosLoginPrompt(result: Pick<StartLoginResult, 'verificationUriComplete' | 'userCode' | 'requestedScope'>): string;
 
 interface HeliosAgentMcpAccountServiceOptions {
@@ -895,6 +1492,18 @@ declare class HeliosAgentMcpDocsService {
 }
 declare function getDefaultHeliosAgentMcpDocsRoot(): string;
 
+/** Helios's public gateway serves both identity (/api/agents) and data-bridge (/api/trpc). */
+declare const DEFAULT_HELIOS_BASE_URL = "https://helios.pgn.io";
+/** Sessions stored before the issuer was recorded could only have come from the public gateway. */
+declare const DEFAULT_HELIOS_SESSION_ISSUER: AgentSessionIssuer;
+/**
+ * Checks a Helios base URL the local server sends the stored tokens to: https, or plain http to localhost only, so a
+ * config can't send them in clear text or to a host by mistake. Returns the value unchanged.
+ */
+declare function assertHeliosBaseUrl(name: string, value: string): string;
+/** True when a stored session or login came from the hosts this server is configured for. */
+declare function isSameHeliosIssuer(stored: AgentSessionIssuer | null | undefined, configured: AgentSessionIssuer): boolean;
+
 interface HeliosAgentMcpLedgerServiceOptions {
     authService: HeliosAgentMcpAuthService;
     dataBridgeClient: HeliosAgentDataBridgeClient;
@@ -1043,6 +1652,16 @@ declare class HeliosAgentMcpTradingService {
     private submitIntent;
 }
 
+/**
+ * Which tools a server lists (Mario 2026-10-26, the lean MCP):
+ * - lean: the 9 smart-money-first tools (reads, your trades, trade, protect, candles) with short text answers, for small models (Qwen 27B
+ *   at 32k) and most agents;
+ * - signals: the reads of lean, with trade and protect on the practice account only, for agents that watch or practice;
+ * - full: lean plus the depth reads (the ~50-column snapshot, symbol detail with raw indicators, fills, the
+ *   indicator docs), for strong models that do their own analysis.
+ */
+type McpProfile = 'lean' | 'signals' | 'full';
+declare const MCP_PROFILES: readonly McpProfile[];
 interface CreateHeliosAgentMcpServerOptions {
     identityServiceUrl: string;
     dataBridgeUrl: string;
@@ -1056,7 +1675,10 @@ interface CreateHeliosAgentMcpServerOptions {
      * left out (whoami stays) and no tool ever starts a login of its own.
      */
     hosted?: boolean;
+    /** Default full, which keeps every read tool; the CLI and the hosted /mcp pass lean. */
+    profile?: McpProfile;
 }
+declare const MAX_TOOL_INPUT_ELEMENTS = 10000;
 declare function createHeliosAgentMcpServer(options: CreateHeliosAgentMcpServerOptions): Promise<{
     server: McpServer;
     authService: HeliosAgentMcpAuthService;
@@ -1142,11 +1764,15 @@ declare function createHeliosAuthToolDefinitions(service: HeliosAgentMcpAuthServ
             "orders:cancel": "orders:cancel";
         }>>;
         constraints: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        verified: z.ZodOptional<z.ZodBoolean>;
+        requireApprovalProof: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;
     execute(input: {
         clientName: string;
         scope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
         constraints?: Record<string, unknown> | undefined;
+        verified?: boolean | undefined;
+        requireApprovalProof?: boolean | undefined;
     }): Promise<{
         content: {
             type: "text";
@@ -1157,7 +1783,6 @@ declare function createHeliosAuthToolDefinitions(service: HeliosAgentMcpAuthServ
             loginUrl: string;
             nextStep: string;
             status: "pending";
-            deviceCode: string;
             userCode: string;
             verificationUri: string;
             verificationUriComplete: string;
@@ -1202,7 +1827,6 @@ declare function createHeliosAuthToolDefinitions(service: HeliosAgentMcpAuthServ
             actionRequired: true;
             loginUrl: string;
             nextStep: string;
-            deviceCode: string;
             userCode: string;
             verificationUri: string;
             verificationUriComplete: string;
@@ -1322,7 +1946,7 @@ declare function createHeliosAccountToolDefinitions(service: HeliosAgentMcpAccou
             verificationUriComplete: string;
             expiresInSeconds: number;
             pollIntervalSeconds: number;
-            requestedScope: AgentDeviceStartInput["scope"];
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
             startedAt: string;
         };
     }>;
@@ -1359,7 +1983,7 @@ declare function createHeliosAccountToolDefinitions(service: HeliosAgentMcpAccou
             verificationUriComplete: string;
             expiresInSeconds: number;
             pollIntervalSeconds: number;
-            requestedScope: AgentDeviceStartInput["scope"];
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
             startedAt: string;
         };
     }>;
@@ -1391,7 +2015,7 @@ declare function createHeliosLedgerToolDefinitions(service: HeliosAgentMcpLedger
             verificationUriComplete: string;
             expiresInSeconds: number;
             pollIntervalSeconds: number;
-            requestedScope: AgentDeviceStartInput["scope"];
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
             startedAt: string;
         };
     }>;
@@ -1434,7 +2058,7 @@ declare function createHeliosLedgerToolDefinitions(service: HeliosAgentMcpLedger
             verificationUriComplete: string;
             expiresInSeconds: number;
             pollIntervalSeconds: number;
-            requestedScope: AgentDeviceStartInput["scope"];
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
             startedAt: string;
         };
     }>;
@@ -1473,7 +2097,7 @@ declare function createHeliosLedgerToolDefinitions(service: HeliosAgentMcpLedger
             verificationUriComplete: string;
             expiresInSeconds: number;
             pollIntervalSeconds: number;
-            requestedScope: AgentDeviceStartInput["scope"];
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
             startedAt: string;
         };
     }>;
@@ -1520,7 +2144,7 @@ declare function createHeliosMarketToolDefinitions(service: HeliosAgentMcpMarket
             verificationUriComplete: string;
             expiresInSeconds: number;
             pollIntervalSeconds: number;
-            requestedScope: AgentDeviceStartInput["scope"];
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
             startedAt: string;
         };
     }>;
@@ -1570,7 +2194,7 @@ declare function createHeliosMarketToolDefinitions(service: HeliosAgentMcpMarket
             verificationUriComplete: string;
             expiresInSeconds: number;
             pollIntervalSeconds: number;
-            requestedScope: AgentDeviceStartInput["scope"];
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
             startedAt: string;
         };
     }>;
@@ -1607,7 +2231,7 @@ declare function createHeliosMarketToolDefinitions(service: HeliosAgentMcpMarket
             verificationUriComplete: string;
             expiresInSeconds: number;
             pollIntervalSeconds: number;
-            requestedScope: AgentDeviceStartInput["scope"];
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
             startedAt: string;
         };
     }>;
@@ -1673,6 +2297,7 @@ declare function createHeliosTradingToolDefinitions(service: HeliosAgentMcpTradi
             }, z.core.$strip>>;
         }, z.core.$strip>>;
         idempotencyKey: z.ZodOptional<z.ZodString>;
+        idempotencyWindowSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
     execute(input: {
         symbol: string;
@@ -1704,6 +2329,7 @@ declare function createHeliosTradingToolDefinitions(service: HeliosAgentMcpTradi
             } | undefined;
         } | undefined;
         idempotencyKey?: string | undefined;
+        idempotencyWindowSeconds?: number | undefined;
     }): Promise<{
         content: {
             type: "text";
@@ -1726,7 +2352,7 @@ declare function createHeliosTradingToolDefinitions(service: HeliosAgentMcpTradi
             verificationUriComplete: string;
             expiresInSeconds: number;
             pollIntervalSeconds: number;
-            requestedScope: AgentDeviceStartInput["scope"];
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
             startedAt: string;
         };
     }>;
@@ -1791,6 +2417,7 @@ declare function createHeliosTradingToolDefinitions(service: HeliosAgentMcpTradi
             }, z.core.$strip>>;
         }, z.core.$strip>>;
         idempotencyKey: z.ZodOptional<z.ZodString>;
+        idempotencyWindowSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
     execute(input: {
         symbol: string;
@@ -1822,6 +2449,7 @@ declare function createHeliosTradingToolDefinitions(service: HeliosAgentMcpTradi
             } | undefined;
         } | undefined;
         idempotencyKey?: string | undefined;
+        idempotencyWindowSeconds?: number | undefined;
     }): Promise<{
         content: {
             type: "text";
@@ -1844,7 +2472,7 @@ declare function createHeliosTradingToolDefinitions(service: HeliosAgentMcpTradi
             verificationUriComplete: string;
             expiresInSeconds: number;
             pollIntervalSeconds: number;
-            requestedScope: AgentDeviceStartInput["scope"];
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
             startedAt: string;
         };
     }>;
@@ -1909,6 +2537,7 @@ declare function createHeliosTradingToolDefinitions(service: HeliosAgentMcpTradi
             }, z.core.$strip>>;
         }, z.core.$strip>>;
         idempotencyKey: z.ZodOptional<z.ZodString>;
+        idempotencyWindowSeconds: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
     execute(input: {
         symbol: string;
@@ -1940,6 +2569,7 @@ declare function createHeliosTradingToolDefinitions(service: HeliosAgentMcpTradi
             } | undefined;
         } | undefined;
         idempotencyKey?: string | undefined;
+        idempotencyWindowSeconds?: number | undefined;
     }): Promise<{
         content: {
             type: "text";
@@ -1962,7 +2592,7 @@ declare function createHeliosTradingToolDefinitions(service: HeliosAgentMcpTradi
             verificationUriComplete: string;
             expiresInSeconds: number;
             pollIntervalSeconds: number;
-            requestedScope: AgentDeviceStartInput["scope"];
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
             startedAt: string;
         };
     }>;
@@ -1976,11 +2606,13 @@ declare function createHeliosTradingToolDefinitions(service: HeliosAgentMcpTradi
         }>>;
         symbol: z.ZodString;
         maxSlippageBps: z.ZodOptional<z.ZodNumber>;
+        fraction: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
     execute(input: {
         symbol: string;
         provider?: "hyperliquid" | undefined;
         maxSlippageBps?: number | undefined;
+        fraction?: number | undefined;
     }): Promise<{
         content: {
             type: "text";
@@ -2003,7 +2635,7 @@ declare function createHeliosTradingToolDefinitions(service: HeliosAgentMcpTradi
             verificationUriComplete: string;
             expiresInSeconds: number;
             pollIntervalSeconds: number;
-            requestedScope: AgentDeviceStartInput["scope"];
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
             startedAt: string;
         };
     }>;
@@ -2077,7 +2709,7 @@ declare function createHeliosTradingToolDefinitions(service: HeliosAgentMcpTradi
             verificationUriComplete: string;
             expiresInSeconds: number;
             pollIntervalSeconds: number;
-            requestedScope: AgentDeviceStartInput["scope"];
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
             startedAt: string;
         };
     }>;
@@ -2118,7 +2750,7 @@ declare function createHeliosTradingToolDefinitions(service: HeliosAgentMcpTradi
             verificationUriComplete: string;
             expiresInSeconds: number;
             pollIntervalSeconds: number;
-            requestedScope: AgentDeviceStartInput["scope"];
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
             startedAt: string;
         };
     }>;
@@ -2149,7 +2781,7 @@ declare function createHeliosTradingToolDefinitions(service: HeliosAgentMcpTradi
             verificationUriComplete: string;
             expiresInSeconds: number;
             pollIntervalSeconds: number;
-            requestedScope: AgentDeviceStartInput["scope"];
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
             startedAt: string;
         };
     }>;
@@ -2186,10 +2818,276 @@ declare function createHeliosTradingToolDefinitions(service: HeliosAgentMcpTradi
             verificationUriComplete: string;
             expiresInSeconds: number;
             pollIntervalSeconds: number;
-            requestedScope: AgentDeviceStartInput["scope"];
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
             startedAt: string;
         };
     }>;
 }];
 
-export { type ActiveProviderView, type AgentMcpSessionStore, type CancelOrderToolResult, type ClosePositionToolResult, type CreateHeliosAgentMcpServerOptions, DEFAULT_SNAPSHOT_FIELDS, DEFAULT_SNAPSHOT_TOP, type DeleteTpSlToolResult, type EnsureLoginOptions, type EnsureLoginResult, FileAgentSessionStore, type GetHeliosAgentMcpDocumentInput, HOSTED_RECONNECT_MESSAGE, HeliosAgentMcpAccountService, type HeliosAgentMcpAccountServiceOptions, HeliosAgentMcpAuthService, type HeliosAgentMcpAuthServiceOptions, type HeliosAgentMcpDocsIndex, type HeliosAgentMcpDocsIndexEntry, HeliosAgentMcpDocsService, type HeliosAgentMcpDocsServiceOptions, type HeliosAgentMcpDocument, HeliosAgentMcpLedgerService, type HeliosAgentMcpLedgerServiceOptions, HeliosAgentMcpMarketService, type HeliosAgentMcpMarketServiceOptions, HeliosAgentMcpProviderService, type HeliosAgentMcpProviderServiceOptions, HeliosAgentMcpTradingService, type HeliosAgentMcpTradingServiceOptions, type HeliosMcpToolDefinition, type HeliosMcpToolResult, type LedgerFillsResult, type LedgerSummaryResult, type MarketSnapshotChunkResult, type MarketSnapshotResult, type MarketSymbolDetailResult, MemoryAgentMcpSessionStore, type OpenOrdersToolResult, type OpenPositionsResult, type PendingAgentLogin, type PendingLoginResult, type PollLoginResult, type PortfolioResult, type SetTpSlToolResult, type StartLoginResult, type TradeIntentAction, type TradeIntentActionInput, type TradeIntentActionResult, type WalletStateResult, compactSymbolDetail, createHeliosAccountToolDefinitions, createHeliosAgentMcpServer, createHeliosAuthToolDefinitions, createHeliosDocsToolDefinitions, createHeliosLedgerToolDefinitions, createHeliosMarketToolDefinitions, createHeliosProviderToolDefinitions, createHeliosTradingToolDefinitions, formatHeliosLoginPrompt, getDefaultHeliosAgentMcpDocsRoot, getDefaultHeliosAgentMcpSessionPath, pendingAgentLoginSchema, retryAfterUnauthorizedRefresh, toolAnnotations, topOfSnapshot, withDataText, withSnapshotDefaults };
+/**
+ * Text for the lean tools: what a small model (Qwen 27B at 32k) reads, so every answer is short, line-oriented and the
+ * same shape each time. The first line is the answer, then one line per row with `|` between fields, units on every
+ * number, times as "minutes ago". Clients that read structured content also get the JSON these are rendered from.
+ */
+declare const usd: (v: number | null | undefined, signed?: boolean) => string;
+declare const pct: (v: number | null | undefined, places?: number) => string;
+/** A price with the digits that matter: 67,420 · 36.90 · 0.0001234. */
+declare const price: (v: number | null | undefined) => string;
+declare const ago: (t: number | null | undefined, now: number) => string;
+/** "Patient Sniper #4 (swing, 82% win)". */
+declare const trader: (m: Pick<SmMove, "nick" | "rank" | "style" | "win">) => string;
+/** "opened long HYPE $310k @ 36.95 5x" or "closed long SOL $150k +$11.8k (+7.9%)". */
+declare const moveText: (m: SmMove) => string;
+/** Where the mark sits against the bigger side's weighted entry: edge > 0 is better than their entry. */
+declare const entryText: (side: "long" | "short" | null, edgePct: number | null) => string | null;
+declare function renderMarket(m: AgentMarket, now?: number): string;
+declare function renderBoard(b: SmartMoneyBoard, now?: number): string;
+declare function renderMoves(m: SmartMoneyMoves, now?: number): string;
+interface CoinYou {
+    position: PortfolioSnapshot['positions'][number] | null;
+    availableBalance: number;
+}
+declare function renderCoin(c: SmartMoneyCoin, you: CoinYou | null, now?: number): string;
+/** Minimum order value on Hyperliquid (notional = margin x leverage). */
+declare const MIN_ORDER_USD = 10;
+/**
+ * What it costs to trade the coin now: max leverage, spread, the slippage of a $10k and $100k market order (worse
+ * side), USD resting within 1% (thinner side), and the next funding payment (Hyperliquid pays every hour on the hour).
+ */
+declare function tradingLine(mk: SmartMoneyCoin['market'] & object, now?: number): string;
+declare function renderAccount(p: PortfolioSnapshot, orders: OpenOrder[] | null, summary: LedgerSummary | null): string;
+/** "long 0.5 BTC @ 67,420 · mark 67,900 · open PnL +$240 · 10x · liquidation 61,200". */
+declare function positionLine(pos: PortfolioSnapshot['positions'][number]): string;
+/** The agent's own fills, newest first, with the window's totals on the first line. */
+declare function renderTrades(page: LedgerFillsPage, paper: boolean, coin: string | null, now?: number): string;
+declare function renderCandles(coin: string, interval: string, c: MarketCandles): string;
+
+/**
+ * The lean tool set (Mario 2026-10-26: "make our MCP incredibly high performance and valuable, even if it means
+ * stripping away most of the indicators"): smart money first, flat parameters, short text answers a 27B model at 32k
+ * reads reliably, and the full JSON as structured content for clients that read it. data-bridge serves the reads from
+ * prebuilt views (services/agents/smartMoney.ts), so each call is a Redis read on the server.
+ */
+interface LeanToolResult {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    structuredContent: Record<string, unknown>;
+}
+interface LeanToolDefinition<TInput> {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodType<TInput>;
+    /** Changes the account (MCP annotations: apps ask before running it). */
+    acts?: boolean;
+    execute(input: TInput): Promise<LeanToolResult>;
+}
+interface LeanServices {
+    auth: HeliosAgentMcpAuthService;
+    dataBridge: HeliosAgentDataBridgeClient;
+}
+declare const smBoardInputSchema: z.ZodObject<{
+    view: z.ZodOptional<z.ZodEnum<{
+        discount: "discount";
+        conviction: "conviction";
+        flows: "flows";
+        pileins: "pileins";
+    }>>;
+    side: z.ZodOptional<z.ZodEnum<{
+        long: "long";
+        short: "short";
+        any: "any";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const smMovesInputSchema: z.ZodObject<{
+    since: z.ZodOptional<z.ZodString>;
+    coin: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        entries: "entries";
+        exits: "exits";
+    }>>;
+    min_usd: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const smCoinInputSchema: z.ZodObject<{
+    coin: z.ZodString;
+}, z.core.$strip>;
+declare const marketInputSchema: z.ZodObject<{
+    coins: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        lean: "lean";
+        rank: "rank";
+        volume: "volume";
+        move1h: "move1h";
+        move24h: "move24h";
+        funding: "funding";
+        edge: "edge";
+    }>>;
+    filter: z.ZodOptional<z.ZodEnum<{
+        discount: "discount";
+        turning: "turning";
+        falling: "falling";
+        stretched_up: "stretched_up";
+        stretched_down: "stretched_down";
+        sm_long: "sm_long";
+        sm_short: "sm_short";
+    }>>;
+}, z.core.$strip>;
+declare const accountInputSchema: z.ZodObject<{
+    paper: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const tradeInputSchema: z.ZodObject<{
+    coin: z.ZodString;
+    action: z.ZodEnum<{
+        reverse: "reverse";
+        open: "open";
+        add: "add";
+        close: "close";
+        reset: "reset";
+    }>;
+    side: z.ZodOptional<z.ZodEnum<{
+        long: "long";
+        short: "short";
+    }>>;
+    margin_usd: z.ZodOptional<z.ZodNumber>;
+    leverage: z.ZodOptional<z.ZodNumber>;
+    sl_pct: z.ZodOptional<z.ZodNumber>;
+    tp_pct: z.ZodOptional<z.ZodNumber>;
+    limit_px: z.ZodOptional<z.ZodNumber>;
+    slippage_bps: z.ZodOptional<z.ZodNumber>;
+    fraction: z.ZodOptional<z.ZodNumber>;
+    paper: z.ZodOptional<z.ZodBoolean>;
+    key: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** How long after the first identical keyless trade call a repeat is still a retry of it (data-bridge holds the window). */
+declare const TRADE_KEY_WINDOW_SECONDS = 60;
+/**
+ * The key for a trade call that brought none: a fingerprint of the account and the normalized order, sent with
+ * idempotencyWindowSeconds. The data-bridge keeps the window in Redis, so an identical call within
+ * TRADE_KEY_WINDOW_SECONDS of the first (a retry after a timeout or a lost reply, when the model never saw a key) names
+ * the same order on every replica and after a restart, and is placed once. The window runs from the first call; after
+ * it an identical call is a new order. A deliberate second identical order within the window needs its own `key`.
+ */
+declare function tradeKeyFor(input: z.infer<typeof tradeInputSchema>, account: string): string;
+declare const protectInputSchema: z.ZodObject<{
+    coin: z.ZodString;
+    op: z.ZodEnum<{
+        set: "set";
+        remove: "remove";
+        cancel: "cancel";
+        move: "move";
+    }>;
+    tp_px: z.ZodOptional<z.ZodNumber>;
+    sl_px: z.ZodOptional<z.ZodNumber>;
+    order_id: z.ZodOptional<z.ZodString>;
+    px: z.ZodOptional<z.ZodNumber>;
+    paper: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const tradesInputSchema: z.ZodObject<{
+    window: z.ZodOptional<z.ZodEnum<{
+        "24h": "24h";
+        "7d": "7d";
+        "30d": "30d";
+    }>>;
+    coin: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    paper: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const candlesInputSchema: z.ZodObject<{
+    coin: z.ZodString;
+    interval: z.ZodEnum<{
+        "1m": "1m";
+        "5m": "5m";
+        "15m": "15m";
+        "1h": "1h";
+        "4h": "4h";
+        "1d": "1d";
+    }>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Why a TP/SL would trigger the moment it is set, or null when both legs are on the right side of the mark: a long's
+ * stop sits under the price and its take profit over it, a short's the other way round. Hyperliquid fires a trigger
+ * that is already through the price at once, closing the position at market.
+ */
+declare function wrongSideTpSl(side: 'LONG' | 'SHORT', mark: number, tp?: number, sl?: number): string | null;
+declare function createLeanToolDefinitions(services: LeanServices): {
+    smBoard: LeanToolDefinition<{
+        view?: "discount" | "conviction" | "flows" | "pileins" | undefined;
+        side?: "long" | "short" | "any" | undefined;
+        limit?: number | undefined;
+    }>;
+    smMoves: LeanToolDefinition<{
+        since?: string | undefined;
+        coin?: string | undefined;
+        kind?: "all" | "entries" | "exits" | undefined;
+        min_usd?: number | undefined;
+        limit?: number | undefined;
+    }>;
+    smCoin: LeanToolDefinition<{
+        coin: string;
+    }>;
+    market: LeanToolDefinition<{
+        coins?: string | undefined;
+        limit?: number | undefined;
+        offset?: number | undefined;
+        sort?: "lean" | "rank" | "volume" | "move1h" | "move24h" | "funding" | "edge" | undefined;
+        filter?: "discount" | "turning" | "falling" | "stretched_up" | "stretched_down" | "sm_long" | "sm_short" | undefined;
+    }>;
+    account: LeanToolDefinition<{
+        paper?: boolean | undefined;
+    }>;
+    trade: LeanToolDefinition<{
+        coin: string;
+        action: "reverse" | "open" | "add" | "close" | "reset";
+        side?: "long" | "short" | undefined;
+        margin_usd?: number | undefined;
+        leverage?: number | undefined;
+        sl_pct?: number | undefined;
+        tp_pct?: number | undefined;
+        limit_px?: number | undefined;
+        slippage_bps?: number | undefined;
+        fraction?: number | undefined;
+        paper?: boolean | undefined;
+        key?: string | undefined;
+    }>;
+    protect: LeanToolDefinition<{
+        coin: string;
+        op: "set" | "remove" | "cancel" | "move";
+        tp_px?: number | undefined;
+        sl_px?: number | undefined;
+        order_id?: string | undefined;
+        px?: number | undefined;
+        paper?: boolean | undefined;
+    }>;
+    trades: LeanToolDefinition<{
+        window?: "24h" | "7d" | "30d" | undefined;
+        coin?: string | undefined;
+        limit?: number | undefined;
+        paper?: boolean | undefined;
+    }>;
+    candles: LeanToolDefinition<{
+        coin: string;
+        interval: "1m" | "5m" | "15m" | "1h" | "4h" | "1d";
+        limit?: number | undefined;
+    }>;
+};
+type LeanTools = ReturnType<typeof createLeanToolDefinitions>;
+/** The tool sets per profile, in the order they are listed (smart money first, so it is what a model reaches for). */
+/**
+ * A write tool for Watch only links (Mario 2026-11-08: they may paper trade): the same tool on the practice account
+ * only, whatever `paper` says. data-bridge holds the same line (paper.ts paperWriter): a watch-only token may change
+ * the agent practice account and nothing else.
+ */
+declare function practiceOnly<T extends {
+    paper?: boolean;
+}>(tool: LeanToolDefinition<T>): LeanToolDefinition<T>;
+declare function leanToolsFor(tools: LeanTools, profile: 'lean' | 'signals' | 'full'): LeanToolDefinition<never>[];
+
+export { type ActiveProviderView, type AgentMcpSessionStore, type CancelOrderToolResult, type ClosePositionToolResult, type CoinYou, type CreateHeliosAgentMcpServerOptions, DEFAULT_HELIOS_BASE_URL, DEFAULT_HELIOS_SESSION_ISSUER, DEFAULT_SNAPSHOT_FIELDS, DEFAULT_SNAPSHOT_TOP, type DeleteTpSlToolResult, type EnsureLoginOptions, type EnsureLoginResult, FileAgentSessionStore, type FileAgentSessionStoreOptions, type GetHeliosAgentMcpDocumentInput, HOSTED_RECONNECT_MESSAGE, HeliosAgentMcpAccountService, type HeliosAgentMcpAccountServiceOptions, HeliosAgentMcpAuthService, type HeliosAgentMcpAuthServiceOptions, type HeliosAgentMcpDocsIndex, type HeliosAgentMcpDocsIndexEntry, HeliosAgentMcpDocsService, type HeliosAgentMcpDocsServiceOptions, type HeliosAgentMcpDocument, HeliosAgentMcpLedgerService, type HeliosAgentMcpLedgerServiceOptions, HeliosAgentMcpMarketService, type HeliosAgentMcpMarketServiceOptions, HeliosAgentMcpProviderService, type HeliosAgentMcpProviderServiceOptions, HeliosAgentMcpTradingService, type HeliosAgentMcpTradingServiceOptions, type HeliosMcpToolDefinition, type HeliosMcpToolResult, type LeanServices, type LeanToolDefinition, type LeanToolResult, type LeanTools, type LedgerFillsResult, type LedgerSummaryResult, MAX_TOOL_INPUT_ELEMENTS, MCP_PROFILES, MIN_ORDER_USD, type MarketSnapshotChunkResult, type MarketSnapshotResult, type MarketSymbolDetailResult, type McpProfile, MemoryAgentMcpSessionStore, type OpenOrdersToolResult, type OpenPositionsResult, type PendingAgentLogin, type PendingLoginResult, type PollLoginResult, type PortfolioResult, type SetTpSlToolResult, type StartLoginResult, TRADE_KEY_WINDOW_SECONDS, type TradeIntentAction, type TradeIntentActionInput, type TradeIntentActionResult, type WalletStateResult, accountInputSchema, ago, assertHeliosBaseUrl, candlesInputSchema, compactSymbolDetail, createHeliosAccountToolDefinitions, createHeliosAgentMcpServer, createHeliosAuthToolDefinitions, createHeliosDocsToolDefinitions, createHeliosLedgerToolDefinitions, createHeliosMarketToolDefinitions, createHeliosProviderToolDefinitions, createHeliosTradingToolDefinitions, createLeanToolDefinitions, entryText, formatHeliosLoginPrompt, getDefaultHeliosAgentMcpDocsRoot, getDefaultHeliosAgentMcpSessionPath, isSameHeliosIssuer, leanToolsFor, marketInputSchema, moveText, pct, pendingAgentLoginSchema, positionLine, practiceOnly, price, protectInputSchema, renderAccount, renderBoard, renderCandles, renderCoin, renderMarket, renderMoves, renderTrades, retryAfterUnauthorizedRefresh, smBoardInputSchema, smCoinInputSchema, smMovesInputSchema, toolAnnotations, topOfSnapshot, tradeInputSchema, tradeKeyFor, trader, tradesInputSchema, tradingLine, usd, withDataText, withSnapshotDefaults, wrongSideTpSl };