@pgnio/helios-mcp 0.0.0-stage → 0.2.1

package/dist/index.d.ts

@@ -0,0 +1,2138 @@
+import { z } from 'zod';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+declare const agentDeviceStartInputSchema: z.ZodObject<{
+    clientName: z.ZodString;
+    scope: z.ZodArray<z.ZodEnum<{
+        "account:read": "account:read";
+        "market:read": "market:read";
+        "orders:write": "orders:write";
+        "orders:cancel": "orders:cancel";
+    }>>;
+    constraints: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+declare const agentDeviceStartOutputSchema: z.ZodObject<{
+    deviceCode: z.ZodString;
+    userCode: z.ZodString;
+    verificationUri: z.ZodString;
+    verificationUriComplete: z.ZodString;
+    expiresInSeconds: z.ZodNumber;
+    pollIntervalSeconds: z.ZodNumber;
+}, z.core.$strip>;
+declare const agentTokenResponseSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    refreshToken: z.ZodString;
+    tokenType: z.ZodLiteral<"Bearer">;
+    expiresInSeconds: z.ZodNumber;
+    scope: z.ZodArray<z.ZodEnum<{
+        "account:read": "account:read";
+        "market:read": "market:read";
+        "orders:write": "orders:write";
+        "orders:cancel": "orders:cancel";
+    }>>;
+    ownerUserId: z.ZodString;
+    agentGrantId: z.ZodString;
+}, z.core.$strip>;
+/** Public Helios trades on Hyperliquid only; 'binance' is no longer accepted anywhere a provider is given. */
+declare const providerSchema: z.ZodEnum<{
+    hyperliquid: "hyperliquid";
+}>;
+declare const walletStateSchema: z.ZodObject<{
+    provider: z.ZodLiteral<"hyperliquid">;
+    accountValue: z.ZodNumber;
+    availableBalance: z.ZodNumber;
+    withdrawable: z.ZodNumber;
+    totalMarginUsed: z.ZodNumber;
+    totalNotionalPosition: z.ZodNumber;
+    crossMarginAccountValue: z.ZodNumber;
+    isActivated: z.ZodBoolean;
+    fetchedAt: z.ZodString;
+}, z.core.$strip>;
+declare const openPositionsSnapshotSchema: z.ZodObject<{
+    provider: z.ZodLiteral<"hyperliquid">;
+    fetchedAt: z.ZodString;
+    totalUnrealizedPnl: 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>>;
+}, 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;
+    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.ZodNumber>;
+        clientOrderId: z.ZodOptional<z.ZodString>;
+        symbol: z.ZodString;
+        side: z.ZodEnum<{
+            BUY: "BUY";
+            SELL: "SELL";
+        }>;
+        positionSide: z.ZodEnum<{
+            LONG: "LONG";
+            SHORT: "SHORT";
+            BOTH: "BOTH";
+        }>;
+        status: z.ZodString;
+        kind: z.ZodEnum<{
+            STOP_LOSS: "STOP_LOSS";
+            TAKE_PROFIT: "TAKE_PROFIT";
+        }>;
+        groupId: z.ZodString;
+        stopPrice: z.ZodOptional<z.ZodString>;
+        parentClientOrderId: z.ZodOptional<z.ZodString>;
+        assetId: z.ZodOptional<z.ZodNumber>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const ledgerFillsInputSchema: z.ZodObject<{
+    window: z.ZodOptional<z.ZodEnum<{
+        "24h": "24h";
+        "7d": "7d";
+        "30d": "30d";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    before: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const ledgerFillsPageSchema: z.ZodObject<{
+    window: z.ZodEnum<{
+        "24h": "24h";
+        "7d": "7d";
+        "30d": "30d";
+    }>;
+    limit: z.ZodNumber;
+    before: z.ZodOptional<z.ZodNumber>;
+    hasMore: z.ZodBoolean;
+    nextBefore: z.ZodOptional<z.ZodNumber>;
+    fetchedAt: z.ZodString;
+    fills: z.ZodArray<z.ZodObject<{
+        coin: z.ZodString;
+        px: z.ZodNumber;
+        sz: z.ZodNumber;
+        side: z.ZodEnum<{
+            B: "B";
+            A: "A";
+        }>;
+        time: z.ZodNumber;
+        dir: z.ZodString;
+        closedPnl: z.ZodNumber;
+        fee: z.ZodNumber;
+        crossed: z.ZodBoolean;
+        oid: z.ZodNumber;
+        tid: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const ledgerSummaryInputSchema: z.ZodObject<{
+    window: z.ZodOptional<z.ZodEnum<{
+        "24h": "24h";
+        "7d": "7d";
+        "30d": "30d";
+    }>>;
+}, z.core.$strip>;
+declare const ledgerSummarySchema: z.ZodObject<{
+    realizedPnl: z.ZodNumber;
+    totalFees: z.ZodNumber;
+    fillCount: z.ZodNumber;
+    closeCount: z.ZodNumber;
+    winCount: z.ZodNumber;
+    lossCount: z.ZodNumber;
+    averageWin: z.ZodNumber;
+    averageLoss: z.ZodNumber;
+    window: z.ZodEnum<{
+        "24h": "24h";
+        "7d": "7d";
+        "30d": "30d";
+    }>;
+    generatedAt: z.ZodString;
+    periods: z.ZodObject<{
+        '24h': z.ZodObject<{
+            realizedPnl: z.ZodNumber;
+            totalFees: z.ZodNumber;
+            fillCount: z.ZodNumber;
+            closeCount: z.ZodNumber;
+            winCount: z.ZodNumber;
+            lossCount: z.ZodNumber;
+            averageWin: z.ZodNumber;
+            averageLoss: z.ZodNumber;
+        }, z.core.$strip>;
+        '7d': z.ZodObject<{
+            realizedPnl: z.ZodNumber;
+            totalFees: z.ZodNumber;
+            fillCount: z.ZodNumber;
+            closeCount: z.ZodNumber;
+            winCount: z.ZodNumber;
+            lossCount: z.ZodNumber;
+            averageWin: z.ZodNumber;
+            averageLoss: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const marketSnapshotInputSchema: z.ZodObject<{
+    scope: z.ZodOptional<z.ZodEnum<{
+        selected: "selected";
+        all: "all";
+    }>>;
+    symbols: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+declare const marketSnapshotChunkInputSchema: z.ZodObject<{
+    scope: z.ZodOptional<z.ZodEnum<{
+        selected: "selected";
+        all: "all";
+    }>>;
+    symbols: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const marketSnapshotSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"helios.market_snapshot.v1">;
+    view: z.ZodLiteral<"market_overview">;
+    scope: z.ZodEnum<{
+        selected: "selected";
+        all: "all";
+        explicit: "explicit";
+    }>;
+    symbolCount: z.ZodNumber;
+    generatedAt: z.ZodString;
+    returnedSymbols: z.ZodArray<z.ZodString>;
+    semantics: z.ZodObject<{
+        nullMeans: z.ZodLiteral<"unavailable">;
+        percentScale: z.ZodLiteral<"already_percent">;
+        percentFields: z.ZodArray<z.ZodString>;
+        changeMapPercentKeys: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    market: z.ZodObject<{
+        fieldIds: z.ZodArray<z.ZodString>;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        symbolLists: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    table: z.ZodObject<{
+        fieldIds: z.ZodArray<z.ZodString>;
+        rows: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+    }, z.core.$strip>;
+    legend: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>;
+declare const marketSnapshotChunkSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"helios.market_snapshot_chunk.v1">;
+    view: z.ZodLiteral<"market_overview_chunk">;
+    scope: z.ZodEnum<{
+        selected: "selected";
+        all: "all";
+        explicit: "explicit";
+    }>;
+    totalSymbolCount: z.ZodNumber;
+    generatedAt: z.ZodString;
+    offset: z.ZodNumber;
+    limit: z.ZodNumber;
+    chunkSymbolCount: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+    nextOffset: z.ZodOptional<z.ZodNumber>;
+    returnedSymbols: z.ZodArray<z.ZodString>;
+    semantics: z.ZodObject<{
+        nullMeans: z.ZodLiteral<"unavailable">;
+        percentScale: z.ZodLiteral<"already_percent">;
+        percentFields: z.ZodArray<z.ZodString>;
+        changeMapPercentKeys: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    market: z.ZodObject<{
+        fieldIds: z.ZodArray<z.ZodString>;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        symbolLists: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    table: z.ZodObject<{
+        fieldIds: z.ZodArray<z.ZodString>;
+        rows: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+    }, z.core.$strip>;
+    legend: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>;
+declare const marketSymbolDetailInputSchema: z.ZodObject<{
+    symbol: z.ZodString;
+}, z.core.$strip>;
+declare const marketSymbolDetailSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"helios.market_symbol_detail.v1">;
+    generatedAt: z.ZodString;
+    symbol: z.ZodString;
+    semantics: z.ZodObject<{
+        nullMeans: z.ZodLiteral<"unavailable">;
+        percentScale: z.ZodLiteral<"already_percent">;
+        percentFields: z.ZodArray<z.ZodString>;
+        changeMapPercentKeys: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    market: z.ZodObject<{
+        fieldIds: z.ZodArray<z.ZodString>;
+        values: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+        symbolLists: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    row: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+    symbolCtx: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>;
+    changeMap: z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodNumber>>;
+    metrics: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    legend: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>;
+declare const submitTradeIntentInputSchema: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+    }>>;
+    symbol: z.ZodString;
+    intentType: z.ZodEnum<{
+        OPEN: "OPEN";
+        DCA: "DCA";
+        REVERSE: "REVERSE";
+        CLOSE: "CLOSE";
+    }>;
+    direction: z.ZodEnum<{
+        LONG: "LONG";
+        SHORT: "SHORT";
+    }>;
+    size: z.ZodObject<{
+        mode: z.ZodEnum<{
+            MARGIN_USD: "MARGIN_USD";
+            BASE_QUANTITY: "BASE_QUANTITY";
+        }>;
+        value: z.ZodNumber;
+    }, z.core.$strip>;
+    execution: z.ZodObject<{
+        style: z.ZodEnum<{
+            MARKET: "MARKET";
+            LIMIT_TAKER: "LIMIT_TAKER";
+            LIMIT_MAKER: "LIMIT_MAKER";
+            LIMIT_GTC: "LIMIT_GTC";
+        }>;
+        timeInForce: z.ZodOptional<z.ZodEnum<{
+            GTC: "GTC";
+            IOC: "IOC";
+            FOK: "FOK";
+            GTX: "GTX";
+        }>>;
+        limitPrice: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    maxSlippageBps: z.ZodOptional<z.ZodNumber>;
+    leverageOverride: z.ZodOptional<z.ZodNumber>;
+    marginModeOverride: z.ZodOptional<z.ZodEnum<{
+        ISOLATED: "ISOLATED";
+        CROSS: "CROSS";
+    }>>;
+    reduceOnly: z.ZodOptional<z.ZodBoolean>;
+    protection: z.ZodOptional<z.ZodObject<{
+        takeProfit: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                MARKET: "MARKET";
+                LIMIT: "LIMIT";
+            }>;
+            triggerPrice: z.ZodNumber;
+            limitPrice: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        stopLoss: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                MARKET: "MARKET";
+                LIMIT: "LIMIT";
+            }>;
+            triggerPrice: z.ZodNumber;
+            limitPrice: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const submitTradeIntentResultSchema: z.ZodObject<{
+    status: z.ZodLiteral<"submitted">;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        placed: "placed";
+        replayed: "replayed";
+    }>>;
+    clientOrderId: z.ZodOptional<z.ZodString>;
+    orderStatus: z.ZodOptional<z.ZodString>;
+    rejectedProtection: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>>;
+    provider: z.ZodOptional<z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+    }>>;
+    symbol: z.ZodString;
+    intentType: z.ZodEnum<{
+        OPEN: "OPEN";
+        DCA: "DCA";
+        REVERSE: "REVERSE";
+        CLOSE: "CLOSE";
+    }>;
+    direction: z.ZodEnum<{
+        LONG: "LONG";
+        SHORT: "SHORT";
+    }>;
+    size: z.ZodObject<{
+        mode: z.ZodEnum<{
+            MARGIN_USD: "MARGIN_USD";
+            BASE_QUANTITY: "BASE_QUANTITY";
+        }>;
+        value: z.ZodNumber;
+    }, z.core.$strip>;
+    execution: z.ZodObject<{
+        style: z.ZodEnum<{
+            MARKET: "MARKET";
+            LIMIT_TAKER: "LIMIT_TAKER";
+            LIMIT_MAKER: "LIMIT_MAKER";
+            LIMIT_GTC: "LIMIT_GTC";
+        }>;
+        timeInForce: z.ZodOptional<z.ZodEnum<{
+            GTC: "GTC";
+            IOC: "IOC";
+            FOK: "FOK";
+            GTX: "GTX";
+        }>>;
+        limitPrice: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    maxSlippageBps: z.ZodOptional<z.ZodNumber>;
+    leverageOverride: z.ZodOptional<z.ZodNumber>;
+    marginModeOverride: z.ZodOptional<z.ZodEnum<{
+        ISOLATED: "ISOLATED";
+        CROSS: "CROSS";
+    }>>;
+    reduceOnly: z.ZodBoolean;
+    hasProtection: z.ZodBoolean;
+}, z.core.$strip>;
+declare const closePositionInputSchema: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+    }>>;
+    symbol: z.ZodString;
+    maxSlippageBps: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const closePositionResultSchema: z.ZodObject<{
+    status: z.ZodLiteral<"submitted">;
+    provider: z.ZodOptional<z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+    }>>;
+    symbol: z.ZodString;
+    mode: z.ZodLiteral<"FULL">;
+    maxSlippageBps: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const setTpSlInputSchema: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+    }>>;
+    symbol: z.ZodString;
+    applyTo: z.ZodEnum<{
+        FULL_POSITION: "FULL_POSITION";
+        CUSTOM_QUANTITY: "CUSTOM_QUANTITY";
+    }>;
+    quantity: z.ZodOptional<z.ZodNumber>;
+    parentClientOrderId: z.ZodString;
+    takeProfit: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            MARKET: "MARKET";
+            LIMIT: "LIMIT";
+        }>;
+        triggerPrice: z.ZodNumber;
+        limitPrice: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    stopLoss: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            MARKET: "MARKET";
+            LIMIT: "LIMIT";
+        }>;
+        triggerPrice: z.ZodNumber;
+        limitPrice: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const setTpSlResultSchema: z.ZodObject<{
+    status: z.ZodLiteral<"submitted">;
+    provider: z.ZodOptional<z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+    }>>;
+    symbol: z.ZodString;
+    applyTo: z.ZodEnum<{
+        FULL_POSITION: "FULL_POSITION";
+        CUSTOM_QUANTITY: "CUSTOM_QUANTITY";
+    }>;
+    quantity: z.ZodOptional<z.ZodNumber>;
+    parentClientOrderId: z.ZodString;
+    hasTakeProfit: z.ZodBoolean;
+    hasStopLoss: z.ZodBoolean;
+}, z.core.$strip>;
+declare const deleteTpSlInputSchema: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+    }>>;
+    symbol: z.ZodString;
+    orderId: z.ZodString;
+}, z.core.$strip>;
+declare const deleteTpSlResultSchema: z.ZodObject<{
+    status: z.ZodLiteral<"deleted">;
+    provider: z.ZodOptional<z.ZodEnum<{
+        hyperliquid: "hyperliquid";
+    }>>;
+    symbol: z.ZodString;
+    orderId: z.ZodString;
+}, z.core.$strip>;
+declare const openOrderSchema: z.ZodObject<{
+    coin: z.ZodString;
+    side: z.ZodEnum<{
+        B: "B";
+        A: "A";
+    }>;
+    limitPx: z.ZodString;
+    sz: z.ZodString;
+    oid: z.ZodNumber;
+    timestamp: z.ZodNumber;
+    origSz: z.ZodString;
+    orderType: z.ZodString;
+    tif: z.ZodNullable<z.ZodString>;
+    reduceOnly: z.ZodBoolean;
+    isTrigger: z.ZodBoolean;
+    triggerPx: z.ZodString;
+    cloid: z.ZodNullable<z.ZodString>;
+    assetId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const cancelOrderInputSchema: z.ZodObject<{
+    symbol: z.ZodString;
+    oid: z.ZodNumber;
+}, z.core.$strip>;
+declare const cancelOrderResultSchema: z.ZodObject<{
+    status: z.ZodLiteral<"cancelled">;
+    symbol: z.ZodString;
+    oid: z.ZodNumber;
+}, z.core.$strip>;
+type AgentDeviceStartInput = z.infer<typeof agentDeviceStartInputSchema>;
+type AgentDeviceStartOutput = z.infer<typeof agentDeviceStartOutputSchema>;
+type AgentTokenResponse = z.infer<typeof agentTokenResponseSchema>;
+type Provider = z.infer<typeof providerSchema>;
+type WalletState = z.infer<typeof walletStateSchema>;
+type OpenPositionsSnapshot = z.infer<typeof openPositionsSnapshotSchema>;
+type PortfolioInput = z.infer<typeof portfolioInputSchema>;
+type PortfolioSnapshot = z.infer<typeof portfolioSnapshotSchema>;
+type LedgerFillsInput = z.infer<typeof ledgerFillsInputSchema>;
+type LedgerFillsPage = z.infer<typeof ledgerFillsPageSchema>;
+type LedgerSummaryInput = z.infer<typeof ledgerSummaryInputSchema>;
+type LedgerSummary = z.infer<typeof ledgerSummarySchema>;
+type MarketSnapshotInput = z.infer<typeof marketSnapshotInputSchema>;
+type MarketSnapshot = z.infer<typeof marketSnapshotSchema>;
+type MarketSnapshotChunkInput = z.infer<typeof marketSnapshotChunkInputSchema>;
+type MarketSnapshotChunk = z.infer<typeof marketSnapshotChunkSchema>;
+type MarketSymbolDetailInput = z.infer<typeof marketSymbolDetailInputSchema>;
+type MarketSymbolDetail = z.infer<typeof marketSymbolDetailSchema>;
+type SubmitTradeIntentInput = z.infer<typeof submitTradeIntentInputSchema>;
+type SubmitTradeIntentResult = z.infer<typeof submitTradeIntentResultSchema>;
+type ClosePositionInput = z.infer<typeof closePositionInputSchema>;
+type ClosePositionResult = z.infer<typeof closePositionResultSchema>;
+type SetTpSlInput = z.infer<typeof setTpSlInputSchema>;
+type SetTpSlResult = z.infer<typeof setTpSlResultSchema>;
+type DeleteTpSlInput = z.infer<typeof deleteTpSlInputSchema>;
+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 FetchLike = typeof fetch;
+interface HeliosAgentAuthClientOptions {
+    baseUrl: string;
+    fetch?: FetchLike;
+    headers?: HeadersInit;
+}
+declare class HeliosAgentAuthClient {
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private readonly headers;
+    constructor(options: HeliosAgentAuthClientOptions);
+    startLogin(input: AgentDeviceStartInput): Promise<AgentDeviceStartOutput>;
+    exchangeDeviceCode(deviceCode: string): 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;
+    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 const storedAgentSessionSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    refreshToken: z.ZodString;
+    tokenType: z.ZodLiteral<"Bearer">;
+    ownerUserId: z.ZodString;
+    agentGrantId: z.ZodString;
+    scope: z.ZodArray<z.ZodEnum<{
+        "account:read": "account:read";
+        "market:read": "market:read";
+        "orders:write": "orders:write";
+        "orders:cancel": "orders:cancel";
+    }>>;
+    accessTokenExpiresAt: z.ZodString;
+    createdAt: z.ZodString;
+    lastRefreshedAt: z.ZodString;
+}, z.core.$strip>;
+declare const agentSessionViewSchema: z.ZodObject<{
+    connected: z.ZodBoolean;
+    status: z.ZodEnum<{
+        pending: "pending";
+        rejected: "rejected";
+        expired: "expired";
+        disconnected: "disconnected";
+        connected: "connected";
+        failed: "failed";
+    }>;
+    ownerUserId: z.ZodOptional<z.ZodString>;
+    agentGrantId: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "account:read": "account:read";
+        "market:read": "market:read";
+        "orders:write": "orders:write";
+        "orders:cancel": "orders:cancel";
+    }>>>;
+    accessTokenExpiresAt: z.ZodOptional<z.ZodString>;
+    lastRefreshedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type StoredAgentSession = z.infer<typeof storedAgentSessionSchema>;
+type AgentSessionView = z.infer<typeof agentSessionViewSchema>;
+interface AgentSessionStore {
+    getSession(): Promise<StoredAgentSession | null>;
+    setSession(session: StoredAgentSession): Promise<void>;
+    clearSession(): Promise<void>;
+}
+
+declare function getDefaultHeliosAgentMcpSessionPath(): string;
+declare const pendingAgentLoginSchema: 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 = z.infer<typeof pendingAgentLoginSchema>;
+interface AgentMcpSessionStore extends AgentSessionStore {
+    getActiveProvider(): Promise<Provider | null>;
+    setActiveProvider(provider: Provider): Promise<void>;
+    clearActiveProvider(): Promise<void>;
+    getPendingLogin(): Promise<PendingAgentLogin | null>;
+    setPendingLogin(pendingLogin: PendingAgentLogin): Promise<void>;
+    clearPendingLogin(): Promise<void>;
+}
+declare class FileAgentSessionStore implements AgentMcpSessionStore {
+    private readonly filePath;
+    constructor(filePath?: string);
+    getSession(): Promise<StoredAgentSession | null>;
+    getPendingLogin(): Promise<PendingAgentLogin | null>;
+    getActiveProvider(): Promise<Provider | null>;
+    setSession(session: StoredAgentSession): Promise<void>;
+    setPendingLogin(pendingLogin: PendingAgentLogin): Promise<void>;
+    setActiveProvider(activeProvider: Provider): Promise<void>;
+    clearSession(): Promise<void>;
+    clearPendingLogin(): Promise<void>;
+    clearActiveProvider(): Promise<void>;
+    private readState;
+    private writeState;
+    private writeStateOrDelete;
+    private deleteFile;
+}
+/**
+ * One request's session on the hosted server: the AI app's OAuth access token, held in memory for that request only.
+ * Nothing is written to disk and the provider is Hyperliquid unless the agent pins another for this request.
+ */
+declare class MemoryAgentMcpSessionStore implements AgentMcpSessionStore {
+    private session;
+    private activeProvider;
+    private pendingLogin;
+    constructor(session?: StoredAgentSession | null, activeProvider?: Provider | null);
+    getSession(): Promise<StoredAgentSession | null>;
+    setSession(session: StoredAgentSession): Promise<void>;
+    clearSession(): Promise<void>;
+    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 HeliosAgentMcpProviderServiceOptions {
+    sessionStore: AgentMcpSessionStore;
+}
+type ActiveProviderView = {
+    configured: true;
+    provider: Provider;
+} | {
+    configured: false;
+    provider: null;
+};
+declare class HeliosAgentMcpProviderService {
+    private readonly sessionStore;
+    constructor(options: HeliosAgentMcpProviderServiceOptions);
+    getActiveProvider(): Promise<ActiveProviderView>;
+    setActiveProvider(provider: Provider): Promise<ActiveProviderView>;
+    resolveProvider(explicitProvider?: Provider): Promise<Provider>;
+}
+
+interface HeliosAgentMcpAuthServiceOptions {
+    client: HeliosAgentAuthClient;
+    sessionStore: AgentMcpSessionStore;
+    refreshWindowMs?: number;
+    now?: () => Date;
+    /**
+     * False on the hosted server (helios.pgn.io/mcp): the AI app signed in through OAuth and holds the tokens, so the server
+     * never starts a device login of its own; an expired or revoked connection is an error the app answers by reconnecting.
+     */
+    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;
+    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 {
+    authService: HeliosAgentMcpAuthService;
+    dataBridgeClient: HeliosAgentDataBridgeClient;
+    providerService: HeliosAgentMcpProviderService;
+}
+type WalletStateResult = {
+    status: 'connected';
+    connected: true;
+    walletState: WalletState;
+} | ({
+    status: 'pending';
+    connected: false;
+    message: string;
+} & StartLoginResult);
+type PortfolioResult = {
+    status: 'connected';
+    connected: true;
+    portfolio: PortfolioSnapshot;
+} | ({
+    status: 'pending';
+    connected: false;
+    message: string;
+} & StartLoginResult);
+declare class HeliosAgentMcpAccountService {
+    private readonly authService;
+    private readonly dataBridgeClient;
+    private readonly providerService;
+    constructor(options: HeliosAgentMcpAccountServiceOptions);
+    getWalletState(): Promise<WalletStateResult>;
+    getPortfolio(input?: {
+        provider?: Provider;
+    }): Promise<PortfolioResult>;
+    private accountReadOptions;
+}
+
+interface HeliosAgentMcpDocsIndexEntry {
+    path: string;
+    section: string;
+    title: string;
+    bytes: number;
+}
+interface HeliosAgentMcpDocsIndex {
+    root: 'docs';
+    documents: HeliosAgentMcpDocsIndexEntry[];
+}
+interface HeliosAgentMcpDocument {
+    path: string;
+    section: string;
+    title: string;
+    body: string;
+    bytes: number;
+}
+interface HeliosAgentMcpDocsServiceOptions {
+    docsRoot: string;
+}
+interface GetHeliosAgentMcpDocumentInput {
+    path: string;
+}
+declare class HeliosAgentMcpDocsService {
+    private readonly docsRoot;
+    constructor(options: HeliosAgentMcpDocsServiceOptions);
+    getIndex(): Promise<HeliosAgentMcpDocsIndex>;
+    getDocument(input: GetHeliosAgentMcpDocumentInput): Promise<HeliosAgentMcpDocument>;
+    private readDocumentMetadata;
+}
+declare function getDefaultHeliosAgentMcpDocsRoot(): string;
+
+interface HeliosAgentMcpLedgerServiceOptions {
+    authService: HeliosAgentMcpAuthService;
+    dataBridgeClient: HeliosAgentDataBridgeClient;
+}
+type PendingLedgerLoginResult = {
+    status: 'pending';
+    connected: false;
+    message: string;
+} & StartLoginResult;
+type OpenPositionsResult = {
+    status: 'connected';
+    connected: true;
+    openPositions: OpenPositionsSnapshot;
+} | PendingLedgerLoginResult;
+type LedgerFillsResult = {
+    status: 'connected';
+    connected: true;
+    fills: LedgerFillsPage;
+} | PendingLedgerLoginResult;
+type LedgerSummaryResult = {
+    status: 'connected';
+    connected: true;
+    summary: LedgerSummary;
+} | PendingLedgerLoginResult;
+declare class HeliosAgentMcpLedgerService {
+    private readonly authService;
+    private readonly dataBridgeClient;
+    constructor(options: HeliosAgentMcpLedgerServiceOptions);
+    getOpenPositions(): Promise<OpenPositionsResult>;
+    getFills(input?: LedgerFillsInput): Promise<LedgerFillsResult>;
+    getSummary(input?: LedgerSummaryInput): Promise<LedgerSummaryResult>;
+    private accountReadOptions;
+}
+
+interface HeliosAgentMcpMarketServiceOptions {
+    authService: HeliosAgentMcpAuthService;
+    dataBridgeClient: HeliosAgentDataBridgeClient;
+}
+type MarketSnapshotResult = {
+    status: 'connected';
+    connected: true;
+    snapshot: MarketSnapshot;
+} | ({
+    status: 'pending';
+    connected: false;
+    message: string;
+} & StartLoginResult);
+type MarketSnapshotChunkResult = {
+    status: 'connected';
+    connected: true;
+    snapshotChunk: MarketSnapshotChunk;
+} | ({
+    status: 'pending';
+    connected: false;
+    message: string;
+} & StartLoginResult);
+type MarketSymbolDetailResult = {
+    status: 'connected';
+    connected: true;
+    detail: MarketSymbolDetail;
+} | ({
+    status: 'pending';
+    connected: false;
+    message: string;
+} & StartLoginResult);
+declare class HeliosAgentMcpMarketService {
+    private readonly authService;
+    private readonly dataBridgeClient;
+    constructor(options: HeliosAgentMcpMarketServiceOptions);
+    getSnapshot(input?: MarketSnapshotInput): Promise<MarketSnapshotResult>;
+    getSnapshotChunk(input?: MarketSnapshotChunkInput): Promise<MarketSnapshotChunkResult>;
+    getSymbolDetail(input: MarketSymbolDetailInput): Promise<MarketSymbolDetailResult>;
+}
+
+interface HeliosAgentMcpTradingServiceOptions {
+    authService: HeliosAgentMcpAuthService;
+    dataBridgeClient: HeliosAgentDataBridgeClient;
+    providerService: HeliosAgentMcpProviderService;
+}
+type PendingTradingLoginResult = {
+    status: 'pending';
+    connected: false;
+    message: string;
+} & StartLoginResult;
+type TradeIntentAction = 'OPEN' | 'DCA' | 'REVERSE';
+type TradeIntentActionInput = Omit<SubmitTradeIntentInput, 'intentType'>;
+type TradeIntentActionResult = {
+    status: 'connected';
+    connected: true;
+    submission: SubmitTradeIntentResult;
+} | PendingTradingLoginResult;
+type ClosePositionToolResult = {
+    status: 'connected';
+    connected: true;
+    closure: ClosePositionResult;
+} | PendingTradingLoginResult;
+type SetTpSlToolResult = {
+    status: 'connected';
+    connected: true;
+    protection: SetTpSlResult;
+} | PendingTradingLoginResult;
+type DeleteTpSlToolResult = {
+    status: 'connected';
+    connected: true;
+    deletion: DeleteTpSlResult;
+} | PendingTradingLoginResult;
+type OpenOrdersToolResult = {
+    status: 'connected';
+    connected: true;
+    orders: OpenOrder[];
+} | PendingTradingLoginResult;
+type CancelOrderToolResult = {
+    status: 'connected';
+    connected: true;
+    cancellation: CancelOrderResult;
+} | PendingTradingLoginResult;
+declare class HeliosAgentMcpTradingService {
+    private readonly authService;
+    private readonly dataBridgeClient;
+    private readonly providerService;
+    constructor(options: HeliosAgentMcpTradingServiceOptions);
+    open(input: TradeIntentActionInput): Promise<TradeIntentActionResult>;
+    dca(input: TradeIntentActionInput): Promise<TradeIntentActionResult>;
+    reverse(input: TradeIntentActionInput): Promise<TradeIntentActionResult>;
+    close(input: ClosePositionInput): Promise<ClosePositionToolResult>;
+    setTpSl(input: SetTpSlInput): Promise<SetTpSlToolResult>;
+    deleteTpSl(input: DeleteTpSlInput): Promise<DeleteTpSlToolResult>;
+    getOpenOrders(): Promise<OpenOrdersToolResult>;
+    cancelOrder(input: CancelOrderInput): Promise<CancelOrderToolResult>;
+    private submitIntent;
+}
+
+interface CreateHeliosAgentMcpServerOptions {
+    identityServiceUrl: string;
+    dataBridgeUrl: string;
+    fetch?: FetchLike;
+    sessionStore?: AgentMcpSessionStore;
+    sessionPath?: string;
+    refreshWindowMs?: number;
+    docsRoot?: string;
+    /**
+     * The hosted server (apps/mcp-service): the session comes from the AI app's OAuth token, so the device-login tools are
+     * left out (whoami stays) and no tool ever starts a login of its own.
+     */
+    hosted?: boolean;
+}
+declare function createHeliosAgentMcpServer(options: CreateHeliosAgentMcpServerOptions): Promise<{
+    server: McpServer;
+    authService: HeliosAgentMcpAuthService;
+    providerService: HeliosAgentMcpProviderService;
+    accountService: HeliosAgentMcpAccountService;
+    docsService: HeliosAgentMcpDocsService;
+    ledgerService: HeliosAgentMcpLedgerService;
+    marketService: HeliosAgentMcpMarketService;
+    tradingService: HeliosAgentMcpTradingService;
+    sessionStore: AgentMcpSessionStore;
+}>;
+declare function toolAnnotations(name: string): {
+    readOnlyHint: boolean;
+    destructiveHint: boolean;
+    openWorldHint: boolean;
+};
+
+interface HeliosMcpToolResult<TStructuredContent extends object> {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    structuredContent: TStructuredContent;
+}
+interface HeliosMcpToolDefinition<TInput, TStructuredContent extends object> {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodType<TInput>;
+    execute(input: TInput): Promise<HeliosMcpToolResult<TStructuredContent>>;
+}
+declare function createHeliosDocsToolDefinitions(service: HeliosAgentMcpDocsService): readonly [{
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{}, z.core.$strip>;
+    execute(): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: HeliosAgentMcpDocsIndex;
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strip>;
+    execute(input: {
+        path: string;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: HeliosAgentMcpDocument;
+    }>;
+}];
+declare function createHeliosAuthToolDefinitions(service: HeliosAgentMcpAuthService): readonly [{
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        clientName: z.ZodString;
+        scope: z.ZodArray<z.ZodEnum<{
+            "account:read": "account:read";
+            "market:read": "market:read";
+            "orders:write": "orders:write";
+            "orders:cancel": "orders:cancel";
+        }>>;
+        constraints: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip>;
+    execute(input: {
+        clientName: string;
+        scope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
+        constraints?: Record<string, unknown> | undefined;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
+            startedAt: string;
+        };
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        clientName: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            "account:read": "account:read";
+            "market:read": "market:read";
+            "orders:write": "orders:write";
+            "orders:cancel": "orders:cancel";
+        }>>>;
+        constraints: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip>;
+    execute(input: {
+        clientName?: string | undefined;
+        scope?: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[] | undefined;
+        constraints?: Record<string, unknown> | undefined;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            ownerUserId?: string | undefined;
+            agentGrantId?: string | undefined;
+            scope?: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[] | undefined;
+            accessTokenExpiresAt?: string | undefined;
+            lastRefreshedAt?: string | undefined;
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[];
+            startedAt: string;
+            status: "pending";
+            connected: false;
+            message: string;
+        };
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        deviceCode: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    execute(input: {
+        deviceCode?: string | undefined;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            ownerUserId?: string | undefined;
+            agentGrantId?: string | undefined;
+            scope?: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[] | undefined;
+            accessTokenExpiresAt?: string | undefined;
+            lastRefreshedAt?: string | undefined;
+        } | {
+            status: "pending" | "rejected" | "expired" | "failed";
+            connected: false;
+            message: string;
+        };
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{}, z.core.$strip>;
+    execute(): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            connected: boolean;
+            status: "pending" | "connected" | "rejected" | "expired" | "disconnected" | "failed";
+            ownerUserId?: string | undefined;
+            agentGrantId?: string | undefined;
+            scope?: ("account:read" | "market:read" | "orders:write" | "orders:cancel")[] | undefined;
+            accessTokenExpiresAt?: string | undefined;
+            lastRefreshedAt?: string | undefined;
+        };
+    }>;
+}];
+declare function createHeliosProviderToolDefinitions(service: HeliosAgentMcpProviderService): readonly [{
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{}, z.core.$strip>;
+    execute(): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: ActiveProviderView;
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        provider: z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+        }>;
+    }, z.core.$strip>;
+    execute(input: {
+        provider: "hyperliquid";
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: ActiveProviderView;
+    }>;
+}];
+declare function createHeliosAccountToolDefinitions(service: HeliosAgentMcpAccountService): readonly [{
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{}, z.core.$strip>;
+    execute(): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            walletState: WalletState;
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            connected: false;
+            message: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: AgentDeviceStartInput["scope"];
+            startedAt: string;
+        };
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        provider: z.ZodOptional<z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+        }>>;
+    }, z.core.$strip>;
+    execute(input: {
+        provider?: "hyperliquid" | undefined;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            portfolio: PortfolioSnapshot;
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            connected: false;
+            message: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: AgentDeviceStartInput["scope"];
+            startedAt: string;
+        };
+    }>;
+}];
+declare function createHeliosLedgerToolDefinitions(service: HeliosAgentMcpLedgerService): readonly [{
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{}, z.core.$strip>;
+    execute(): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            openPositions: OpenPositionsSnapshot;
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            connected: false;
+            message: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: AgentDeviceStartInput["scope"];
+            startedAt: string;
+        };
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        window: z.ZodOptional<z.ZodEnum<{
+            "24h": "24h";
+            "7d": "7d";
+            "30d": "30d";
+        }>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+        before: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    execute(input: {
+        window?: "24h" | "7d" | "30d" | undefined;
+        limit?: number | undefined;
+        before?: number | undefined;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            fills: LedgerFillsPage;
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            connected: false;
+            message: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: AgentDeviceStartInput["scope"];
+            startedAt: string;
+        };
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        window: z.ZodOptional<z.ZodEnum<{
+            "24h": "24h";
+            "7d": "7d";
+            "30d": "30d";
+        }>>;
+    }, z.core.$strip>;
+    execute(input: {
+        window?: "24h" | "7d" | "30d" | undefined;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            summary: LedgerSummary;
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            connected: false;
+            message: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: AgentDeviceStartInput["scope"];
+            startedAt: string;
+        };
+    }>;
+}];
+declare function createHeliosMarketToolDefinitions(service: HeliosAgentMcpMarketService): readonly [{
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        scope: z.ZodOptional<z.ZodEnum<{
+            selected: "selected";
+            all: "all";
+        }>>;
+        symbols: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    execute(input: {
+        scope?: "selected" | "all" | undefined;
+        symbols?: string[] | undefined;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            snapshot: MarketSnapshot;
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            connected: false;
+            message: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: AgentDeviceStartInput["scope"];
+            startedAt: string;
+        };
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        scope: z.ZodOptional<z.ZodEnum<{
+            selected: "selected";
+            all: "all";
+        }>>;
+        symbols: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        offset: z.ZodOptional<z.ZodNumber>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    execute(input: {
+        scope?: "selected" | "all" | undefined;
+        symbols?: string[] | undefined;
+        offset?: number | undefined;
+        limit?: number | undefined;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            snapshotChunk: MarketSnapshotChunk;
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            connected: false;
+            message: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: AgentDeviceStartInput["scope"];
+            startedAt: string;
+        };
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        symbol: z.ZodString;
+    }, z.core.$strip>;
+    execute(input: {
+        symbol: string;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            detail: MarketSymbolDetail;
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            connected: false;
+            message: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: AgentDeviceStartInput["scope"];
+            startedAt: string;
+        };
+    }>;
+}];
+declare function createHeliosTradingToolDefinitions(service: HeliosAgentMcpTradingService): readonly [{
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        symbol: z.ZodString;
+        provider: z.ZodOptional<z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+        }>>;
+        direction: z.ZodEnum<{
+            LONG: "LONG";
+            SHORT: "SHORT";
+        }>;
+        size: z.ZodObject<{
+            mode: z.ZodEnum<{
+                MARGIN_USD: "MARGIN_USD";
+                BASE_QUANTITY: "BASE_QUANTITY";
+            }>;
+            value: z.ZodNumber;
+        }, z.core.$strip>;
+        execution: z.ZodObject<{
+            style: z.ZodEnum<{
+                MARKET: "MARKET";
+                LIMIT_TAKER: "LIMIT_TAKER";
+                LIMIT_MAKER: "LIMIT_MAKER";
+                LIMIT_GTC: "LIMIT_GTC";
+            }>;
+            timeInForce: z.ZodOptional<z.ZodEnum<{
+                GTC: "GTC";
+                IOC: "IOC";
+                FOK: "FOK";
+                GTX: "GTX";
+            }>>;
+            limitPrice: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        maxSlippageBps: z.ZodOptional<z.ZodNumber>;
+        leverageOverride: z.ZodOptional<z.ZodNumber>;
+        marginModeOverride: z.ZodOptional<z.ZodEnum<{
+            ISOLATED: "ISOLATED";
+            CROSS: "CROSS";
+        }>>;
+        reduceOnly: z.ZodOptional<z.ZodBoolean>;
+        protection: z.ZodOptional<z.ZodObject<{
+            takeProfit: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    MARKET: "MARKET";
+                    LIMIT: "LIMIT";
+                }>;
+                triggerPrice: z.ZodNumber;
+                limitPrice: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            stopLoss: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    MARKET: "MARKET";
+                    LIMIT: "LIMIT";
+                }>;
+                triggerPrice: z.ZodNumber;
+                limitPrice: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    execute(input: {
+        symbol: string;
+        direction: "LONG" | "SHORT";
+        size: {
+            mode: "MARGIN_USD" | "BASE_QUANTITY";
+            value: number;
+        };
+        execution: {
+            style: "MARKET" | "LIMIT_TAKER" | "LIMIT_MAKER" | "LIMIT_GTC";
+            timeInForce?: "GTC" | "IOC" | "FOK" | "GTX" | undefined;
+            limitPrice?: number | undefined;
+        };
+        provider?: "hyperliquid" | undefined;
+        maxSlippageBps?: number | undefined;
+        leverageOverride?: number | undefined;
+        marginModeOverride?: "ISOLATED" | "CROSS" | undefined;
+        reduceOnly?: boolean | undefined;
+        protection?: {
+            takeProfit?: {
+                kind: "MARKET" | "LIMIT";
+                triggerPrice: number;
+                limitPrice?: number | undefined;
+            } | undefined;
+            stopLoss?: {
+                kind: "MARKET" | "LIMIT";
+                triggerPrice: number;
+                limitPrice?: number | undefined;
+            } | undefined;
+        } | undefined;
+        idempotencyKey?: string | undefined;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            submission: SubmitTradeIntentResult;
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            connected: false;
+            message: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: AgentDeviceStartInput["scope"];
+            startedAt: string;
+        };
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        symbol: z.ZodString;
+        provider: z.ZodOptional<z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+        }>>;
+        direction: z.ZodEnum<{
+            LONG: "LONG";
+            SHORT: "SHORT";
+        }>;
+        size: z.ZodObject<{
+            mode: z.ZodEnum<{
+                MARGIN_USD: "MARGIN_USD";
+                BASE_QUANTITY: "BASE_QUANTITY";
+            }>;
+            value: z.ZodNumber;
+        }, z.core.$strip>;
+        execution: z.ZodObject<{
+            style: z.ZodEnum<{
+                MARKET: "MARKET";
+                LIMIT_TAKER: "LIMIT_TAKER";
+                LIMIT_MAKER: "LIMIT_MAKER";
+                LIMIT_GTC: "LIMIT_GTC";
+            }>;
+            timeInForce: z.ZodOptional<z.ZodEnum<{
+                GTC: "GTC";
+                IOC: "IOC";
+                FOK: "FOK";
+                GTX: "GTX";
+            }>>;
+            limitPrice: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        maxSlippageBps: z.ZodOptional<z.ZodNumber>;
+        leverageOverride: z.ZodOptional<z.ZodNumber>;
+        marginModeOverride: z.ZodOptional<z.ZodEnum<{
+            ISOLATED: "ISOLATED";
+            CROSS: "CROSS";
+        }>>;
+        reduceOnly: z.ZodOptional<z.ZodBoolean>;
+        protection: z.ZodOptional<z.ZodObject<{
+            takeProfit: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    MARKET: "MARKET";
+                    LIMIT: "LIMIT";
+                }>;
+                triggerPrice: z.ZodNumber;
+                limitPrice: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            stopLoss: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    MARKET: "MARKET";
+                    LIMIT: "LIMIT";
+                }>;
+                triggerPrice: z.ZodNumber;
+                limitPrice: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    execute(input: {
+        symbol: string;
+        direction: "LONG" | "SHORT";
+        size: {
+            mode: "MARGIN_USD" | "BASE_QUANTITY";
+            value: number;
+        };
+        execution: {
+            style: "MARKET" | "LIMIT_TAKER" | "LIMIT_MAKER" | "LIMIT_GTC";
+            timeInForce?: "GTC" | "IOC" | "FOK" | "GTX" | undefined;
+            limitPrice?: number | undefined;
+        };
+        provider?: "hyperliquid" | undefined;
+        maxSlippageBps?: number | undefined;
+        leverageOverride?: number | undefined;
+        marginModeOverride?: "ISOLATED" | "CROSS" | undefined;
+        reduceOnly?: boolean | undefined;
+        protection?: {
+            takeProfit?: {
+                kind: "MARKET" | "LIMIT";
+                triggerPrice: number;
+                limitPrice?: number | undefined;
+            } | undefined;
+            stopLoss?: {
+                kind: "MARKET" | "LIMIT";
+                triggerPrice: number;
+                limitPrice?: number | undefined;
+            } | undefined;
+        } | undefined;
+        idempotencyKey?: string | undefined;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            submission: SubmitTradeIntentResult;
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            connected: false;
+            message: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: AgentDeviceStartInput["scope"];
+            startedAt: string;
+        };
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        symbol: z.ZodString;
+        provider: z.ZodOptional<z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+        }>>;
+        direction: z.ZodEnum<{
+            LONG: "LONG";
+            SHORT: "SHORT";
+        }>;
+        size: z.ZodObject<{
+            mode: z.ZodEnum<{
+                MARGIN_USD: "MARGIN_USD";
+                BASE_QUANTITY: "BASE_QUANTITY";
+            }>;
+            value: z.ZodNumber;
+        }, z.core.$strip>;
+        execution: z.ZodObject<{
+            style: z.ZodEnum<{
+                MARKET: "MARKET";
+                LIMIT_TAKER: "LIMIT_TAKER";
+                LIMIT_MAKER: "LIMIT_MAKER";
+                LIMIT_GTC: "LIMIT_GTC";
+            }>;
+            timeInForce: z.ZodOptional<z.ZodEnum<{
+                GTC: "GTC";
+                IOC: "IOC";
+                FOK: "FOK";
+                GTX: "GTX";
+            }>>;
+            limitPrice: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+        maxSlippageBps: z.ZodOptional<z.ZodNumber>;
+        leverageOverride: z.ZodOptional<z.ZodNumber>;
+        marginModeOverride: z.ZodOptional<z.ZodEnum<{
+            ISOLATED: "ISOLATED";
+            CROSS: "CROSS";
+        }>>;
+        reduceOnly: z.ZodOptional<z.ZodBoolean>;
+        protection: z.ZodOptional<z.ZodObject<{
+            takeProfit: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    MARKET: "MARKET";
+                    LIMIT: "LIMIT";
+                }>;
+                triggerPrice: z.ZodNumber;
+                limitPrice: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+            stopLoss: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    MARKET: "MARKET";
+                    LIMIT: "LIMIT";
+                }>;
+                triggerPrice: z.ZodNumber;
+                limitPrice: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        idempotencyKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    execute(input: {
+        symbol: string;
+        direction: "LONG" | "SHORT";
+        size: {
+            mode: "MARGIN_USD" | "BASE_QUANTITY";
+            value: number;
+        };
+        execution: {
+            style: "MARKET" | "LIMIT_TAKER" | "LIMIT_MAKER" | "LIMIT_GTC";
+            timeInForce?: "GTC" | "IOC" | "FOK" | "GTX" | undefined;
+            limitPrice?: number | undefined;
+        };
+        provider?: "hyperliquid" | undefined;
+        maxSlippageBps?: number | undefined;
+        leverageOverride?: number | undefined;
+        marginModeOverride?: "ISOLATED" | "CROSS" | undefined;
+        reduceOnly?: boolean | undefined;
+        protection?: {
+            takeProfit?: {
+                kind: "MARKET" | "LIMIT";
+                triggerPrice: number;
+                limitPrice?: number | undefined;
+            } | undefined;
+            stopLoss?: {
+                kind: "MARKET" | "LIMIT";
+                triggerPrice: number;
+                limitPrice?: number | undefined;
+            } | undefined;
+        } | undefined;
+        idempotencyKey?: string | undefined;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            submission: SubmitTradeIntentResult;
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            connected: false;
+            message: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: AgentDeviceStartInput["scope"];
+            startedAt: string;
+        };
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        provider: z.ZodOptional<z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+        }>>;
+        symbol: z.ZodString;
+        maxSlippageBps: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    execute(input: {
+        symbol: string;
+        provider?: "hyperliquid" | undefined;
+        maxSlippageBps?: number | undefined;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            closure: ClosePositionResult;
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            connected: false;
+            message: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: AgentDeviceStartInput["scope"];
+            startedAt: string;
+        };
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        provider: z.ZodOptional<z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+        }>>;
+        symbol: z.ZodString;
+        applyTo: z.ZodEnum<{
+            FULL_POSITION: "FULL_POSITION";
+            CUSTOM_QUANTITY: "CUSTOM_QUANTITY";
+        }>;
+        quantity: z.ZodOptional<z.ZodNumber>;
+        parentClientOrderId: z.ZodString;
+        takeProfit: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                MARKET: "MARKET";
+                LIMIT: "LIMIT";
+            }>;
+            triggerPrice: z.ZodNumber;
+            limitPrice: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        stopLoss: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                MARKET: "MARKET";
+                LIMIT: "LIMIT";
+            }>;
+            triggerPrice: z.ZodNumber;
+            limitPrice: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    execute(input: {
+        symbol: string;
+        applyTo: "FULL_POSITION" | "CUSTOM_QUANTITY";
+        parentClientOrderId: string;
+        provider?: "hyperliquid" | undefined;
+        quantity?: number | undefined;
+        takeProfit?: {
+            kind: "MARKET" | "LIMIT";
+            triggerPrice: number;
+            limitPrice?: number | undefined;
+        } | undefined;
+        stopLoss?: {
+            kind: "MARKET" | "LIMIT";
+            triggerPrice: number;
+            limitPrice?: number | undefined;
+        } | undefined;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            protection: SetTpSlResult;
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            connected: false;
+            message: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: AgentDeviceStartInput["scope"];
+            startedAt: string;
+        };
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        provider: z.ZodOptional<z.ZodEnum<{
+            hyperliquid: "hyperliquid";
+        }>>;
+        symbol: z.ZodString;
+        orderId: z.ZodString;
+    }, z.core.$strip>;
+    execute(input: {
+        symbol: string;
+        orderId: string;
+        provider?: "hyperliquid" | undefined;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            deletion: DeleteTpSlResult;
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            connected: false;
+            message: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: AgentDeviceStartInput["scope"];
+            startedAt: string;
+        };
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{}, z.core.$strip>;
+    execute(): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            orders: OpenOrder[];
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            connected: false;
+            message: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: AgentDeviceStartInput["scope"];
+            startedAt: string;
+        };
+    }>;
+}, {
+    name: string;
+    title: string;
+    description: string;
+    inputSchema: z.ZodObject<{
+        symbol: z.ZodString;
+        oid: z.ZodNumber;
+    }, z.core.$strip>;
+    execute(input: {
+        symbol: string;
+        oid: number;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        structuredContent: {
+            status: "connected";
+            connected: true;
+            cancellation: CancelOrderResult;
+        } | {
+            actionRequired: true;
+            loginUrl: string;
+            nextStep: string;
+            status: "pending";
+            connected: false;
+            message: string;
+            deviceCode: string;
+            userCode: string;
+            verificationUri: string;
+            verificationUriComplete: string;
+            expiresInSeconds: number;
+            pollIntervalSeconds: number;
+            requestedScope: AgentDeviceStartInput["scope"];
+            startedAt: string;
+        };
+    }>;
+}];
+
+export { type ActiveProviderView, type AgentMcpSessionStore, type CancelOrderToolResult, type ClosePositionToolResult, type CreateHeliosAgentMcpServerOptions, 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, createHeliosAccountToolDefinitions, createHeliosAgentMcpServer, createHeliosAuthToolDefinitions, createHeliosDocsToolDefinitions, createHeliosLedgerToolDefinitions, createHeliosMarketToolDefinitions, createHeliosProviderToolDefinitions, createHeliosTradingToolDefinitions, formatHeliosLoginPrompt, getDefaultHeliosAgentMcpDocsRoot, getDefaultHeliosAgentMcpSessionPath, pendingAgentLoginSchema, retryAfterUnauthorizedRefresh, toolAnnotations };