@pgnio/helios-mcp 0.0.0-stage → 0.2.1

package/dist/index.js

@@ -0,0 +1,3043 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FileAgentSessionStore: () => FileAgentSessionStore,
+  HOSTED_RECONNECT_MESSAGE: () => HOSTED_RECONNECT_MESSAGE,
+  HeliosAgentMcpAccountService: () => HeliosAgentMcpAccountService,
+  HeliosAgentMcpAuthService: () => HeliosAgentMcpAuthService,
+  HeliosAgentMcpDocsService: () => HeliosAgentMcpDocsService,
+  HeliosAgentMcpLedgerService: () => HeliosAgentMcpLedgerService,
+  HeliosAgentMcpMarketService: () => HeliosAgentMcpMarketService,
+  HeliosAgentMcpProviderService: () => HeliosAgentMcpProviderService,
+  HeliosAgentMcpTradingService: () => HeliosAgentMcpTradingService,
+  MemoryAgentMcpSessionStore: () => MemoryAgentMcpSessionStore,
+  createHeliosAccountToolDefinitions: () => createHeliosAccountToolDefinitions,
+  createHeliosAgentMcpServer: () => createHeliosAgentMcpServer,
+  createHeliosAuthToolDefinitions: () => createHeliosAuthToolDefinitions,
+  createHeliosDocsToolDefinitions: () => createHeliosDocsToolDefinitions,
+  createHeliosLedgerToolDefinitions: () => createHeliosLedgerToolDefinitions,
+  createHeliosMarketToolDefinitions: () => createHeliosMarketToolDefinitions,
+  createHeliosProviderToolDefinitions: () => createHeliosProviderToolDefinitions,
+  createHeliosTradingToolDefinitions: () => createHeliosTradingToolDefinitions,
+  formatHeliosLoginPrompt: () => formatHeliosLoginPrompt,
+  getDefaultHeliosAgentMcpDocsRoot: () => getDefaultHeliosAgentMcpDocsRoot,
+  getDefaultHeliosAgentMcpSessionPath: () => getDefaultHeliosAgentMcpSessionPath,
+  pendingAgentLoginSchema: () => pendingAgentLoginSchema,
+  retryAfterUnauthorizedRefresh: () => retryAfterUnauthorizedRefresh,
+  toolAnnotations: () => toolAnnotations
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../agent/dist/index.mjs
+var import_zod = require("zod");
+var import_zod2 = require("zod");
+var import_zod3 = require("zod");
+var __defProp2 = Object.defineProperty;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField2 = (obj, key, value) => __defNormalProp2(obj, typeof key !== "symbol" ? key + "" : key, value);
+var AGENT_SCOPES = {
+  ACCOUNT_READ: "account:read",
+  MARKET_READ: "market:read",
+  ORDERS_WRITE: "orders:write",
+  ORDERS_CANCEL: "orders:cancel"
+};
+var AGENT_SCOPE_VALUES = [
+  AGENT_SCOPES.ACCOUNT_READ,
+  AGENT_SCOPES.MARKET_READ,
+  AGENT_SCOPES.ORDERS_WRITE,
+  AGENT_SCOPES.ORDERS_CANCEL
+];
+var agentScopeSchema = import_zod.z.enum(AGENT_SCOPE_VALUES);
+var agentGrantStatusSchema = import_zod.z.enum(["active", "revoked"]);
+var agentDeviceRequestStatusSchema = import_zod.z.enum(["pending", "approved", "rejected", "exchanged", "expired"]);
+var agentConstraintsSchema = import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).default({});
+var agentGrantMetadataSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  userId: import_zod.z.string(),
+  clientName: import_zod.z.string(),
+  status: agentGrantStatusSchema,
+  scope: import_zod.z.array(agentScopeSchema).min(1),
+  constraints: agentConstraintsSchema,
+  tokenVersion: import_zod.z.number().int().nonnegative(),
+  createdAt: import_zod.z.string(),
+  approvedAt: import_zod.z.string().optional(),
+  lastUsedAt: import_zod.z.string().optional(),
+  revokedAt: import_zod.z.string().optional()
+});
+var agentDeviceStartInputSchema = import_zod.z.object({
+  clientName: import_zod.z.string().min(1).max(64),
+  scope: import_zod.z.array(agentScopeSchema).min(1),
+  constraints: agentConstraintsSchema.optional()
+});
+var agentDeviceStartOutputSchema = import_zod.z.object({
+  deviceCode: import_zod.z.string(),
+  userCode: import_zod.z.string(),
+  verificationUri: import_zod.z.string().url(),
+  verificationUriComplete: import_zod.z.string().url(),
+  expiresInSeconds: import_zod.z.number().int().positive(),
+  pollIntervalSeconds: import_zod.z.number().int().positive()
+});
+var agentDeviceTokenInputSchema = import_zod.z.object({
+  deviceCode: import_zod.z.string().min(1)
+});
+var agentDeviceRequestViewSchema = import_zod.z.object({
+  userCode: import_zod.z.string(),
+  clientName: import_zod.z.string(),
+  scope: import_zod.z.array(agentScopeSchema).min(1),
+  constraints: agentConstraintsSchema,
+  status: agentDeviceRequestStatusSchema,
+  expiresAt: import_zod.z.string()
+});
+var agentTokenResponseSchema = import_zod.z.object({
+  accessToken: import_zod.z.string(),
+  refreshToken: import_zod.z.string(),
+  tokenType: import_zod.z.literal("Bearer"),
+  expiresInSeconds: import_zod.z.number().int().positive(),
+  scope: import_zod.z.array(agentScopeSchema).min(1),
+  ownerUserId: import_zod.z.string(),
+  agentGrantId: import_zod.z.string()
+});
+var agentRefreshInputSchema = import_zod.z.object({
+  refreshToken: import_zod.z.string().min(1)
+});
+var agentApprovalResponseSchema = import_zod.z.object({
+  request: agentDeviceRequestViewSchema,
+  grant: agentGrantMetadataSchema
+});
+var agentSessionStateSchema = import_zod.z.object({
+  status: import_zod.z.enum(["pending", "authorized", "rejected", "revoked"]),
+  request: agentDeviceRequestViewSchema.optional(),
+  grant: agentGrantMetadataSchema.optional()
+});
+var providerSchema = import_zod.z.enum(["hyperliquid"]);
+var walletStateSchema = import_zod.z.object({
+  provider: import_zod.z.literal("hyperliquid"),
+  accountValue: import_zod.z.number(),
+  availableBalance: import_zod.z.number(),
+  withdrawable: import_zod.z.number(),
+  totalMarginUsed: import_zod.z.number(),
+  totalNotionalPosition: import_zod.z.number(),
+  crossMarginAccountValue: import_zod.z.number(),
+  isActivated: import_zod.z.boolean(),
+  fetchedAt: import_zod.z.string().datetime()
+});
+var openPositionSchema = import_zod.z.object({
+  symbol: import_zod.z.string(),
+  side: import_zod.z.enum(["LONG", "SHORT"]),
+  size: import_zod.z.number(),
+  entryPrice: import_zod.z.number(),
+  markPrice: import_zod.z.number(),
+  unrealizedPnl: import_zod.z.number(),
+  margin: import_zod.z.number(),
+  leverage: import_zod.z.number(),
+  liquidationPrice: import_zod.z.number().optional()
+});
+var openPositionsSnapshotSchema = import_zod.z.object({
+  provider: import_zod.z.literal("hyperliquid"),
+  fetchedAt: import_zod.z.string().datetime(),
+  totalUnrealizedPnl: import_zod.z.number(),
+  positions: import_zod.z.array(openPositionSchema)
+});
+var protectiveOrderKindSchema = import_zod.z.enum(["STOP_LOSS", "TAKE_PROFIT"]);
+var protectiveOrderSideSchema = import_zod.z.enum(["BUY", "SELL"]);
+var protectiveOrderPositionSideSchema = import_zod.z.enum(["BOTH", "LONG", "SHORT"]);
+var protectiveOrderSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  binanceOrderId: import_zod.z.number().int().nonnegative().optional(),
+  clientOrderId: import_zod.z.string().optional(),
+  symbol: import_zod.z.string(),
+  side: protectiveOrderSideSchema,
+  positionSide: protectiveOrderPositionSideSchema,
+  status: import_zod.z.string(),
+  kind: protectiveOrderKindSchema,
+  groupId: import_zod.z.string(),
+  stopPrice: import_zod.z.string().optional(),
+  parentClientOrderId: import_zod.z.string().optional(),
+  assetId: import_zod.z.number().int().nonnegative().optional(),
+  createdAt: import_zod.z.string().datetime()
+});
+var hyperliquidPortfolioSnapshotSchema = import_zod.z.object({
+  provider: import_zod.z.literal("hyperliquid"),
+  totalBalance: import_zod.z.number(),
+  availableBalance: import_zod.z.number(),
+  totalMargin: import_zod.z.number(),
+  unrealizedPnl: import_zod.z.number(),
+  positions: import_zod.z.array(openPositionSchema),
+  protectiveOrders: import_zod.z.array(protectiveOrderSchema)
+});
+var portfolioInputSchema = import_zod.z.object({
+  provider: providerSchema
+});
+var portfolioSnapshotSchema = hyperliquidPortfolioSnapshotSchema;
+var ledgerWindowSchema = import_zod.z.enum(["24h", "7d", "30d"]);
+var ledgerFillsInputSchema = import_zod.z.object({
+  window: ledgerWindowSchema.optional(),
+  limit: import_zod.z.number().int().positive().max(200).optional(),
+  before: import_zod.z.number().int().nonnegative().optional()
+});
+var ledgerFillSchema = import_zod.z.object({
+  coin: import_zod.z.string(),
+  px: import_zod.z.number(),
+  sz: import_zod.z.number(),
+  side: import_zod.z.enum(["B", "A"]),
+  time: import_zod.z.number().int().nonnegative(),
+  dir: import_zod.z.string(),
+  closedPnl: import_zod.z.number(),
+  fee: import_zod.z.number(),
+  crossed: import_zod.z.boolean(),
+  oid: import_zod.z.number().int().nonnegative(),
+  tid: import_zod.z.number().int().nonnegative()
+});
+var ledgerFillsPageSchema = import_zod.z.object({
+  window: ledgerWindowSchema,
+  limit: import_zod.z.number().int().positive(),
+  before: import_zod.z.number().int().nonnegative().optional(),
+  hasMore: import_zod.z.boolean(),
+  nextBefore: import_zod.z.number().int().nonnegative().optional(),
+  fetchedAt: import_zod.z.string().datetime(),
+  fills: import_zod.z.array(ledgerFillSchema)
+});
+var ledgerPeriodSummarySchema = import_zod.z.object({
+  realizedPnl: import_zod.z.number(),
+  totalFees: import_zod.z.number(),
+  fillCount: import_zod.z.number().int().nonnegative(),
+  closeCount: import_zod.z.number().int().nonnegative(),
+  winCount: import_zod.z.number().int().nonnegative(),
+  lossCount: import_zod.z.number().int().nonnegative(),
+  averageWin: import_zod.z.number(),
+  averageLoss: import_zod.z.number()
+});
+var ledgerSummaryInputSchema = import_zod.z.object({
+  window: ledgerWindowSchema.optional()
+});
+var ledgerSummarySchema = ledgerPeriodSummarySchema.extend({
+  window: ledgerWindowSchema,
+  generatedAt: import_zod.z.string().datetime(),
+  periods: import_zod.z.object({
+    "24h": ledgerPeriodSummarySchema,
+    "7d": ledgerPeriodSummarySchema
+  })
+});
+var marketSnapshotScopeSchema = import_zod.z.enum(["selected", "all"]);
+var marketSnapshotResolvedScopeSchema = import_zod.z.enum(["selected", "all", "explicit"]);
+var marketSnapshotValueSchema = import_zod.z.union([import_zod.z.string(), import_zod.z.number(), import_zod.z.boolean(), import_zod.z.null()]);
+var marketSnapshotInputSchema = import_zod.z.object({
+  scope: marketSnapshotScopeSchema.optional(),
+  symbols: import_zod.z.array(import_zod.z.string().min(1)).min(1).optional()
+});
+var marketSnapshotChunkInputSchema = marketSnapshotInputSchema.extend({
+  offset: import_zod.z.number().int().nonnegative().optional(),
+  limit: import_zod.z.number().int().positive().max(100).optional()
+});
+var marketFieldBlockSchema = import_zod.z.object({
+  fieldIds: import_zod.z.array(import_zod.z.string()).min(1),
+  values: import_zod.z.array(marketSnapshotValueSchema),
+  symbolLists: import_zod.z.record(import_zod.z.string(), import_zod.z.array(import_zod.z.string())).optional()
+});
+var marketMatrixSchema = import_zod.z.object({
+  fieldIds: import_zod.z.array(import_zod.z.string()).min(1),
+  rows: import_zod.z.array(import_zod.z.array(marketSnapshotValueSchema))
+});
+var marketFieldSemanticsSchema = import_zod.z.object({
+  nullMeans: import_zod.z.literal("unavailable"),
+  percentScale: import_zod.z.literal("already_percent"),
+  percentFields: import_zod.z.array(import_zod.z.string()).min(1),
+  changeMapPercentKeys: import_zod.z.array(import_zod.z.string()).min(1)
+});
+var marketSnapshotSchema = import_zod.z.object({
+  schema: import_zod.z.literal("helios.market_snapshot.v1"),
+  view: import_zod.z.literal("market_overview"),
+  scope: marketSnapshotResolvedScopeSchema,
+  symbolCount: import_zod.z.number().int().nonnegative(),
+  generatedAt: import_zod.z.string().datetime(),
+  returnedSymbols: import_zod.z.array(import_zod.z.string()),
+  semantics: marketFieldSemanticsSchema,
+  market: marketFieldBlockSchema,
+  table: marketMatrixSchema,
+  legend: import_zod.z.record(import_zod.z.string(), import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.string())]))
+});
+var marketSnapshotChunkSchema = import_zod.z.object({
+  schema: import_zod.z.literal("helios.market_snapshot_chunk.v1"),
+  view: import_zod.z.literal("market_overview_chunk"),
+  scope: marketSnapshotResolvedScopeSchema,
+  totalSymbolCount: import_zod.z.number().int().nonnegative(),
+  generatedAt: import_zod.z.string().datetime(),
+  offset: import_zod.z.number().int().nonnegative(),
+  limit: import_zod.z.number().int().positive(),
+  chunkSymbolCount: import_zod.z.number().int().nonnegative(),
+  hasMore: import_zod.z.boolean(),
+  nextOffset: import_zod.z.number().int().nonnegative().optional(),
+  returnedSymbols: import_zod.z.array(import_zod.z.string()),
+  semantics: marketFieldSemanticsSchema,
+  market: marketFieldBlockSchema,
+  table: marketMatrixSchema,
+  legend: import_zod.z.record(import_zod.z.string(), import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.string())]))
+});
+var marketSymbolDetailInputSchema = import_zod.z.object({
+  symbol: import_zod.z.string().min(1)
+});
+var marketSymbolDetailSchema = import_zod.z.object({
+  schema: import_zod.z.literal("helios.market_symbol_detail.v1"),
+  generatedAt: import_zod.z.string().datetime(),
+  symbol: import_zod.z.string(),
+  semantics: marketFieldSemanticsSchema,
+  market: marketFieldBlockSchema,
+  row: import_zod.z.record(import_zod.z.string(), marketSnapshotValueSchema),
+  symbolCtx: import_zod.z.record(import_zod.z.string(), marketSnapshotValueSchema),
+  changeMap: import_zod.z.record(import_zod.z.string(), import_zod.z.number().nullable()),
+  metrics: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).nullable(),
+  legend: import_zod.z.record(import_zod.z.string(), import_zod.z.union([import_zod.z.string(), import_zod.z.array(import_zod.z.string())]))
+});
+var tradingDirectionSchema = import_zod.z.enum(["LONG", "SHORT"]);
+var tradingExecutionStyleSchema = import_zod.z.enum(["MARKET", "LIMIT_TAKER", "LIMIT_MAKER", "LIMIT_GTC"]);
+var tradingSizeSchema = import_zod.z.object({
+  mode: import_zod.z.enum(["MARGIN_USD", "BASE_QUANTITY"]),
+  value: import_zod.z.number().positive()
+});
+var tradingProtectionLegSchema = import_zod.z.object({
+  kind: import_zod.z.enum(["LIMIT", "MARKET"]),
+  triggerPrice: import_zod.z.number().positive(),
+  limitPrice: import_zod.z.number().positive().optional()
+});
+var tradingProtectionSchema = import_zod.z.object({
+  takeProfit: tradingProtectionLegSchema.optional(),
+  stopLoss: tradingProtectionLegSchema.optional()
+});
+var tradeIntentTypeSchema = import_zod.z.enum(["OPEN", "DCA", "REVERSE", "CLOSE"]);
+var submitTradeIntentInputSchema = import_zod.z.object({
+  provider: providerSchema.optional(),
+  symbol: import_zod.z.string().regex(/^[a-zA-Z0-9]+(?:USDT)?$/),
+  intentType: tradeIntentTypeSchema,
+  direction: tradingDirectionSchema,
+  size: tradingSizeSchema,
+  execution: import_zod.z.object({
+    style: tradingExecutionStyleSchema,
+    timeInForce: import_zod.z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+    limitPrice: import_zod.z.number().positive().optional()
+  }),
+  maxSlippageBps: import_zod.z.number().int().nonnegative().max(1e3).optional(),
+  leverageOverride: import_zod.z.number().positive().optional(),
+  marginModeOverride: import_zod.z.enum(["ISOLATED", "CROSS"]).optional(),
+  reduceOnly: import_zod.z.boolean().optional(),
+  protection: tradingProtectionSchema.optional(),
+  /** One per user action, reused on retries: the data-bridge never places a second order for the same key. */
+  idempotencyKey: import_zod.z.string().regex(/^[A-Za-z0-9_-]{8,64}$/).optional()
+});
+var submitTradeIntentResultSchema = import_zod.z.object({
+  status: import_zod.z.literal("submitted"),
+  /** `replayed`: an earlier attempt of this action already placed the order; nothing new was sent. */
+  outcome: import_zod.z.enum(["placed", "replayed"]).optional(),
+  clientOrderId: import_zod.z.string().optional(),
+  orderStatus: import_zod.z.string().optional(),
+  /** TP/SL legs Hyperliquid refused while the entry went through: the position is open without them. */
+  rejectedProtection: import_zod.z.array(import_zod.z.object({ kind: import_zod.z.string(), reason: import_zod.z.string() })).optional(),
+  provider: providerSchema.optional(),
+  symbol: import_zod.z.string(),
+  intentType: tradeIntentTypeSchema,
+  direction: tradingDirectionSchema,
+  size: tradingSizeSchema,
+  execution: import_zod.z.object({
+    style: tradingExecutionStyleSchema,
+    timeInForce: import_zod.z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+    limitPrice: import_zod.z.number().positive().optional()
+  }),
+  maxSlippageBps: import_zod.z.number().int().nonnegative().max(1e3).optional(),
+  leverageOverride: import_zod.z.number().positive().optional(),
+  marginModeOverride: import_zod.z.enum(["ISOLATED", "CROSS"]).optional(),
+  reduceOnly: import_zod.z.boolean(),
+  hasProtection: import_zod.z.boolean()
+});
+var closePositionInputSchema = import_zod.z.object({
+  provider: providerSchema.optional(),
+  symbol: import_zod.z.string().regex(/^[a-zA-Z0-9]+(?:USDT)?$/),
+  maxSlippageBps: import_zod.z.number().int().nonnegative().max(1e3).optional()
+});
+var closePositionResultSchema = import_zod.z.object({
+  status: import_zod.z.literal("submitted"),
+  provider: providerSchema.optional(),
+  symbol: import_zod.z.string(),
+  mode: import_zod.z.literal("FULL"),
+  maxSlippageBps: import_zod.z.number().int().nonnegative().max(1e3).optional()
+});
+var setTpSlInputSchema = import_zod.z.object({
+  provider: providerSchema.optional(),
+  symbol: import_zod.z.string().regex(/^[a-zA-Z0-9]+(?:USDT)?$/),
+  applyTo: import_zod.z.enum(["FULL_POSITION", "CUSTOM_QUANTITY"]),
+  quantity: import_zod.z.number().positive().optional(),
+  parentClientOrderId: import_zod.z.string(),
+  takeProfit: tradingProtectionLegSchema.optional(),
+  stopLoss: tradingProtectionLegSchema.optional()
+});
+var setTpSlResultSchema = import_zod.z.object({
+  status: import_zod.z.literal("submitted"),
+  provider: providerSchema.optional(),
+  symbol: import_zod.z.string(),
+  applyTo: import_zod.z.enum(["FULL_POSITION", "CUSTOM_QUANTITY"]),
+  quantity: import_zod.z.number().positive().optional(),
+  parentClientOrderId: import_zod.z.string(),
+  hasTakeProfit: import_zod.z.boolean(),
+  hasStopLoss: import_zod.z.boolean()
+});
+var deleteTpSlInputSchema = import_zod.z.object({
+  provider: providerSchema.optional(),
+  symbol: import_zod.z.string().regex(/^[a-zA-Z0-9]+(?:USDT)?$/),
+  orderId: import_zod.z.string()
+});
+var deleteTpSlResultSchema = import_zod.z.object({
+  status: import_zod.z.literal("deleted"),
+  provider: providerSchema.optional(),
+  symbol: import_zod.z.string(),
+  orderId: import_zod.z.string()
+});
+var openOrderSchema = import_zod.z.object({
+  coin: import_zod.z.string(),
+  side: import_zod.z.enum(["B", "A"]),
+  limitPx: import_zod.z.string(),
+  sz: import_zod.z.string(),
+  oid: import_zod.z.number().int().nonnegative(),
+  timestamp: import_zod.z.number().int().nonnegative(),
+  origSz: import_zod.z.string(),
+  orderType: import_zod.z.string(),
+  tif: import_zod.z.string().nullable(),
+  reduceOnly: import_zod.z.boolean(),
+  isTrigger: import_zod.z.boolean(),
+  triggerPx: import_zod.z.string(),
+  cloid: import_zod.z.string().nullable(),
+  assetId: import_zod.z.number().int().nonnegative().optional()
+});
+var cancelOrderInputSchema = import_zod.z.object({
+  symbol: import_zod.z.string().regex(/^[a-zA-Z0-9]+(?:USDT)?$/),
+  oid: import_zod.z.number().int().nonnegative()
+});
+var cancelOrderResultSchema = import_zod.z.object({
+  status: import_zod.z.literal("cancelled"),
+  symbol: import_zod.z.string(),
+  oid: import_zod.z.number().int().nonnegative()
+});
+var heliosAgentErrorResponseSchema = import_zod2.z.object({
+  error: import_zod2.z.string().optional(),
+  errorDescription: import_zod2.z.string().optional(),
+  message: import_zod2.z.string().optional()
+});
+var HeliosAgentApiError = class extends Error {
+  constructor(options) {
+    super(options.message);
+    __publicField2(this, "status");
+    __publicField2(this, "code");
+    __publicField2(this, "errorDescription");
+    __publicField2(this, "payload");
+    this.name = "HeliosAgentApiError";
+    this.status = options.status;
+    this.code = options.code;
+    this.errorDescription = options.errorDescription;
+    this.payload = options.payload;
+    if (options.cause !== void 0) {
+      Object.defineProperty(this, "cause", {
+        configurable: true,
+        enumerable: false,
+        value: options.cause,
+        writable: true
+      });
+    }
+  }
+};
+function isHeliosAgentApiError(error) {
+  return error instanceof HeliosAgentApiError;
+}
+var HeliosAgentAuthClient = class {
+  constructor(options) {
+    __publicField2(this, "baseUrl");
+    __publicField2(this, "fetchImpl");
+    __publicField2(this, "headers");
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.fetchImpl = options.fetch ?? fetch;
+    this.headers = options.headers ?? {};
+  }
+  async startLogin(input) {
+    const parsed = agentDeviceStartInputSchema.parse(input);
+    return this.post("/api/agents/device/start", parsed, agentDeviceStartOutputSchema);
+  }
+  async exchangeDeviceCode(deviceCode) {
+    const parsed = agentDeviceStartOutputSchema.shape.deviceCode.parse(deviceCode);
+    return this.post("/api/agents/device/token", { deviceCode: parsed }, agentTokenResponseSchema);
+  }
+  async refreshSession(refreshToken) {
+    const parsed = agentRefreshInputSchema.parse({ refreshToken });
+    return this.post("/api/agents/auth/refresh", parsed, agentTokenResponseSchema);
+  }
+  async post(path3, body, schema) {
+    let response;
+    try {
+      response = await this.fetchImpl(`${this.baseUrl}${path3}`, {
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          ...this.headers
+        },
+        body: JSON.stringify(body)
+      });
+    } catch (error) {
+      throw new HeliosAgentApiError({
+        status: 0,
+        code: "network_error",
+        message: error instanceof Error ? error.message : "Network error",
+        cause: error
+      });
+    }
+    const payload = await this.parseJson(response);
+    if (!response.ok) {
+      const parsed = heliosAgentErrorResponseSchema.safeParse(payload);
+      throw new HeliosAgentApiError({
+        status: response.status,
+        code: parsed.success ? parsed.data.error ?? "request_failed" : "request_failed",
+        message: parsed.success ? parsed.data.errorDescription ?? parsed.data.message ?? `Request failed with status ${response.status}` : `Request failed with status ${response.status}`,
+        errorDescription: parsed.success ? parsed.data.errorDescription : void 0,
+        payload
+      });
+    }
+    return schema.parse(payload);
+  }
+  async parseJson(response) {
+    const text = await response.text();
+    if (!text) {
+      return null;
+    }
+    try {
+      return JSON.parse(text);
+    } catch (error) {
+      throw new HeliosAgentApiError({
+        status: response.status,
+        code: "invalid_json",
+        message: "Received an invalid JSON response from Helios",
+        cause: error
+      });
+    }
+  }
+};
+var HeliosAgentDataBridgeClient = class {
+  constructor(options) {
+    __publicField2(this, "baseUrl");
+    __publicField2(this, "fetchImpl");
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.fetchImpl = options.fetch ?? fetch;
+  }
+  async getWalletState(accessToken) {
+    const payload = await this.request(accessToken, "account.getWalletState");
+    return walletStateSchema.parse(this.unwrapResult(payload));
+  }
+  async getOpenPositions(accessToken) {
+    const payload = await this.request(accessToken, "positions.getOpen");
+    return openPositionsSnapshotSchema.parse(this.unwrapResult(payload));
+  }
+  async getPortfolio(accessToken, input) {
+    const parsedInput = portfolioInputSchema.parse(input);
+    const payload = await this.request(accessToken, "positions.getPortfolio", parsedInput);
+    const result = this.unwrapResult(payload);
+    if (!result || typeof result !== "object" || Array.isArray(result)) {
+      throw new HeliosAgentApiError({
+        status: 200,
+        code: "invalid_response",
+        message: "Helios data bridge returned an invalid portfolio payload",
+        payload
+      });
+    }
+    return portfolioSnapshotSchema.parse({
+      ...result,
+      provider: parsedInput.provider
+    });
+  }
+  async getLedgerFills(accessToken, input = {}) {
+    const parsedInput = ledgerFillsInputSchema.parse(input);
+    const payload = await this.request(accessToken, "ledger.getFills", parsedInput);
+    return ledgerFillsPageSchema.parse(this.unwrapResult(payload));
+  }
+  async getLedgerSummary(accessToken, input = {}) {
+    const parsedInput = ledgerSummaryInputSchema.parse(input);
+    const payload = await this.request(accessToken, "ledger.getSummary", parsedInput);
+    return ledgerSummarySchema.parse(this.unwrapResult(payload));
+  }
+  async getMarketSnapshot(accessToken, input = {}) {
+    const parsedInput = marketSnapshotInputSchema.parse(input);
+    const payload = await this.request(accessToken, "market.getSnapshot", parsedInput);
+    return marketSnapshotSchema.parse(this.unwrapResult(payload));
+  }
+  async getMarketSnapshotChunk(accessToken, input = {}) {
+    const parsedInput = marketSnapshotChunkInputSchema.parse(input);
+    const payload = await this.request(accessToken, "market.getSnapshotChunk", parsedInput);
+    return marketSnapshotChunkSchema.parse(this.unwrapResult(payload));
+  }
+  async getMarketSymbolDetail(accessToken, input) {
+    const parsedInput = marketSymbolDetailInputSchema.parse(input);
+    const payload = await this.request(accessToken, "market.getSymbolDetail", parsedInput);
+    return marketSymbolDetailSchema.parse(this.unwrapResult(payload));
+  }
+  async submitTradeIntent(accessToken, input) {
+    const parsedInput = submitTradeIntentInputSchema.parse(input);
+    const payload = await this.request(accessToken, "trading.submitIntent", parsedInput, "POST");
+    const answer = this.unwrapResult(payload) ?? {};
+    return submitTradeIntentResultSchema.parse({
+      status: "submitted",
+      ...answer.outcome === "placed" || answer.outcome === "replayed" ? { outcome: answer.outcome } : {},
+      ...typeof answer.clientOrderId === "string" ? { clientOrderId: answer.clientOrderId } : {},
+      ...typeof answer.orderStatus === "string" ? { orderStatus: answer.orderStatus } : {},
+      ...Array.isArray(answer.rejectedProtection) ? { rejectedProtection: answer.rejectedProtection } : {},
+      provider: parsedInput.provider,
+      symbol: parsedInput.symbol,
+      intentType: parsedInput.intentType,
+      direction: parsedInput.direction,
+      size: parsedInput.size,
+      execution: parsedInput.execution,
+      maxSlippageBps: parsedInput.maxSlippageBps,
+      leverageOverride: parsedInput.leverageOverride,
+      marginModeOverride: parsedInput.marginModeOverride,
+      reduceOnly: Boolean(parsedInput.reduceOnly),
+      hasProtection: Boolean(parsedInput.protection?.takeProfit || parsedInput.protection?.stopLoss)
+    });
+  }
+  async closePosition(accessToken, input) {
+    const parsedInput = closePositionInputSchema.parse(input);
+    await this.request(
+      accessToken,
+      "positions.close",
+      {
+        ...parsedInput.provider !== void 0 ? { provider: parsedInput.provider } : {},
+        symbol: parsedInput.symbol,
+        mode: "FULL",
+        ...parsedInput.maxSlippageBps !== void 0 ? { maxSlippageBps: parsedInput.maxSlippageBps } : {}
+      },
+      "POST"
+    );
+    return closePositionResultSchema.parse({
+      status: "submitted",
+      provider: parsedInput.provider,
+      symbol: parsedInput.symbol,
+      mode: "FULL",
+      maxSlippageBps: parsedInput.maxSlippageBps
+    });
+  }
+  async setTpSl(accessToken, input) {
+    const parsedInput = setTpSlInputSchema.parse(input);
+    await this.request(accessToken, "positions.setTpSl", parsedInput, "POST");
+    return setTpSlResultSchema.parse({
+      status: "submitted",
+      provider: parsedInput.provider,
+      symbol: parsedInput.symbol,
+      applyTo: parsedInput.applyTo,
+      quantity: parsedInput.quantity,
+      parentClientOrderId: parsedInput.parentClientOrderId,
+      hasTakeProfit: Boolean(parsedInput.takeProfit),
+      hasStopLoss: Boolean(parsedInput.stopLoss)
+    });
+  }
+  async deleteTpSl(accessToken, input) {
+    const parsedInput = deleteTpSlInputSchema.parse(input);
+    await this.request(accessToken, "positions.deleteTpSl", parsedInput, "POST");
+    return deleteTpSlResultSchema.parse({
+      status: "deleted",
+      provider: parsedInput.provider,
+      symbol: parsedInput.symbol,
+      orderId: parsedInput.orderId
+    });
+  }
+  async getOpenOrders(accessToken) {
+    const payload = await this.request(accessToken, "positions.getOpenOrders");
+    return openOrderSchema.array().parse(this.unwrapResult(payload));
+  }
+  async cancelOrder(accessToken, input) {
+    const parsedInput = cancelOrderInputSchema.parse(input);
+    await this.request(accessToken, "positions.cancelOrder", parsedInput, "POST");
+    return cancelOrderResultSchema.parse({
+      status: "cancelled",
+      symbol: parsedInput.symbol,
+      oid: parsedInput.oid
+    });
+  }
+  async request(accessToken, procedure, input, method = "GET") {
+    let response;
+    try {
+      response = await this.fetchImpl(this.buildProcedureUrl(procedure, method === "GET" ? input : void 0), {
+        method,
+        headers: {
+          Accept: "application/json",
+          ...method === "POST" ? { "Content-Type": "application/json" } : {},
+          Authorization: `Bearer ${accessToken}`
+        },
+        ...method === "POST" && input !== void 0 ? { body: JSON.stringify({ json: input }) } : {}
+      });
+    } catch (error) {
+      throw new HeliosAgentApiError({
+        status: 0,
+        code: "network_error",
+        message: error instanceof Error ? error.message : "Network error",
+        cause: error
+      });
+    }
+    const payload = await this.parseJson(response);
+    if (!response.ok) {
+      throw new HeliosAgentApiError({
+        status: response.status,
+        code: this.extractErrorCode(payload),
+        message: this.extractErrorMessage(payload, response.status),
+        payload
+      });
+    }
+    return payload;
+  }
+  buildProcedureUrl(procedure, input) {
+    const url = new URL(`${this.baseUrl}/api/trpc/${procedure}`);
+    if (input !== void 0) {
+      url.searchParams.set("input", JSON.stringify({ json: input }));
+    }
+    return url.toString();
+  }
+  async parseJson(response) {
+    const text = await response.text();
+    if (!text) {
+      return null;
+    }
+    try {
+      return JSON.parse(text);
+    } catch (error) {
+      throw new HeliosAgentApiError({
+        status: response.status,
+        code: "invalid_json",
+        message: "Received an invalid JSON response from Helios data bridge",
+        cause: error
+      });
+    }
+  }
+  unwrapResult(payload) {
+    if (!payload || typeof payload !== "object") {
+      throw new HeliosAgentApiError({
+        status: 200,
+        code: "invalid_response",
+        message: "Helios data bridge returned an invalid response payload",
+        payload
+      });
+    }
+    const result = payload.result;
+    if (!result) {
+      throw new HeliosAgentApiError({
+        status: 200,
+        code: "invalid_response",
+        message: "Helios data bridge response is missing a result payload",
+        payload
+      });
+    }
+    const data = result.data;
+    if (data && typeof data === "object" && "json" in data) {
+      return data.json;
+    }
+    return data;
+  }
+  extractErrorCode(payload) {
+    if (payload && typeof payload === "object") {
+      const errorShape = this.unwrapTrpcError(payload);
+      if (errorShape?.data?.code) {
+        return errorShape.data.code;
+      }
+    }
+    return "request_failed";
+  }
+  extractErrorMessage(payload, status) {
+    if (payload && typeof payload === "object") {
+      const errorShape = this.unwrapTrpcError(payload);
+      if (errorShape?.message) {
+        return errorShape.message;
+      }
+    }
+    return `Request failed with status ${status}`;
+  }
+  /**
+   * Unwrap a tRPC error envelope, handling the superjson `{ json: ... }` wrapper
+   * that the data-bridge applies via its transformer configuration.
+   */
+  unwrapTrpcError(payload) {
+    const envelope = payload.error;
+    if (!envelope || typeof envelope !== "object") {
+      return void 0;
+    }
+    if ("json" in envelope) {
+      const inner = envelope.json;
+      if (inner && typeof inner === "object") {
+        return inner;
+      }
+    }
+    return envelope;
+  }
+};
+var DEFAULT_AGENT_REFRESH_WINDOW_MS = 60 * 1e3;
+var agentConnectionStatusSchema = import_zod3.z.enum([
+  "disconnected",
+  "pending",
+  "connected",
+  "rejected",
+  "expired",
+  "failed"
+]);
+var storedAgentSessionSchema = import_zod3.z.object({
+  accessToken: import_zod3.z.string(),
+  refreshToken: import_zod3.z.string(),
+  tokenType: agentTokenResponseSchema.shape.tokenType,
+  ownerUserId: import_zod3.z.string(),
+  agentGrantId: import_zod3.z.string(),
+  scope: import_zod3.z.array(agentScopeSchema).min(1),
+  accessTokenExpiresAt: import_zod3.z.string().datetime(),
+  createdAt: import_zod3.z.string().datetime(),
+  lastRefreshedAt: import_zod3.z.string().datetime()
+});
+var agentSessionViewSchema = import_zod3.z.object({
+  connected: import_zod3.z.boolean(),
+  status: agentConnectionStatusSchema,
+  ownerUserId: import_zod3.z.string().optional(),
+  agentGrantId: import_zod3.z.string().optional(),
+  scope: import_zod3.z.array(agentScopeSchema).optional(),
+  accessTokenExpiresAt: import_zod3.z.string().datetime().optional(),
+  lastRefreshedAt: import_zod3.z.string().datetime().optional()
+});
+function createStoredAgentSession(tokenResponse, now = /* @__PURE__ */ new Date()) {
+  const createdAt = now.toISOString();
+  return {
+    accessToken: tokenResponse.accessToken,
+    refreshToken: tokenResponse.refreshToken,
+    tokenType: tokenResponse.tokenType,
+    ownerUserId: tokenResponse.ownerUserId,
+    agentGrantId: tokenResponse.agentGrantId,
+    scope: tokenResponse.scope,
+    accessTokenExpiresAt: new Date(now.getTime() + tokenResponse.expiresInSeconds * 1e3).toISOString(),
+    createdAt,
+    lastRefreshedAt: createdAt
+  };
+}
+function sanitizeAgentSession(session, status = session ? "connected" : "disconnected") {
+  if (!session) {
+    return {
+      connected: false,
+      status: status === "connected" ? "disconnected" : status
+    };
+  }
+  return {
+    connected: true,
+    status,
+    ownerUserId: session.ownerUserId,
+    agentGrantId: session.agentGrantId,
+    scope: session.scope,
+    accessTokenExpiresAt: session.accessTokenExpiresAt,
+    lastRefreshedAt: session.lastRefreshedAt
+  };
+}
+function shouldRefreshAgentSession(session, now = /* @__PURE__ */ new Date(), refreshWindowMs = DEFAULT_AGENT_REFRESH_WINDOW_MS) {
+  return new Date(session.accessTokenExpiresAt).getTime() - now.getTime() <= refreshWindowMs;
+}
+
+// src/auth-service.ts
+var HOSTED_RECONNECT_MESSAGE = "Helios no longer accepts this connection (it expired or was revoked). Reconnect Helios in your AI app to continue.";
+var HeliosAgentMcpAuthService = class {
+  constructor(options) {
+    __publicField(this, "client");
+    __publicField(this, "sessionStore");
+    __publicField(this, "refreshWindowMs");
+    __publicField(this, "now");
+    __publicField(this, "deviceLogin");
+    this.client = options.client;
+    this.sessionStore = options.sessionStore;
+    this.refreshWindowMs = options.refreshWindowMs ?? 60 * 1e3;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.deviceLogin = options.deviceLogin ?? true;
+  }
+  async startLogin(input) {
+    const response = await this.startDeviceLogin(input);
+    const result = this.buildStartLoginResult(response, input.scope);
+    await this.sessionStore.setPendingLogin(result);
+    return result;
+  }
+  async resetSessionAndStartLogin(input) {
+    await this.sessionStore.clearSession();
+    await this.sessionStore.clearPendingLogin();
+    const response = await this.startDeviceLogin(input);
+    const result = this.buildStartLoginResult(response, input.scope);
+    await this.sessionStore.setPendingLogin(result);
+    return result;
+  }
+  async startDeviceLogin(input) {
+    if (!this.deviceLogin) {
+      throw new Error(HOSTED_RECONNECT_MESSAGE);
+    }
+    return this.client.startLogin(input);
+  }
+  buildStartLoginResult(response, requestedScope) {
+    return {
+      status: "pending",
+      ...response,
+      requestedScope,
+      startedAt: this.now().toISOString()
+    };
+  }
+  async startRelogin(options = {}) {
+    const requestedScope = options.scope ?? [AGENT_SCOPES.ACCOUNT_READ, AGENT_SCOPES.MARKET_READ];
+    const started = await this.resetSessionAndStartLogin({
+      clientName: options.clientName ?? "Helios MCP",
+      scope: requestedScope,
+      constraints: options.constraints
+    });
+    return {
+      ...started,
+      connected: false,
+      message: formatHeliosLoginPrompt(started)
+    };
+  }
+  async clearSessionState() {
+    await this.sessionStore.clearSession();
+    await this.sessionStore.clearPendingLogin();
+  }
+  async invalidateIfUnauthorized(error, options = {}) {
+    if (!isHeliosAgentApiError(error) || error.status !== 401) {
+      return null;
+    }
+    return this.startRelogin(options);
+  }
+  async refreshSessionAfterUnauthorized(error) {
+    if (!isHeliosAgentApiError(error) || error.status !== 401) {
+      return null;
+    }
+    const session = await this.sessionStore.getSession();
+    if (!session) {
+      return null;
+    }
+    return this.refreshStoredSession(session);
+  }
+  async ensureLogin(options = {}) {
+    const requestedScope = options.scope ?? [AGENT_SCOPES.ACCOUNT_READ, AGENT_SCOPES.MARKET_READ];
+    const requestedConstraints = options.constraints ?? {};
+    const session = await this.getValidSession();
+    if (session) {
+      return {
+        ...sanitizeAgentSession(session),
+        connected: true,
+        status: "connected"
+      };
+    }
+    const pendingLogin = await this.getPendingLogin({
+      requestedScope,
+      requestedConstraints
+    });
+    if (pendingLogin) {
+      const polled = await this.pollLogin(pendingLogin.deviceCode).catch(() => null);
+      if (polled?.status === "connected") return polled;
+      if (polled?.status !== "rejected" && polled?.status !== "expired") {
+        return {
+          ...pendingLogin,
+          connected: false,
+          message: formatHeliosLoginPrompt(pendingLogin)
+        };
+      }
+    }
+    const started = await this.startLogin({
+      clientName: options.clientName ?? "Helios MCP",
+      scope: requestedScope,
+      constraints: options.constraints
+    });
+    return {
+      ...started,
+      connected: false,
+      message: formatHeliosLoginPrompt(started)
+    };
+  }
+  /** Polls the given login, or the stored pending one when no device code is given. */
+  async pollLogin(deviceCode) {
+    if (!deviceCode) {
+      const pending = await this.sessionStore.getPendingLogin();
+      if (!pending) {
+        const session = await this.getValidSession();
+        if (session) return { ...sanitizeAgentSession(session), connected: true, status: "connected" };
+        return {
+          status: "failed",
+          connected: false,
+          message: "No Helios login is in progress. Call helios_auth_ensure_login to start one."
+        };
+      }
+      deviceCode = pending.deviceCode;
+    } else {
+      const pending = await this.sessionStore.getPendingLogin();
+      if (pending && pending.userCode.toUpperCase() === deviceCode.trim().toUpperCase()) deviceCode = pending.deviceCode;
+    }
+    try {
+      const response = await this.client.exchangeDeviceCode(deviceCode);
+      const session = createStoredAgentSession(response, this.now());
+      await this.sessionStore.setSession(session);
+      await this.sessionStore.clearPendingLogin();
+      return {
+        ...sanitizeAgentSession(session),
+        connected: true,
+        status: "connected"
+      };
+    } catch (error) {
+      if (isHeliosAgentApiError(error)) {
+        if (error.code === "authorization_pending") {
+          return {
+            status: "pending",
+            connected: false,
+            message: error.message
+          };
+        }
+        if (error.code === "access_denied") {
+          await this.clearPendingLoginIfMatches(deviceCode);
+          return {
+            status: "rejected",
+            connected: false,
+            message: error.message
+          };
+        }
+        if (error.code === "expired_token") {
+          await this.clearPendingLoginIfMatches(deviceCode);
+          return {
+            status: "expired",
+            connected: false,
+            message: error.message
+          };
+        }
+        return {
+          status: "failed",
+          connected: false,
+          message: error.message
+        };
+      }
+      return {
+        status: "failed",
+        connected: false,
+        message: error instanceof Error ? error.message : "Unexpected Helios login error"
+      };
+    }
+  }
+  async whoami() {
+    const session = await this.getValidSession();
+    return sanitizeAgentSession(session);
+  }
+  async getAccessToken() {
+    const session = await this.getValidSession();
+    return session?.accessToken ?? null;
+  }
+  async requireSession() {
+    const session = await this.getValidSession();
+    if (!session) {
+      throw new Error("No Helios delegated agent session is connected");
+    }
+    return session;
+  }
+  async getValidSession() {
+    const session = await this.sessionStore.getSession();
+    if (!session) {
+      return null;
+    }
+    if (!shouldRefreshAgentSession(session, this.now(), this.refreshWindowMs)) {
+      return session;
+    }
+    return this.refreshStoredSession(session);
+  }
+  async refreshStoredSession(session) {
+    try {
+      const refreshed = await this.client.refreshSession(session.refreshToken);
+      const nextSession = createStoredAgentSession(refreshed, this.now());
+      await this.sessionStore.setSession(nextSession);
+      return nextSession;
+    } catch (error) {
+      if (isHeliosAgentApiError(error) && error.code === "invalid_grant") {
+        await this.sessionStore.clearSession();
+        await this.sessionStore.clearPendingLogin();
+        return null;
+      }
+      throw error;
+    }
+  }
+  async getPendingLogin(options) {
+    const pendingLogin = await this.sessionStore.getPendingLogin();
+    if (!pendingLogin) {
+      return null;
+    }
+    const expiresAt = new Date(pendingLogin.startedAt).getTime() + pendingLogin.expiresInSeconds * 1e3;
+    if (this.now().getTime() >= expiresAt) {
+      await this.sessionStore.clearPendingLogin();
+      return null;
+    }
+    if (!isPendingLoginCompatible(pendingLogin, options.requestedScope, options.requestedConstraints)) {
+      return null;
+    }
+    return pendingLogin;
+  }
+  async clearPendingLoginIfMatches(deviceCode) {
+    const pendingLogin = await this.sessionStore.getPendingLogin();
+    if (pendingLogin?.deviceCode === deviceCode) {
+      await this.sessionStore.clearPendingLogin();
+    }
+  }
+};
+async function retryAfterUnauthorizedRefresh(options) {
+  const refreshedSession = await options.authService.refreshSessionAfterUnauthorized(options.error);
+  if (!refreshedSession) {
+    return options.authService.invalidateIfUnauthorized(options.error, options.loginOptions);
+  }
+  try {
+    return await options.retry(refreshedSession.accessToken);
+  } catch (retryError) {
+    const relogin = await options.authService.invalidateIfUnauthorized(retryError, options.loginOptions);
+    if (relogin) {
+      return relogin;
+    }
+    throw retryError;
+  }
+}
+function formatHeliosLoginPrompt(result) {
+  return `Log in to Helios by opening this URL in your browser:
+
+${result.verificationUriComplete}
+
+User code: ${result.userCode}
+
+Requested scopes: ${result.requestedScope.join(", ")}
+
+After approving access, call helios_auth_ensure_login (or helios_auth_poll_login) again to finish connecting.`;
+}
+function isPendingLoginCompatible(pendingLogin, requestedScope, requestedConstraints) {
+  const pendingScope = new Set(pendingLogin.requestedScope);
+  const scopeCompatible = requestedScope.every((scope) => pendingScope.has(scope));
+  if (!scopeCompatible) {
+    return false;
+  }
+  return Object.keys(requestedConstraints ?? {}).length === 0;
+}
+
+// src/account-service.ts
+var HeliosAgentMcpAccountService = class {
+  constructor(options) {
+    __publicField(this, "authService");
+    __publicField(this, "dataBridgeClient");
+    __publicField(this, "providerService");
+    this.authService = options.authService;
+    this.dataBridgeClient = options.dataBridgeClient;
+    this.providerService = options.providerService;
+  }
+  async getWalletState() {
+    const loginOptions = this.accountReadOptions();
+    const login = await this.authService.ensureLogin(loginOptions);
+    if (login.status !== "connected") {
+      return {
+        ...login,
+        status: "pending",
+        connected: false
+      };
+    }
+    const session = await this.authService.requireSession();
+    try {
+      const walletState = await this.dataBridgeClient.getWalletState(session.accessToken);
+      return {
+        status: "connected",
+        connected: true,
+        walletState
+      };
+    } catch (error) {
+      const recovery = await retryAfterUnauthorizedRefresh({
+        authService: this.authService,
+        error,
+        loginOptions,
+        retry: async (accessToken) => {
+          const walletState = await this.dataBridgeClient.getWalletState(accessToken);
+          return {
+            status: "connected",
+            connected: true,
+            walletState
+          };
+        }
+      });
+      if (recovery) {
+        return recovery;
+      }
+      throw error;
+    }
+  }
+  async getPortfolio(input = {}) {
+    const loginOptions = this.accountReadOptions();
+    const login = await this.authService.ensureLogin(loginOptions);
+    if (login.status !== "connected") {
+      return {
+        ...login,
+        status: "pending",
+        connected: false
+      };
+    }
+    const session = await this.authService.requireSession();
+    try {
+      const provider = await this.providerService.resolveProvider(input.provider);
+      const portfolio = await this.dataBridgeClient.getPortfolio(session.accessToken, { provider });
+      return {
+        status: "connected",
+        connected: true,
+        portfolio
+      };
+    } catch (error) {
+      const recovery = await retryAfterUnauthorizedRefresh({
+        authService: this.authService,
+        error,
+        loginOptions,
+        retry: async (accessToken) => {
+          const provider = await this.providerService.resolveProvider(input.provider);
+          const portfolio = await this.dataBridgeClient.getPortfolio(accessToken, { provider });
+          return {
+            status: "connected",
+            connected: true,
+            portfolio
+          };
+        }
+      });
+      if (recovery) {
+        return recovery;
+      }
+      throw error;
+    }
+  }
+  accountReadOptions() {
+    return {
+      clientName: "Helios MCP",
+      scope: [AGENT_SCOPES.ACCOUNT_READ]
+    };
+  }
+};
+
+// src/docs-service.ts
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"));
+var HeliosAgentMcpDocsService = class {
+  constructor(options) {
+    __publicField(this, "docsRoot");
+    this.docsRoot = options.docsRoot;
+  }
+  async getIndex() {
+    const documents = listDocumentPaths(this.docsRoot).map((documentPath) => this.readDocumentMetadata(documentPath));
+    return {
+      root: "docs",
+      documents
+    };
+  }
+  async getDocument(input) {
+    const documentPath = resolveDocumentPath(this.docsRoot, input.path);
+    const body = (0, import_node_fs.readFileSync)(documentPath, "utf8");
+    const stats = (0, import_node_fs.statSync)(documentPath);
+    const relativePath = toPosixPath(import_node_path.default.relative(this.docsRoot, documentPath));
+    return {
+      path: relativePath,
+      section: getDocumentSection(relativePath),
+      title: extractDocumentTitle(body, relativePath),
+      body,
+      bytes: stats.size
+    };
+  }
+  readDocumentMetadata(documentPath) {
+    const body = (0, import_node_fs.readFileSync)(documentPath, "utf8");
+    const stats = (0, import_node_fs.statSync)(documentPath);
+    const relativePath = toPosixPath(import_node_path.default.relative(this.docsRoot, documentPath));
+    return {
+      path: relativePath,
+      section: getDocumentSection(relativePath),
+      title: extractDocumentTitle(body, relativePath),
+      bytes: stats.size
+    };
+  }
+};
+function getDefaultHeliosAgentMcpDocsRoot() {
+  return import_node_path.default.resolve(__dirname, "..", "docs");
+}
+function listDocumentPaths(root) {
+  return walk(root).filter((filePath) => filePath.endsWith(".txt")).sort((left, right) => left.localeCompare(right));
+}
+function walk(currentPath) {
+  const entries = (0, import_node_fs.readdirSync)(currentPath, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const nextPath = import_node_path.default.join(currentPath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walk(nextPath));
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(nextPath);
+    }
+  }
+  return files;
+}
+function resolveDocumentPath(root, relativeDocumentPath) {
+  const normalizedPath = relativeDocumentPath.replace(/\\/g, "/").replace(/^\/+/, "");
+  const resolvedPath = import_node_path.default.resolve(root, normalizedPath);
+  const relativePath = import_node_path.default.relative(root, resolvedPath);
+  if (!normalizedPath) {
+    throw new Error("Document path is required.");
+  }
+  if (import_node_path.default.isAbsolute(normalizedPath) || relativePath.startsWith("..") || import_node_path.default.isAbsolute(relativePath)) {
+    throw new Error(`Document path "${relativeDocumentPath}" is outside the docs root.`);
+  }
+  if (!resolvedPath.endsWith(".txt")) {
+    throw new Error(`Document path "${relativeDocumentPath}" must point to a .txt file.`);
+  }
+  return resolvedPath;
+}
+function extractDocumentTitle(body, relativePath) {
+  const lines = body.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || /^=+$/.test(trimmed)) {
+      continue;
+    }
+    if (trimmed.startsWith("TITLE:")) {
+      return trimmed.slice("TITLE:".length).trim();
+    }
+    return trimmed;
+  }
+  return import_node_path.default.basename(relativePath, ".txt");
+}
+function getDocumentSection(relativePath) {
+  return relativePath.split("/")[0] ?? "docs";
+}
+function toPosixPath(value) {
+  return value.split(import_node_path.default.sep).join("/");
+}
+
+// src/ledger-service.ts
+var HeliosAgentMcpLedgerService = class {
+  constructor(options) {
+    __publicField(this, "authService");
+    __publicField(this, "dataBridgeClient");
+    this.authService = options.authService;
+    this.dataBridgeClient = options.dataBridgeClient;
+  }
+  async getOpenPositions() {
+    const loginOptions = this.accountReadOptions();
+    const login = await this.authService.ensureLogin(loginOptions);
+    if (login.status !== "connected") {
+      return asPending(login);
+    }
+    const session = await this.authService.requireSession();
+    try {
+      const openPositions = await this.dataBridgeClient.getOpenPositions(session.accessToken);
+      return {
+        status: "connected",
+        connected: true,
+        openPositions
+      };
+    } catch (error) {
+      const recovery = await retryAfterUnauthorizedRefresh({
+        authService: this.authService,
+        error,
+        loginOptions,
+        retry: async (accessToken) => {
+          const openPositions = await this.dataBridgeClient.getOpenPositions(accessToken);
+          return {
+            status: "connected",
+            connected: true,
+            openPositions
+          };
+        }
+      });
+      if (recovery) {
+        return recovery;
+      }
+      throw error;
+    }
+  }
+  async getFills(input = {}) {
+    const loginOptions = this.accountReadOptions();
+    const login = await this.authService.ensureLogin(loginOptions);
+    if (login.status !== "connected") {
+      return asPending(login);
+    }
+    const session = await this.authService.requireSession();
+    try {
+      const fills = await this.dataBridgeClient.getLedgerFills(session.accessToken, input);
+      return {
+        status: "connected",
+        connected: true,
+        fills
+      };
+    } catch (error) {
+      const recovery = await retryAfterUnauthorizedRefresh({
+        authService: this.authService,
+        error,
+        loginOptions,
+        retry: async (accessToken) => {
+          const fills = await this.dataBridgeClient.getLedgerFills(accessToken, input);
+          return {
+            status: "connected",
+            connected: true,
+            fills
+          };
+        }
+      });
+      if (recovery) {
+        return recovery;
+      }
+      throw error;
+    }
+  }
+  async getSummary(input = {}) {
+    const loginOptions = this.accountReadOptions();
+    const login = await this.authService.ensureLogin(loginOptions);
+    if (login.status !== "connected") {
+      return asPending(login);
+    }
+    const session = await this.authService.requireSession();
+    try {
+      const summary = await this.dataBridgeClient.getLedgerSummary(session.accessToken, input);
+      return {
+        status: "connected",
+        connected: true,
+        summary
+      };
+    } catch (error) {
+      const recovery = await retryAfterUnauthorizedRefresh({
+        authService: this.authService,
+        error,
+        loginOptions,
+        retry: async (accessToken) => {
+          const summary = await this.dataBridgeClient.getLedgerSummary(accessToken, input);
+          return {
+            status: "connected",
+            connected: true,
+            summary
+          };
+        }
+      });
+      if (recovery) {
+        return recovery;
+      }
+      throw error;
+    }
+  }
+  accountReadOptions() {
+    return {
+      clientName: "Helios MCP",
+      scope: [AGENT_SCOPES.ACCOUNT_READ]
+    };
+  }
+};
+function asPending(login) {
+  return {
+    ...login,
+    status: "pending",
+    connected: false
+  };
+}
+
+// src/market-service.ts
+var HeliosAgentMcpMarketService = class {
+  constructor(options) {
+    __publicField(this, "authService");
+    __publicField(this, "dataBridgeClient");
+    this.authService = options.authService;
+    this.dataBridgeClient = options.dataBridgeClient;
+  }
+  async getSnapshot(input = {}) {
+    const loginOptions = {
+      clientName: "Helios MCP",
+      scope: [AGENT_SCOPES.MARKET_READ]
+    };
+    const login = await this.authService.ensureLogin(loginOptions);
+    if (login.status !== "connected") {
+      return {
+        ...login,
+        status: "pending",
+        connected: false
+      };
+    }
+    const session = await this.authService.requireSession();
+    try {
+      const snapshot = await this.dataBridgeClient.getMarketSnapshot(session.accessToken, input);
+      return {
+        status: "connected",
+        connected: true,
+        snapshot
+      };
+    } catch (error) {
+      const recovery = await retryAfterUnauthorizedRefresh({
+        authService: this.authService,
+        error,
+        loginOptions,
+        retry: async (accessToken) => {
+          const snapshot = await this.dataBridgeClient.getMarketSnapshot(accessToken, input);
+          return {
+            status: "connected",
+            connected: true,
+            snapshot
+          };
+        }
+      });
+      if (recovery) {
+        return recovery;
+      }
+      throw error;
+    }
+  }
+  async getSnapshotChunk(input = {}) {
+    const loginOptions = {
+      clientName: "Helios MCP",
+      scope: [AGENT_SCOPES.MARKET_READ]
+    };
+    const login = await this.authService.ensureLogin(loginOptions);
+    if (login.status !== "connected") {
+      return {
+        ...login,
+        status: "pending",
+        connected: false
+      };
+    }
+    const session = await this.authService.requireSession();
+    try {
+      const snapshotChunk = await this.dataBridgeClient.getMarketSnapshotChunk(session.accessToken, input);
+      return {
+        status: "connected",
+        connected: true,
+        snapshotChunk
+      };
+    } catch (error) {
+      const recovery = await retryAfterUnauthorizedRefresh({
+        authService: this.authService,
+        error,
+        loginOptions,
+        retry: async (accessToken) => {
+          const snapshotChunk = await this.dataBridgeClient.getMarketSnapshotChunk(accessToken, input);
+          return {
+            status: "connected",
+            connected: true,
+            snapshotChunk
+          };
+        }
+      });
+      if (recovery) {
+        return recovery;
+      }
+      throw error;
+    }
+  }
+  async getSymbolDetail(input) {
+    const loginOptions = {
+      clientName: "Helios MCP",
+      scope: [AGENT_SCOPES.MARKET_READ]
+    };
+    const login = await this.authService.ensureLogin(loginOptions);
+    if (login.status !== "connected") {
+      return {
+        ...login,
+        status: "pending",
+        connected: false
+      };
+    }
+    const session = await this.authService.requireSession();
+    try {
+      const detail = await this.dataBridgeClient.getMarketSymbolDetail(session.accessToken, input);
+      return {
+        status: "connected",
+        connected: true,
+        detail
+      };
+    } catch (error) {
+      const recovery = await retryAfterUnauthorizedRefresh({
+        authService: this.authService,
+        error,
+        loginOptions,
+        retry: async (accessToken) => {
+          const detail = await this.dataBridgeClient.getMarketSymbolDetail(accessToken, input);
+          return {
+            status: "connected",
+            connected: true,
+            detail
+          };
+        }
+      });
+      if (recovery) {
+        return recovery;
+      }
+      throw error;
+    }
+  }
+};
+
+// src/provider-service.ts
+var HeliosAgentMcpProviderService = class {
+  constructor(options) {
+    __publicField(this, "sessionStore");
+    this.sessionStore = options.sessionStore;
+  }
+  async getActiveProvider() {
+    const provider = await this.sessionStore.getActiveProvider();
+    if (!provider) {
+      return {
+        configured: false,
+        provider: null
+      };
+    }
+    return {
+      configured: true,
+      provider
+    };
+  }
+  async setActiveProvider(provider) {
+    await this.sessionStore.setActiveProvider(provider);
+    return {
+      configured: true,
+      provider
+    };
+  }
+  async resolveProvider(explicitProvider) {
+    if (explicitProvider) {
+      return explicitProvider;
+    }
+    const activeProvider = await this.sessionStore.getActiveProvider();
+    if (activeProvider) {
+      return activeProvider;
+    }
+    throw new Error("No active provider configured. Call helios_provider_set_active or pass provider explicitly.");
+  }
+};
+
+// src/session-store.ts
+var import_promises = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path2 = __toESM(require("path"));
+var import_zod4 = require("zod");
+function getDefaultHeliosAgentMcpSessionPath() {
+  return import_node_path2.default.join((0, import_node_os.homedir)(), ".helios-agent-mcp", "session.json");
+}
+var pendingAgentLoginSchema = import_zod4.z.object({
+  status: import_zod4.z.literal("pending"),
+  deviceCode: import_zod4.z.string(),
+  userCode: import_zod4.z.string(),
+  verificationUri: import_zod4.z.string().url(),
+  verificationUriComplete: import_zod4.z.string().url(),
+  expiresInSeconds: import_zod4.z.number().int().positive(),
+  pollIntervalSeconds: import_zod4.z.number().int().positive(),
+  requestedScope: import_zod4.z.array(agentScopeSchema).min(1),
+  startedAt: import_zod4.z.string().datetime()
+});
+var mcpSessionStateSchema = import_zod4.z.object({
+  session: storedAgentSessionSchema.nullish(),
+  pendingLogin: pendingAgentLoginSchema.nullish(),
+  // A provider pinned before Binance was retired ('binance') reads as unpinned, so the agent must pick again, rather than
+  // failing the whole file (which would drop the session) or silently switching it to Hyperliquid.
+  activeProvider: providerSchema.nullish().catch(null)
+});
+var FileAgentSessionStore = class {
+  constructor(filePath = getDefaultHeliosAgentMcpSessionPath()) {
+    this.filePath = filePath;
+  }
+  async getSession() {
+    return (await this.readState()).session;
+  }
+  async getPendingLogin() {
+    return (await this.readState()).pendingLogin;
+  }
+  async getActiveProvider() {
+    return (await this.readState()).activeProvider;
+  }
+  async setSession(session) {
+    const state = await this.readState();
+    await this.writeState({
+      ...state,
+      session
+    });
+  }
+  async setPendingLogin(pendingLogin) {
+    const state = await this.readState();
+    await this.writeState({
+      ...state,
+      pendingLogin
+    });
+  }
+  async setActiveProvider(activeProvider) {
+    const state = await this.readState();
+    await this.writeState({
+      ...state,
+      activeProvider
+    });
+  }
+  async clearSession() {
+    const state = await this.readState();
+    await this.writeStateOrDelete({
+      ...state,
+      session: null
+    });
+  }
+  async clearPendingLogin() {
+    const state = await this.readState();
+    await this.writeStateOrDelete({
+      ...state,
+      pendingLogin: null
+    });
+  }
+  async clearActiveProvider() {
+    const state = await this.readState();
+    await this.writeStateOrDelete({
+      ...state,
+      activeProvider: null
+    });
+  }
+  async readState() {
+    try {
+      const raw = await (0, import_promises.readFile)(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && ("session" in parsed || "pendingLogin" in parsed || "activeProvider" in parsed)) {
+        const envelope = mcpSessionStateSchema.safeParse(parsed);
+        if (envelope.success) {
+          return {
+            session: envelope.data.session ?? null,
+            pendingLogin: envelope.data.pendingLogin ?? null,
+            activeProvider: envelope.data.activeProvider ?? null
+          };
+        }
+      }
+      const legacySession = storedAgentSessionSchema.safeParse(parsed);
+      if (legacySession.success) {
+        return {
+          session: legacySession.data,
+          pendingLogin: null,
+          activeProvider: null
+        };
+      }
+      return {
+        session: null,
+        pendingLogin: null,
+        activeProvider: null
+      };
+    } catch (error) {
+      if (isMissingFileError(error)) {
+        return {
+          session: null,
+          pendingLogin: null,
+          activeProvider: null
+        };
+      }
+      if (error instanceof Error && error.name === "ZodError") {
+        return {
+          session: null,
+          pendingLogin: null,
+          activeProvider: null
+        };
+      }
+      throw error;
+    }
+  }
+  async writeState(state) {
+    await (0, import_promises.mkdir)(import_node_path2.default.dirname(this.filePath), { recursive: true });
+    await (0, import_promises.writeFile)(this.filePath, `${JSON.stringify(state, null, 2)}
+`, { encoding: "utf8", mode: 384 });
+    await (0, import_promises.chmod)(this.filePath, 384).catch(() => void 0);
+  }
+  async writeStateOrDelete(state) {
+    if (!state.session && !state.pendingLogin && !state.activeProvider) {
+      await this.deleteFile();
+      return;
+    }
+    await this.writeState(state);
+  }
+  async deleteFile() {
+    try {
+      await (0, import_promises.rm)(this.filePath, { force: true });
+    } catch (error) {
+      if (!isMissingFileError(error)) {
+        throw error;
+      }
+    }
+  }
+};
+var MemoryAgentMcpSessionStore = class {
+  constructor(session = null, activeProvider = "hyperliquid") {
+    this.session = session;
+    this.activeProvider = activeProvider;
+    __publicField(this, "pendingLogin", null);
+  }
+  async getSession() {
+    return this.session;
+  }
+  async setSession(session) {
+    this.session = session;
+  }
+  async clearSession() {
+    this.session = null;
+  }
+  async getActiveProvider() {
+    return this.activeProvider;
+  }
+  async setActiveProvider(provider) {
+    this.activeProvider = provider;
+  }
+  async clearActiveProvider() {
+    this.activeProvider = null;
+  }
+  async getPendingLogin() {
+    return this.pendingLogin;
+  }
+  async setPendingLogin(pendingLogin) {
+    this.pendingLogin = pendingLogin;
+  }
+  async clearPendingLogin() {
+    this.pendingLogin = null;
+  }
+};
+function isMissingFileError(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
+// src/trading-service.ts
+var import_node_crypto = require("crypto");
+var HeliosAgentMcpTradingService = class {
+  constructor(options) {
+    __publicField(this, "authService");
+    __publicField(this, "dataBridgeClient");
+    __publicField(this, "providerService");
+    this.authService = options.authService;
+    this.dataBridgeClient = options.dataBridgeClient;
+    this.providerService = options.providerService;
+  }
+  async open(input) {
+    return this.submitIntent("OPEN", input);
+  }
+  async dca(input) {
+    return this.submitIntent("DCA", input);
+  }
+  async reverse(input) {
+    return this.submitIntent("REVERSE", input);
+  }
+  async close(input) {
+    const loginOptions = {
+      clientName: "Helios MCP",
+      scope: [AGENT_SCOPES.ORDERS_WRITE]
+    };
+    const login = await this.authService.ensureLogin(loginOptions);
+    if (login.status !== "connected") {
+      return asPending2(login);
+    }
+    const session = await this.authService.requireSession();
+    try {
+      const provider = await this.providerService.resolveProvider(input.provider);
+      const closure = await this.dataBridgeClient.closePosition(session.accessToken, {
+        ...input,
+        provider
+      });
+      return {
+        status: "connected",
+        connected: true,
+        closure
+      };
+    } catch (error) {
+      const recovery = await retryAfterUnauthorizedRefresh({
+        authService: this.authService,
+        error,
+        loginOptions,
+        retry: async (accessToken) => {
+          const provider = await this.providerService.resolveProvider(input.provider);
+          const closure = await this.dataBridgeClient.closePosition(accessToken, {
+            ...input,
+            provider
+          });
+          return {
+            status: "connected",
+            connected: true,
+            closure
+          };
+        }
+      });
+      if (recovery) {
+        return recovery;
+      }
+      throw error;
+    }
+  }
+  async setTpSl(input) {
+    const loginOptions = {
+      clientName: "Helios MCP",
+      scope: [AGENT_SCOPES.ORDERS_WRITE]
+    };
+    const login = await this.authService.ensureLogin(loginOptions);
+    if (login.status !== "connected") {
+      return asPending2(login);
+    }
+    const session = await this.authService.requireSession();
+    try {
+      const provider = await this.providerService.resolveProvider(input.provider);
+      const protection = await this.dataBridgeClient.setTpSl(session.accessToken, {
+        ...input,
+        provider
+      });
+      return {
+        status: "connected",
+        connected: true,
+        protection
+      };
+    } catch (error) {
+      const recovery = await retryAfterUnauthorizedRefresh({
+        authService: this.authService,
+        error,
+        loginOptions,
+        retry: async (accessToken) => {
+          const provider = await this.providerService.resolveProvider(input.provider);
+          const protection = await this.dataBridgeClient.setTpSl(accessToken, {
+            ...input,
+            provider
+          });
+          return {
+            status: "connected",
+            connected: true,
+            protection
+          };
+        }
+      });
+      if (recovery) {
+        return recovery;
+      }
+      throw error;
+    }
+  }
+  async deleteTpSl(input) {
+    const loginOptions = {
+      clientName: "Helios MCP",
+      scope: [AGENT_SCOPES.ORDERS_CANCEL]
+    };
+    const login = await this.authService.ensureLogin(loginOptions);
+    if (login.status !== "connected") {
+      return asPending2(login);
+    }
+    const session = await this.authService.requireSession();
+    try {
+      const provider = await this.providerService.resolveProvider(input.provider);
+      const deletion = await this.dataBridgeClient.deleteTpSl(session.accessToken, {
+        ...input,
+        provider
+      });
+      return {
+        status: "connected",
+        connected: true,
+        deletion
+      };
+    } catch (error) {
+      const recovery = await retryAfterUnauthorizedRefresh({
+        authService: this.authService,
+        error,
+        loginOptions,
+        retry: async (accessToken) => {
+          const provider = await this.providerService.resolveProvider(input.provider);
+          const deletion = await this.dataBridgeClient.deleteTpSl(accessToken, {
+            ...input,
+            provider
+          });
+          return {
+            status: "connected",
+            connected: true,
+            deletion
+          };
+        }
+      });
+      if (recovery) {
+        return recovery;
+      }
+      throw error;
+    }
+  }
+  async getOpenOrders() {
+    const loginOptions = {
+      clientName: "Helios MCP",
+      scope: [AGENT_SCOPES.ACCOUNT_READ]
+    };
+    const login = await this.authService.ensureLogin(loginOptions);
+    if (login.status !== "connected") {
+      return asPending2(login);
+    }
+    const session = await this.authService.requireSession();
+    try {
+      const orders = await this.dataBridgeClient.getOpenOrders(session.accessToken);
+      return {
+        status: "connected",
+        connected: true,
+        orders
+      };
+    } catch (error) {
+      const recovery = await retryAfterUnauthorizedRefresh({
+        authService: this.authService,
+        error,
+        loginOptions,
+        retry: async (accessToken) => {
+          const orders = await this.dataBridgeClient.getOpenOrders(accessToken);
+          return {
+            status: "connected",
+            connected: true,
+            orders
+          };
+        }
+      });
+      if (recovery) {
+        return recovery;
+      }
+      throw error;
+    }
+  }
+  async cancelOrder(input) {
+    const loginOptions = {
+      clientName: "Helios MCP",
+      scope: [AGENT_SCOPES.ORDERS_CANCEL]
+    };
+    const login = await this.authService.ensureLogin(loginOptions);
+    if (login.status !== "connected") {
+      return asPending2(login);
+    }
+    const session = await this.authService.requireSession();
+    try {
+      const cancellation = await this.dataBridgeClient.cancelOrder(session.accessToken, input);
+      return {
+        status: "connected",
+        connected: true,
+        cancellation
+      };
+    } catch (error) {
+      const recovery = await retryAfterUnauthorizedRefresh({
+        authService: this.authService,
+        error,
+        loginOptions,
+        retry: async (accessToken) => {
+          const cancellation = await this.dataBridgeClient.cancelOrder(accessToken, input);
+          return {
+            status: "connected",
+            connected: true,
+            cancellation
+          };
+        }
+      });
+      if (recovery) {
+        return recovery;
+      }
+      throw error;
+    }
+  }
+  async submitIntent(intentType, input) {
+    const loginOptions = {
+      clientName: "Helios MCP",
+      scope: [AGENT_SCOPES.ORDERS_WRITE]
+    };
+    const login = await this.authService.ensureLogin(loginOptions);
+    if (login.status !== "connected") {
+      return asPending2(login);
+    }
+    const session = await this.authService.requireSession();
+    const idempotencyKey = input.idempotencyKey ?? (0, import_node_crypto.randomUUID)().replace(/-/g, "");
+    try {
+      const provider = await this.providerService.resolveProvider(input.provider);
+      const submission = await this.dataBridgeClient.submitTradeIntent(session.accessToken, {
+        ...input,
+        provider,
+        intentType,
+        idempotencyKey
+      });
+      return {
+        status: "connected",
+        connected: true,
+        submission
+      };
+    } catch (error) {
+      const recovery = await retryAfterUnauthorizedRefresh({
+        authService: this.authService,
+        error,
+        loginOptions,
+        retry: async (accessToken) => {
+          const provider = await this.providerService.resolveProvider(input.provider);
+          const submission = await this.dataBridgeClient.submitTradeIntent(accessToken, {
+            ...input,
+            provider,
+            intentType,
+            idempotencyKey
+          });
+          return {
+            status: "connected",
+            connected: true,
+            submission
+          };
+        }
+      });
+      if (recovery) {
+        return recovery;
+      }
+      throw error;
+    }
+  }
+};
+function asPending2(login) {
+  return {
+    ...login,
+    status: "pending",
+    connected: false
+  };
+}
+
+// src/tools.ts
+var import_zod5 = require("zod");
+var pollLoginInputSchema = import_zod5.z.object({
+  /** Optional: defaults to the login started by helios_auth_ensure_login / helios_auth_start_login. */
+  deviceCode: import_zod5.z.string().min(1).optional()
+});
+var startLoginOutputSchema = import_zod5.z.object({
+  status: import_zod5.z.literal("pending"),
+  deviceCode: import_zod5.z.string(),
+  userCode: import_zod5.z.string(),
+  verificationUri: import_zod5.z.string().url(),
+  verificationUriComplete: import_zod5.z.string().url(),
+  expiresInSeconds: import_zod5.z.number().int().positive(),
+  pollIntervalSeconds: import_zod5.z.number().int().positive(),
+  requestedScope: import_zod5.z.array(agentScopeSchema).min(1),
+  startedAt: import_zod5.z.string().datetime()
+});
+var ensureLoginInputSchema = import_zod5.z.object({
+  clientName: import_zod5.z.string().min(1).max(64).optional(),
+  scope: import_zod5.z.array(agentScopeSchema).min(1).optional(),
+  constraints: agentConstraintsSchema.optional()
+});
+var providerSelectionInputSchema = import_zod5.z.object({
+  provider: providerSchema.optional()
+});
+var providerSetInputSchema = import_zod5.z.object({
+  provider: providerSchema
+});
+var activeProviderSchema = import_zod5.z.object({
+  configured: import_zod5.z.boolean(),
+  provider: providerSchema.nullable()
+});
+var ensureLoginOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  agentSessionViewSchema.extend({
+    status: import_zod5.z.literal("connected"),
+    connected: import_zod5.z.literal(true)
+  }),
+  startLoginOutputSchema.extend({
+    status: import_zod5.z.literal("pending"),
+    connected: import_zod5.z.literal(false),
+    message: import_zod5.z.string()
+  })
+]);
+var pollLoginOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  agentSessionViewSchema.extend({
+    status: import_zod5.z.literal("connected"),
+    connected: import_zod5.z.literal(true)
+  }),
+  import_zod5.z.object({
+    status: import_zod5.z.enum(["pending", "rejected", "expired", "failed"]),
+    connected: import_zod5.z.literal(false),
+    message: import_zod5.z.string()
+  })
+]);
+var walletStateToolOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  import_zod5.z.object({
+    status: import_zod5.z.literal("connected"),
+    connected: import_zod5.z.literal(true),
+    walletState: walletStateSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: import_zod5.z.literal("pending"),
+    connected: import_zod5.z.literal(false),
+    message: import_zod5.z.string()
+  })
+]);
+var portfolioToolOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  import_zod5.z.object({
+    status: import_zod5.z.literal("connected"),
+    connected: import_zod5.z.literal(true),
+    portfolio: portfolioSnapshotSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: import_zod5.z.literal("pending"),
+    connected: import_zod5.z.literal(false),
+    message: import_zod5.z.string()
+  })
+]);
+var openPositionsToolOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  import_zod5.z.object({
+    status: import_zod5.z.literal("connected"),
+    connected: import_zod5.z.literal(true),
+    openPositions: openPositionsSnapshotSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: import_zod5.z.literal("pending"),
+    connected: import_zod5.z.literal(false),
+    message: import_zod5.z.string()
+  })
+]);
+var ledgerFillsToolOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  import_zod5.z.object({
+    status: import_zod5.z.literal("connected"),
+    connected: import_zod5.z.literal(true),
+    fills: ledgerFillsPageSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: import_zod5.z.literal("pending"),
+    connected: import_zod5.z.literal(false),
+    message: import_zod5.z.string()
+  })
+]);
+var ledgerSummaryToolOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  import_zod5.z.object({
+    status: import_zod5.z.literal("connected"),
+    connected: import_zod5.z.literal(true),
+    summary: ledgerSummarySchema
+  }),
+  startLoginOutputSchema.extend({
+    status: import_zod5.z.literal("pending"),
+    connected: import_zod5.z.literal(false),
+    message: import_zod5.z.string()
+  })
+]);
+var marketSnapshotToolOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  import_zod5.z.object({
+    status: import_zod5.z.literal("connected"),
+    connected: import_zod5.z.literal(true),
+    snapshot: marketSnapshotSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: import_zod5.z.literal("pending"),
+    connected: import_zod5.z.literal(false),
+    message: import_zod5.z.string()
+  })
+]);
+var marketSnapshotChunkToolOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  import_zod5.z.object({
+    status: import_zod5.z.literal("connected"),
+    connected: import_zod5.z.literal(true),
+    snapshotChunk: marketSnapshotChunkSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: import_zod5.z.literal("pending"),
+    connected: import_zod5.z.literal(false),
+    message: import_zod5.z.string()
+  })
+]);
+var marketSymbolDetailToolOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  import_zod5.z.object({
+    status: import_zod5.z.literal("connected"),
+    connected: import_zod5.z.literal(true),
+    detail: marketSymbolDetailSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: import_zod5.z.literal("pending"),
+    connected: import_zod5.z.literal(false),
+    message: import_zod5.z.string()
+  })
+]);
+var tradeActionInputSchema = submitTradeIntentInputSchema.omit({
+  intentType: true
+});
+var tradeActionToolOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  import_zod5.z.object({
+    status: import_zod5.z.literal("connected"),
+    connected: import_zod5.z.literal(true),
+    submission: submitTradeIntentResultSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: import_zod5.z.literal("pending"),
+    connected: import_zod5.z.literal(false),
+    message: import_zod5.z.string()
+  })
+]);
+var closeTradeToolOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  import_zod5.z.object({
+    status: import_zod5.z.literal("connected"),
+    connected: import_zod5.z.literal(true),
+    closure: closePositionResultSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: import_zod5.z.literal("pending"),
+    connected: import_zod5.z.literal(false),
+    message: import_zod5.z.string()
+  })
+]);
+var setTpSlToolOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  import_zod5.z.object({
+    status: import_zod5.z.literal("connected"),
+    connected: import_zod5.z.literal(true),
+    protection: setTpSlResultSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: import_zod5.z.literal("pending"),
+    connected: import_zod5.z.literal(false),
+    message: import_zod5.z.string()
+  })
+]);
+var deleteTpSlToolOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  import_zod5.z.object({
+    status: import_zod5.z.literal("connected"),
+    connected: import_zod5.z.literal(true),
+    deletion: deleteTpSlResultSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: import_zod5.z.literal("pending"),
+    connected: import_zod5.z.literal(false),
+    message: import_zod5.z.string()
+  })
+]);
+var openOrdersToolOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  import_zod5.z.object({
+    status: import_zod5.z.literal("connected"),
+    connected: import_zod5.z.literal(true),
+    orders: import_zod5.z.array(openOrderSchema)
+  }),
+  startLoginOutputSchema.extend({
+    status: import_zod5.z.literal("pending"),
+    connected: import_zod5.z.literal(false),
+    message: import_zod5.z.string()
+  })
+]);
+var cancelOrderToolOutputSchema = import_zod5.z.discriminatedUnion("status", [
+  import_zod5.z.object({
+    status: import_zod5.z.literal("connected"),
+    connected: import_zod5.z.literal(true),
+    cancellation: cancelOrderResultSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: import_zod5.z.literal("pending"),
+    connected: import_zod5.z.literal(false),
+    message: import_zod5.z.string()
+  })
+]);
+var documentPathInputSchema = import_zod5.z.object({
+  path: import_zod5.z.string().min(1)
+});
+var docsIndexSchema = import_zod5.z.object({
+  root: import_zod5.z.literal("docs"),
+  documents: import_zod5.z.array(
+    import_zod5.z.object({
+      path: import_zod5.z.string(),
+      section: import_zod5.z.string(),
+      title: import_zod5.z.string(),
+      bytes: import_zod5.z.number().int().nonnegative()
+    })
+  )
+});
+var documentSchema = import_zod5.z.object({
+  path: import_zod5.z.string(),
+  section: import_zod5.z.string(),
+  title: import_zod5.z.string(),
+  body: import_zod5.z.string(),
+  bytes: import_zod5.z.number().int().nonnegative()
+});
+function createHeliosDocsToolDefinitions(service) {
+  return [
+    {
+      name: "helios_docs_get_index",
+      title: "Get Helios Docs Index",
+      description: "Lists the package-local Helios MCP and indicator .txt documentation available to the agent.",
+      inputSchema: import_zod5.z.object({}),
+      async execute() {
+        const result = docsIndexSchema.parse(await service.getIndex());
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Helios docs index: ${result.documents.length} documents across ${new Set(result.documents.map((document) => document.section)).size} sections.`
+            }
+          ],
+          structuredContent: result
+        };
+      }
+    },
+    {
+      name: "helios_docs_get_document",
+      title: "Get Helios Doc",
+      description: "Returns one package-local Helios .txt document by relative docs path.",
+      inputSchema: documentPathInputSchema,
+      async execute(input) {
+        const result = documentSchema.parse(await service.getDocument(input));
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.body
+            }
+          ],
+          structuredContent: result
+        };
+      }
+    }
+  ];
+}
+function createHeliosAuthToolDefinitions(service) {
+  return [
+    {
+      name: "helios_auth_start_login",
+      title: "Start Helios Login",
+      description: "Starts the delegated Helios login flow and returns the approval URL for the user.",
+      inputSchema: agentDeviceStartInputSchema,
+      async execute(input) {
+        const result = startLoginOutputSchema.parse(await service.startLogin(input));
+        const manualResult = {
+          ...result,
+          ...withManualLoginFields(result)
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: buildManualLoginText(result)
+            }
+          ],
+          structuredContent: manualResult
+        };
+      }
+    },
+    {
+      name: "helios_auth_ensure_login",
+      title: "Ensure Helios Login",
+      description: "Ensures a delegated Helios session exists, or starts a login flow and returns a ready-to-display approval prompt. Call it again after the person approves: it finishes connecting.",
+      inputSchema: ensureLoginInputSchema,
+      async execute(input) {
+        const result = ensureLoginOutputSchema.parse(await service.ensureLogin(input));
+        const structuredContent = result.status === "connected" ? result : {
+          ...result,
+          ...withManualLoginFields(result)
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Connected to Helios as user ${result.ownerUserId}.` : result.message
+            }
+          ],
+          structuredContent
+        };
+      }
+    },
+    {
+      name: "helios_auth_poll_login",
+      title: "Poll Helios Login",
+      description: "Checks whether the Helios login was approved and finishes connecting. The device code is optional; without it, the login in progress is checked.",
+      inputSchema: pollLoginInputSchema,
+      async execute(input) {
+        const result = pollLoginOutputSchema.parse(await service.pollLogin(input.deviceCode));
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Connected to Helios as user ${result.ownerUserId}.` : `Helios login is ${result.status}: ${result.message}`
+            }
+          ],
+          structuredContent: result
+        };
+      }
+    },
+    {
+      name: "helios_auth_whoami",
+      title: "Helios Login Status",
+      description: "Returns the delegated Helios session state currently stored by the MCP server.",
+      inputSchema: import_zod5.z.object({}),
+      async execute() {
+        const result = agentSessionViewSchema.parse(await service.whoami());
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.connected ? `Connected to Helios as user ${result.ownerUserId}.` : "No delegated Helios session is connected."
+            }
+          ],
+          structuredContent: result
+        };
+      }
+    }
+  ];
+}
+function createHeliosProviderToolDefinitions(service) {
+  return [
+    {
+      name: "helios_provider_get_active",
+      title: "Get Helios Active Provider",
+      description: "Returns the provider currently pinned for this MCP session, if any.",
+      inputSchema: import_zod5.z.object({}),
+      async execute() {
+        const result = activeProviderSchema.parse(await service.getActiveProvider());
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.configured ? `Helios active provider is ${result.provider}.` : "No Helios active provider is configured for this session."
+            }
+          ],
+          structuredContent: result
+        };
+      }
+    },
+    {
+      name: "helios_provider_set_active",
+      title: "Set Helios Active Provider",
+      description: "Pins the active provider for this MCP session so portfolio and trading tools can omit provider.",
+      inputSchema: providerSetInputSchema,
+      async execute(input) {
+        const result = activeProviderSchema.parse(await service.setActiveProvider(input.provider));
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Helios active provider set to ${result.provider}.`
+            }
+          ],
+          structuredContent: result
+        };
+      }
+    }
+  ];
+}
+function createHeliosAccountToolDefinitions(service) {
+  return [
+    {
+      name: "helios_account_get_wallet_state",
+      title: "Get Helios Wallet State",
+      description: "Returns the current Hyperliquid wallet snapshot for the connected Helios account.",
+      inputSchema: import_zod5.z.object({}),
+      async execute() {
+        const result = walletStateToolOutputSchema.parse(await service.getWalletState());
+        const structuredContent = result.status === "connected" ? result : {
+          ...result,
+          ...withManualLoginFields(result)
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Helios wallet state: available balance ${result.walletState.availableBalance}, account value ${result.walletState.accountValue}.` : result.message
+            }
+          ],
+          structuredContent
+        };
+      }
+    },
+    {
+      name: "helios_portfolio_get",
+      title: "Get Helios Portfolio",
+      description: "Returns a provider-specific portfolio snapshot. Provider may be omitted if one is already pinned with helios_provider_set_active.",
+      inputSchema: providerSelectionInputSchema,
+      async execute(input) {
+        const result = portfolioToolOutputSchema.parse(await service.getPortfolio(input));
+        const structuredContent = result.status === "connected" ? result : {
+          ...result,
+          ...withManualLoginFields(result)
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? buildPortfolioText(result.portfolio) : result.message
+            }
+          ],
+          structuredContent
+        };
+      }
+    }
+  ];
+}
+function createHeliosLedgerToolDefinitions(service) {
+  return [
+    {
+      name: "helios_positions_get_open",
+      title: "Get Helios Open Positions",
+      description: "Returns the current open Hyperliquid positions for the connected Helios account.",
+      inputSchema: import_zod5.z.object({}),
+      async execute() {
+        const result = openPositionsToolOutputSchema.parse(await service.getOpenPositions());
+        const structuredContent = result.status === "connected" ? result : {
+          ...result,
+          ...withManualLoginFields(result)
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Helios open positions: ${result.openPositions.positions.length} positions, total unrealized PnL ${result.openPositions.totalUnrealizedPnl}.` : result.message
+            }
+          ],
+          structuredContent
+        };
+      }
+    },
+    {
+      name: "helios_ledger_get_fills",
+      title: "Get Helios Ledger Fills",
+      description: "Returns recent Hyperliquid fills/trade history for the connected Helios account.",
+      inputSchema: ledgerFillsInputSchema,
+      async execute(input) {
+        const result = ledgerFillsToolOutputSchema.parse(await service.getFills(input));
+        const structuredContent = result.status === "connected" ? result : {
+          ...result,
+          ...withManualLoginFields(result)
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Helios ledger fills: ${result.fills.fills.length} fills from ${result.fills.window}${result.fills.hasMore ? ", more available" : ""}.` : result.message
+            }
+          ],
+          structuredContent
+        };
+      }
+    },
+    {
+      name: "helios_ledger_get_summary",
+      title: "Get Helios Ledger Summary",
+      description: "Returns realized PnL, fees, and win/loss metrics over a recent Hyperliquid fill window.",
+      inputSchema: ledgerSummaryInputSchema,
+      async execute(input) {
+        const result = ledgerSummaryToolOutputSchema.parse(await service.getSummary(input));
+        const structuredContent = result.status === "connected" ? result : {
+          ...result,
+          ...withManualLoginFields(result)
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Helios ledger summary (${result.summary.window}): realized PnL ${result.summary.realizedPnl}, fees ${result.summary.totalFees}, wins ${result.summary.winCount}, losses ${result.summary.lossCount}.` : result.message
+            }
+          ],
+          structuredContent
+        };
+      }
+    }
+  ];
+}
+function createHeliosMarketToolDefinitions(service) {
+  return [
+    {
+      name: "helios_market_get_snapshot",
+      title: "Get Helios Market Snapshot",
+      description: "Returns a compact market snapshot for the selected, all, or explicitly requested symbols.",
+      inputSchema: marketSnapshotInputSchema,
+      async execute(input) {
+        const result = marketSnapshotToolOutputSchema.parse(await service.getSnapshot(input));
+        const structuredContent = result.status === "connected" ? result : {
+          ...result,
+          ...withManualLoginFields(result)
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Helios market snapshot: ${result.snapshot.symbolCount} symbols (${result.snapshot.scope}) at ${result.snapshot.generatedAt}. Timeframe return fields are already percentages; do not multiply by 100. Null means unavailable, not zero.` : result.message
+            }
+          ],
+          structuredContent
+        };
+      }
+    },
+    {
+      name: "helios_market_get_snapshot_chunk",
+      title: "Get Helios Market Snapshot Chunk",
+      description: "Returns one chunk of the Helios market snapshot for batch analysis when the full snapshot is too large.",
+      inputSchema: marketSnapshotChunkInputSchema,
+      async execute(input) {
+        const result = marketSnapshotChunkToolOutputSchema.parse(await service.getSnapshotChunk(input));
+        const structuredContent = result.status === "connected" ? result : {
+          ...result,
+          ...withManualLoginFields(result)
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Helios market snapshot chunk: ${result.snapshotChunk.chunkSymbolCount}/${result.snapshotChunk.totalSymbolCount} symbols at offset ${result.snapshotChunk.offset} (limit ${result.snapshotChunk.limit}). ${result.snapshotChunk.hasMore ? `Read next chunk at offset ${result.snapshotChunk.nextOffset}.` : "No more chunks remain."} Timeframe return fields are already percentages; do not multiply by 100. Null means unavailable, not zero.` : result.message
+            }
+          ],
+          structuredContent
+        };
+      }
+    },
+    {
+      name: "helios_market_get_symbol_detail",
+      title: "Get Helios Symbol Detail",
+      description: "Returns expanded market detail for one symbol from the current Helios market snapshot.",
+      inputSchema: marketSymbolDetailInputSchema,
+      async execute(input) {
+        const result = marketSymbolDetailToolOutputSchema.parse(await service.getSymbolDetail(input));
+        const structuredContent = result.status === "connected" ? result : {
+          ...result,
+          ...withManualLoginFields(result)
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Helios symbol detail: ${result.detail.symbol} at ${result.detail.generatedAt}. Timeframe return fields are already percentages; do not multiply by 100. Null means unavailable, not zero.` : result.message
+            }
+          ],
+          structuredContent
+        };
+      }
+    }
+  ];
+}
+function createHeliosTradingToolDefinitions(service) {
+  return [
+    {
+      name: "helios_trading_open",
+      title: "Open Helios Position",
+      description: "Submits a Helios OPEN trading intent. Provider may be omitted if one is already pinned with helios_provider_set_active.",
+      inputSchema: tradeActionInputSchema,
+      async execute(input) {
+        const result = tradeActionToolOutputSchema.parse(await service.open(input));
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Submitted Helios OPEN intent for ${result.submission.provider ?? input.provider} ${result.submission.symbol} ${result.submission.direction} with ${result.submission.execution.style} execution.` : result.message
+            }
+          ],
+          structuredContent: result.status === "connected" ? result : {
+            ...result,
+            ...withManualLoginFields(result)
+          }
+        };
+      }
+    },
+    {
+      name: "helios_trading_dca",
+      title: "DCA Helios Position",
+      description: "Submits a Helios DCA trading intent. Provider may be omitted if one is already pinned with helios_provider_set_active.",
+      inputSchema: tradeActionInputSchema,
+      async execute(input) {
+        const result = tradeActionToolOutputSchema.parse(await service.dca(input));
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Submitted Helios DCA intent for ${result.submission.provider ?? input.provider} ${result.submission.symbol} ${result.submission.direction} with ${result.submission.execution.style} execution.` : result.message
+            }
+          ],
+          structuredContent: result.status === "connected" ? result : {
+            ...result,
+            ...withManualLoginFields(result)
+          }
+        };
+      }
+    },
+    {
+      name: "helios_trading_reverse",
+      title: "Reverse Helios Position",
+      description: "Submits a Helios REVERSE trading intent. Provider may be omitted if one is already pinned with helios_provider_set_active.",
+      inputSchema: tradeActionInputSchema,
+      async execute(input) {
+        const result = tradeActionToolOutputSchema.parse(await service.reverse(input));
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Submitted Helios REVERSE intent for ${result.submission.provider ?? input.provider} ${result.submission.symbol} ${result.submission.direction} with ${result.submission.execution.style} execution.` : result.message
+            }
+          ],
+          structuredContent: result.status === "connected" ? result : {
+            ...result,
+            ...withManualLoginFields(result)
+          }
+        };
+      }
+    },
+    {
+      name: "helios_trading_close",
+      title: "Close Helios Position",
+      description: "Closes the full Helios position using the dedicated backend close route. Provider may be omitted if one is already pinned with helios_provider_set_active.",
+      inputSchema: closePositionInputSchema,
+      async execute(input) {
+        const result = closeTradeToolOutputSchema.parse(await service.close(input));
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Submitted Helios full close for ${result.closure.provider ?? input.provider} ${result.closure.symbol}.` : result.message
+            }
+          ],
+          structuredContent: result.status === "connected" ? result : {
+            ...result,
+            ...withManualLoginFields(result)
+          }
+        };
+      }
+    },
+    {
+      name: "helios_positions_set_tp_sl",
+      title: "Set Helios TP/SL",
+      description: "Creates or replaces take-profit and stop-loss protection for an existing Helios position. Provider may be omitted if one is already pinned with helios_provider_set_active.",
+      inputSchema: setTpSlInputSchema,
+      async execute(input) {
+        const result = setTpSlToolOutputSchema.parse(await service.setTpSl(input));
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Submitted ${result.protection.provider ?? input.provider} TP/SL protection update for ${result.protection.symbol}.` : result.message
+            }
+          ],
+          structuredContent: result.status === "connected" ? result : {
+            ...result,
+            ...withManualLoginFields(result)
+          }
+        };
+      }
+    },
+    {
+      name: "helios_positions_delete_tp_sl",
+      title: "Delete Helios TP/SL",
+      description: "Deletes an existing Helios take-profit or stop-loss order by order id. Provider may be omitted if one is already pinned with helios_provider_set_active.",
+      inputSchema: deleteTpSlInputSchema,
+      async execute(input) {
+        const result = deleteTpSlToolOutputSchema.parse(await service.deleteTpSl(input));
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Deleted ${result.deletion.provider ?? input.provider} TP/SL order ${result.deletion.orderId} for ${result.deletion.symbol}.` : result.message
+            }
+          ],
+          structuredContent: result.status === "connected" ? result : {
+            ...result,
+            ...withManualLoginFields(result)
+          }
+        };
+      }
+    },
+    {
+      name: "helios_orders_get_open",
+      title: "Get Helios Open Orders",
+      description: "Lists the currently open Hyperliquid orders for the connected account.",
+      inputSchema: import_zod5.z.object({}),
+      async execute() {
+        const result = openOrdersToolOutputSchema.parse(await service.getOpenOrders());
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Retrieved ${result.orders.length} open Helios orders.` : result.message
+            }
+          ],
+          structuredContent: result.status === "connected" ? result : {
+            ...result,
+            ...withManualLoginFields(result)
+          }
+        };
+      }
+    },
+    {
+      name: "helios_orders_cancel",
+      title: "Cancel Helios Order",
+      description: "Cancels an open Hyperliquid order by symbol and order id.",
+      inputSchema: cancelOrderInputSchema,
+      async execute(input) {
+        const result = cancelOrderToolOutputSchema.parse(await service.cancelOrder(input));
+        return {
+          content: [
+            {
+              type: "text",
+              text: result.status === "connected" ? `Cancelled Helios order ${result.cancellation.oid} for ${result.cancellation.symbol}.` : result.message
+            }
+          ],
+          structuredContent: result.status === "connected" ? result : {
+            ...result,
+            ...withManualLoginFields(result)
+          }
+        };
+      }
+    }
+  ];
+}
+function withManualLoginFields(result) {
+  return {
+    actionRequired: true,
+    loginUrl: result.verificationUriComplete,
+    nextStep: "Open the login URL in your browser, approve Helios access, then call helios_auth_ensure_login again to finish connecting."
+  };
+}
+function buildPortfolioText(result) {
+  return `Helios Hyperliquid portfolio: ${result.positions.length} positions, available balance ${result.availableBalance}, total balance ${result.totalBalance}.`;
+}
+function buildManualLoginText(result) {
+  return `Log in to Helios by opening this URL in your browser:
+
+${result.verificationUriComplete}
+
+User code: ${result.userCode}
+
+After approving access, call helios_auth_ensure_login (or helios_auth_poll_login) again to finish connecting.`;
+}
+
+// src/server.ts
+async function createHeliosAgentMcpServer(options) {
+  if (!options.identityServiceUrl) {
+    throw new Error("identityServiceUrl is required");
+  }
+  if (!options.dataBridgeUrl) {
+    throw new Error("dataBridgeUrl is required");
+  }
+  const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+  const server = new McpServer({
+    name: "helios",
+    version: "0.2.1"
+  });
+  const sessionStore = options.sessionStore ?? new FileAgentSessionStore(options.sessionPath ?? getDefaultHeliosAgentMcpSessionPath());
+  const client = new HeliosAgentAuthClient({
+    baseUrl: options.identityServiceUrl,
+    fetch: options.fetch
+  });
+  const dataBridgeClient = new HeliosAgentDataBridgeClient({
+    baseUrl: options.dataBridgeUrl,
+    fetch: options.fetch
+  });
+  const authService = new HeliosAgentMcpAuthService({
+    client,
+    sessionStore,
+    refreshWindowMs: options.refreshWindowMs,
+    deviceLogin: !options.hosted
+  });
+  const providerService = new HeliosAgentMcpProviderService({
+    sessionStore
+  });
+  const accountService = new HeliosAgentMcpAccountService({
+    authService,
+    dataBridgeClient,
+    providerService
+  });
+  const marketService = new HeliosAgentMcpMarketService({
+    authService,
+    dataBridgeClient
+  });
+  const ledgerService = new HeliosAgentMcpLedgerService({
+    authService,
+    dataBridgeClient
+  });
+  const tradingService = new HeliosAgentMcpTradingService({
+    authService,
+    dataBridgeClient,
+    providerService
+  });
+  const docsService = new HeliosAgentMcpDocsService({
+    docsRoot: options.docsRoot ?? getDefaultHeliosAgentMcpDocsRoot()
+  });
+  const docsTools = createHeliosDocsToolDefinitions(docsService);
+  const authTools = createHeliosAuthToolDefinitions(authService);
+  const providerTools = createHeliosProviderToolDefinitions(providerService);
+  const accountTools = createHeliosAccountToolDefinitions(accountService);
+  const ledgerTools = createHeliosLedgerToolDefinitions(ledgerService);
+  const marketTools = createHeliosMarketToolDefinitions(marketService);
+  const tradingTools = createHeliosTradingToolDefinitions(tradingService);
+  registerTool(server, docsTools[0]);
+  registerTool(server, docsTools[1]);
+  if (!options.hosted) {
+    registerTool(server, authTools[0]);
+    registerTool(server, authTools[1]);
+    registerTool(server, authTools[2]);
+  }
+  registerTool(server, authTools[3]);
+  registerTool(server, providerTools[0]);
+  registerTool(server, providerTools[1]);
+  registerTool(server, accountTools[0]);
+  registerTool(server, accountTools[1]);
+  registerTool(server, ledgerTools[0]);
+  registerTool(server, ledgerTools[1]);
+  registerTool(server, ledgerTools[2]);
+  registerTool(server, marketTools[0]);
+  registerTool(server, marketTools[1]);
+  registerTool(server, marketTools[2]);
+  registerTool(server, tradingTools[0]);
+  registerTool(server, tradingTools[1]);
+  registerTool(server, tradingTools[2]);
+  registerTool(server, tradingTools[3]);
+  registerTool(server, tradingTools[4]);
+  registerTool(server, tradingTools[5]);
+  registerTool(server, tradingTools[6]);
+  registerTool(server, tradingTools[7]);
+  return {
+    server,
+    authService,
+    providerService,
+    accountService,
+    docsService,
+    ledgerService,
+    marketService,
+    tradingService,
+    sessionStore
+  };
+}
+var ACTS_ON_ACCOUNT = /^helios_(trading_|positions_set_tp_sl|positions_delete_tp_sl|orders_cancel)/;
+var CHANGES_SESSION = /^helios_(auth_start_login|auth_ensure_login|auth_poll_login|provider_set_active)$/;
+function toolAnnotations(name) {
+  if (ACTS_ON_ACCOUNT.test(name)) return { readOnlyHint: false, destructiveHint: true, openWorldHint: true };
+  if (CHANGES_SESSION.test(name)) return { readOnlyHint: false, destructiveHint: false, openWorldHint: false };
+  return { readOnlyHint: true, destructiveHint: false, openWorldHint: true };
+}
+function registerTool(server, tool) {
+  server.registerTool(
+    tool.name,
+    {
+      title: tool.title,
+      description: tool.description,
+      inputSchema: tool.inputSchema,
+      annotations: { title: tool.title, ...toolAnnotations(tool.name) }
+    },
+    async (input) => {
+      const result = await tool.execute(tool.inputSchema.parse(input));
+      return {
+        ...result,
+        structuredContent: result.structuredContent
+      };
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileAgentSessionStore,
+  HOSTED_RECONNECT_MESSAGE,
+  HeliosAgentMcpAccountService,
+  HeliosAgentMcpAuthService,
+  HeliosAgentMcpDocsService,
+  HeliosAgentMcpLedgerService,
+  HeliosAgentMcpMarketService,
+  HeliosAgentMcpProviderService,
+  HeliosAgentMcpTradingService,
+  MemoryAgentMcpSessionStore,
+  createHeliosAccountToolDefinitions,
+  createHeliosAgentMcpServer,
+  createHeliosAuthToolDefinitions,
+  createHeliosDocsToolDefinitions,
+  createHeliosLedgerToolDefinitions,
+  createHeliosMarketToolDefinitions,
+  createHeliosProviderToolDefinitions,
+  createHeliosTradingToolDefinitions,
+  formatHeliosLoginPrompt,
+  getDefaultHeliosAgentMcpDocsRoot,
+  getDefaultHeliosAgentMcpSessionPath,
+  pendingAgentLoginSchema,
+  retryAfterUnauthorizedRefresh,
+  toolAnnotations
+});