@pgnio/helios-mcp 0.2.9 → 0.5.0

package/dist/chunk-7TMDGB6C.mjs

@@ -1,3084 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-
-// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_tsx@4.20.6_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js
-import path from "path";
-import { fileURLToPath } from "url";
-var getFilename = () => fileURLToPath(import.meta.url);
-var getDirname = () => path.dirname(getFilename());
-var __dirname = /* @__PURE__ */ getDirname();
-
-// ../agent/dist/index.mjs
-import { z } from "zod";
-import { z as z2 } from "zod";
-import { z as z3 } from "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 = z.enum(AGENT_SCOPE_VALUES);
-var agentGrantStatusSchema = z.enum(["active", "revoked"]);
-var agentDeviceRequestStatusSchema = z.enum(["pending", "approved", "rejected", "exchanged", "expired"]);
-var agentConstraintsSchema = z.record(z.string(), z.unknown()).default({});
-var agentGrantMetadataSchema = z.object({
-  id: z.string(),
-  userId: z.string(),
-  clientName: z.string(),
-  status: agentGrantStatusSchema,
-  scope: z.array(agentScopeSchema).min(1),
-  constraints: agentConstraintsSchema,
-  tokenVersion: z.number().int().nonnegative(),
-  createdAt: z.string(),
-  approvedAt: z.string().optional(),
-  lastUsedAt: z.string().optional(),
-  revokedAt: z.string().optional()
-});
-var agentDeviceStartInputSchema = z.object({
-  clientName: z.string().min(1).max(64),
-  scope: z.array(agentScopeSchema).min(1),
-  constraints: agentConstraintsSchema.optional()
-});
-var agentDeviceStartOutputSchema = z.object({
-  deviceCode: z.string(),
-  userCode: z.string(),
-  verificationUri: z.string().url(),
-  verificationUriComplete: z.string().url(),
-  expiresInSeconds: z.number().int().positive(),
-  pollIntervalSeconds: z.number().int().positive()
-});
-var agentDeviceTokenInputSchema = z.object({
-  deviceCode: z.string().min(1)
-});
-var agentDeviceRequestViewSchema = z.object({
-  userCode: z.string(),
-  clientName: z.string(),
-  scope: z.array(agentScopeSchema).min(1),
-  constraints: agentConstraintsSchema,
-  status: agentDeviceRequestStatusSchema,
-  expiresAt: z.string()
-});
-var agentTokenResponseSchema = z.object({
-  accessToken: z.string(),
-  refreshToken: z.string(),
-  tokenType: z.literal("Bearer"),
-  expiresInSeconds: z.number().int().positive(),
-  scope: z.array(agentScopeSchema).min(1),
-  ownerUserId: z.string(),
-  agentGrantId: z.string()
-});
-var agentRefreshInputSchema = z.object({
-  refreshToken: z.string().min(1)
-});
-var agentApprovalResponseSchema = z.object({
-  request: agentDeviceRequestViewSchema,
-  grant: agentGrantMetadataSchema
-});
-var agentSessionStateSchema = z.object({
-  status: z.enum(["pending", "authorized", "rejected", "revoked"]),
-  request: agentDeviceRequestViewSchema.optional(),
-  grant: agentGrantMetadataSchema.optional()
-});
-var providerSchema = z.enum(["hyperliquid"]);
-var walletStateSchema = z.object({
-  provider: z.literal("hyperliquid"),
-  accountValue: z.number(),
-  availableBalance: z.number(),
-  withdrawable: z.number(),
-  totalMarginUsed: z.number(),
-  totalNotionalPosition: z.number(),
-  crossMarginAccountValue: z.number(),
-  isActivated: z.boolean(),
-  fetchedAt: z.string().datetime()
-});
-var openPositionSchema = z.object({
-  symbol: z.string(),
-  side: z.enum(["LONG", "SHORT"]),
-  size: z.number(),
-  entryPrice: z.number(),
-  markPrice: z.number(),
-  unrealizedPnl: z.number(),
-  margin: z.number(),
-  leverage: z.number(),
-  liquidationPrice: z.number().optional()
-});
-var openPositionsSnapshotSchema = z.object({
-  provider: z.literal("hyperliquid"),
-  fetchedAt: z.string().datetime(),
-  totalUnrealizedPnl: z.number(),
-  positions: z.array(openPositionSchema)
-});
-var protectiveOrderKindSchema = z.enum(["STOP_LOSS", "TAKE_PROFIT"]);
-var protectiveOrderSideSchema = z.enum(["BUY", "SELL"]);
-var protectiveOrderPositionSideSchema = z.enum(["BOTH", "LONG", "SHORT"]);
-var protectiveOrderSchema = z.object({
-  /** Helios's record id: what helios_positions_delete_tp_sl takes (the Hyperliquid order id works there too). */
-  id: z.string(),
-  /** The Hyperliquid order id (named after the retired Binance field). */
-  binanceOrderId: z.number().int().nonnegative().nullish(),
-  clientOrderId: z.string().nullish(),
-  symbol: z.string(),
-  side: protectiveOrderSideSchema,
-  positionSide: protectiveOrderPositionSideSchema.nullish().transform((value) => value ?? "BOTH"),
-  status: z.string(),
-  kind: protectiveOrderKindSchema,
-  groupId: z.string().nullish(),
-  stopPrice: z.union([z.string(), z.number()]).nullish().transform((value) => value == null ? value : String(value)),
-  parentClientOrderId: z.string().nullish(),
-  assetId: z.number().int().nonnegative().nullish(),
-  createdAt: z.string().nullish()
-});
-var hyperliquidPortfolioSnapshotSchema = z.object({
-  provider: z.literal("hyperliquid"),
-  totalBalance: z.number(),
-  availableBalance: z.number(),
-  totalMargin: z.number(),
-  unrealizedPnl: z.number(),
-  positions: z.array(openPositionSchema),
-  /** Unreadable entries are dropped (see readProtectiveOrders) rather than failing the read. */
-  protectiveOrders: z.array(protectiveOrderSchema)
-});
-var portfolioInputSchema = z.object({
-  provider: providerSchema
-});
-var portfolioSnapshotSchema = hyperliquidPortfolioSnapshotSchema;
-var ledgerWindowSchema = z.enum(["24h", "7d", "30d"]);
-var ledgerFillsInputSchema = z.object({
-  window: ledgerWindowSchema.optional(),
-  limit: z.number().int().positive().max(200).optional(),
-  before: z.number().int().nonnegative().optional()
-});
-var ledgerFillSchema = z.object({
-  coin: z.string(),
-  px: z.number(),
-  sz: z.number(),
-  side: z.enum(["B", "A"]),
-  time: z.number().int().nonnegative(),
-  dir: z.string(),
-  closedPnl: z.number(),
-  fee: z.number(),
-  crossed: z.boolean(),
-  oid: z.number().int().nonnegative(),
-  tid: z.number().int().nonnegative()
-});
-var ledgerFillsPageSchema = z.object({
-  window: ledgerWindowSchema,
-  limit: z.number().int().positive(),
-  before: z.number().int().nonnegative().optional(),
-  hasMore: z.boolean(),
-  nextBefore: z.number().int().nonnegative().optional(),
-  fetchedAt: z.string().datetime(),
-  fills: z.array(ledgerFillSchema)
-});
-var ledgerPeriodSummarySchema = z.object({
-  realizedPnl: z.number(),
-  totalFees: z.number(),
-  fillCount: z.number().int().nonnegative(),
-  closeCount: z.number().int().nonnegative(),
-  winCount: z.number().int().nonnegative(),
-  lossCount: z.number().int().nonnegative(),
-  averageWin: z.number(),
-  averageLoss: z.number()
-});
-var ledgerSummaryInputSchema = z.object({
-  window: ledgerWindowSchema.optional()
-});
-var ledgerSummarySchema = ledgerPeriodSummarySchema.extend({
-  window: ledgerWindowSchema,
-  generatedAt: z.string().datetime(),
-  periods: z.object({
-    "24h": ledgerPeriodSummarySchema,
-    "7d": ledgerPeriodSummarySchema
-  })
-});
-var marketSnapshotScopeSchema = z.enum(["selected", "all"]);
-var marketSnapshotResolvedScopeSchema = z.enum(["selected", "all", "explicit"]);
-var marketSnapshotValueSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
-var marketSnapshotInputSchema = z.object({
-  scope: marketSnapshotScopeSchema.optional(),
-  symbols: z.array(z.string().min(1)).min(1).optional(),
-  fields: z.array(z.string().min(1)).min(1).optional().describe("Table columns to return; sym and base always come back. Ids: rank, lp, bv, qv, ts, r1m, r3m, r5m, r15m, r30m, r1h, r2h, r4h, r6h, r8h, r12h, r24h, r3d, r7d, hmi, hmiv, reg, ob, de, hfi, ar, ms, vcc, vcp, obosd, obosp, vwap, vwz, poc, pocd, vap, macdh, macds, macdd, srs, srr, fh24, fl24, fh7, fl7, sr, az, hfiw, trv, tri, trh, hs."),
-  sort: z.enum(["rank"]).optional().describe('"rank" orders rows by market cap rank, unranked last.')
-});
-var marketSnapshotChunkInputSchema = marketSnapshotInputSchema.extend({
-  offset: z.number().int().nonnegative().optional(),
-  limit: z.number().int().positive().max(100).optional()
-});
-var marketFieldBlockSchema = z.object({
-  fieldIds: z.array(z.string()).min(1),
-  values: z.array(marketSnapshotValueSchema),
-  symbolLists: z.record(z.string(), z.array(z.string())).optional()
-});
-var marketMatrixSchema = z.object({
-  fieldIds: z.array(z.string()).min(1),
-  rows: z.array(z.array(marketSnapshotValueSchema))
-});
-var marketFieldSemanticsSchema = z.object({
-  nullMeans: z.literal("unavailable"),
-  percentScale: z.literal("already_percent"),
-  percentFields: z.array(z.string()).min(1),
-  changeMapPercentKeys: z.array(z.string()).min(1)
-});
-var marketSnapshotSchema = z.object({
-  schema: z.literal("helios.market_snapshot.v1"),
-  view: z.literal("market_overview"),
-  scope: marketSnapshotResolvedScopeSchema,
-  symbolCount: z.number().int().nonnegative(),
-  generatedAt: z.string().datetime(),
-  returnedSymbols: z.array(z.string()),
-  semantics: marketFieldSemanticsSchema,
-  market: marketFieldBlockSchema,
-  table: marketMatrixSchema,
-  legend: z.record(z.string(), z.union([z.string(), z.array(z.string())]))
-});
-var marketSnapshotChunkSchema = z.object({
-  schema: z.literal("helios.market_snapshot_chunk.v1"),
-  view: z.literal("market_overview_chunk"),
-  scope: marketSnapshotResolvedScopeSchema,
-  totalSymbolCount: z.number().int().nonnegative(),
-  generatedAt: z.string().datetime(),
-  offset: z.number().int().nonnegative(),
-  limit: z.number().int().positive(),
-  chunkSymbolCount: z.number().int().nonnegative(),
-  hasMore: z.boolean(),
-  nextOffset: z.number().int().nonnegative().optional(),
-  returnedSymbols: z.array(z.string()),
-  semantics: marketFieldSemanticsSchema,
-  market: marketFieldBlockSchema,
-  table: marketMatrixSchema,
-  legend: z.record(z.string(), z.union([z.string(), z.array(z.string())]))
-});
-var marketSymbolDetailInputSchema = z.object({
-  symbol: z.string().min(1),
-  full: z.boolean().optional().describe("true adds every raw indicator and the price history (large, ~25 KB). Omit for the compact row and market context.")
-});
-var marketSymbolDetailSchema = z.object({
-  schema: z.literal("helios.market_symbol_detail.v1"),
-  generatedAt: z.string().datetime(),
-  symbol: z.string(),
-  semantics: marketFieldSemanticsSchema,
-  market: marketFieldBlockSchema,
-  row: z.record(z.string(), marketSnapshotValueSchema),
-  symbolCtx: z.record(z.string(), marketSnapshotValueSchema),
-  changeMap: z.record(z.string(), z.number().nullable()),
-  metrics: z.record(z.string(), z.unknown()).nullable(),
-  legend: z.record(z.string(), z.union([z.string(), z.array(z.string())]))
-});
-var tradingDirectionSchema = z.enum(["LONG", "SHORT"]);
-var tradingExecutionStyleSchema = z.enum(["MARKET", "LIMIT_TAKER", "LIMIT_MAKER", "LIMIT_GTC"]);
-var tradingSizeSchema = z.object({
-  mode: z.enum(["MARGIN_USD", "BASE_QUANTITY"]),
-  value: z.number().positive()
-});
-var tradingProtectionLegSchema = z.object({
-  kind: z.enum(["LIMIT", "MARKET"]),
-  triggerPrice: z.number().positive(),
-  limitPrice: z.number().positive().optional()
-});
-var tradingProtectionSchema = z.object({
-  takeProfit: tradingProtectionLegSchema.optional(),
-  stopLoss: tradingProtectionLegSchema.optional()
-});
-var tradeIntentTypeSchema = z.enum(["OPEN", "DCA", "REVERSE", "CLOSE"]);
-var submitTradeIntentInputSchema = z.object({
-  provider: providerSchema.optional(),
-  symbol: z.string().regex(/^[a-zA-Z0-9]+(?:USDT)?$/),
-  intentType: tradeIntentTypeSchema,
-  direction: tradingDirectionSchema,
-  size: tradingSizeSchema,
-  execution: z.object({
-    style: tradingExecutionStyleSchema,
-    timeInForce: z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
-    limitPrice: z.number().positive().optional()
-  }),
-  maxSlippageBps: z.number().int().nonnegative().max(1e3).optional(),
-  leverageOverride: z.number().positive().optional(),
-  marginModeOverride: z.enum(["ISOLATED", "CROSS"]).optional(),
-  reduceOnly: 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: z.string().regex(/^[A-Za-z0-9_-]{8,64}$/).optional()
-});
-var submitTradeIntentResultSchema = z.object({
-  status: z.literal("submitted"),
-  /** `replayed`: an earlier attempt of this action already placed the order; nothing new was sent. */
-  outcome: z.enum(["placed", "replayed"]).optional(),
-  clientOrderId: z.string().optional(),
-  orderStatus: z.string().optional(),
-  /** TP/SL legs Hyperliquid refused while the entry went through: the position is open without them. */
-  rejectedProtection: z.array(z.object({ kind: z.string(), reason: z.string() })).optional(),
-  provider: providerSchema.optional(),
-  symbol: z.string(),
-  intentType: tradeIntentTypeSchema,
-  direction: tradingDirectionSchema,
-  size: tradingSizeSchema,
-  execution: z.object({
-    style: tradingExecutionStyleSchema,
-    timeInForce: z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
-    limitPrice: z.number().positive().optional()
-  }),
-  maxSlippageBps: z.number().int().nonnegative().max(1e3).optional(),
-  leverageOverride: z.number().positive().optional(),
-  marginModeOverride: z.enum(["ISOLATED", "CROSS"]).optional(),
-  reduceOnly: z.boolean(),
-  hasProtection: z.boolean()
-});
-var closePositionInputSchema = z.object({
-  provider: providerSchema.optional(),
-  symbol: z.string().regex(/^[a-zA-Z0-9]+(?:USDT)?$/),
-  maxSlippageBps: z.number().int().nonnegative().max(1e3).optional()
-});
-var closePositionResultSchema = z.object({
-  status: z.literal("submitted"),
-  /** `no_position`: nothing was open on this coin, so no order was sent. Absent from older data-bridges. */
-  outcome: z.enum(["closed", "no_position"]).optional(),
-  provider: providerSchema.optional(),
-  symbol: z.string(),
-  mode: z.literal("FULL"),
-  maxSlippageBps: z.number().int().nonnegative().max(1e3).optional()
-});
-var setTpSlInputSchema = z.object({
-  provider: providerSchema.optional(),
-  symbol: z.string().regex(/^[a-zA-Z0-9]+(?:USDT)?$/),
-  applyTo: z.enum(["FULL_POSITION", "CUSTOM_QUANTITY"]),
-  quantity: z.number().positive().optional(),
-  parentClientOrderId: z.string(),
-  takeProfit: tradingProtectionLegSchema.optional(),
-  stopLoss: tradingProtectionLegSchema.optional()
-});
-var setTpSlResultSchema = z.object({
-  status: z.literal("submitted"),
-  provider: providerSchema.optional(),
-  symbol: z.string(),
-  applyTo: z.enum(["FULL_POSITION", "CUSTOM_QUANTITY"]),
-  quantity: z.number().positive().optional(),
-  parentClientOrderId: z.string(),
-  hasTakeProfit: z.boolean(),
-  hasStopLoss: z.boolean()
-});
-var deleteTpSlInputSchema = z.object({
-  provider: providerSchema.optional(),
-  symbol: z.string().regex(/^[a-zA-Z0-9]+(?:USDT)?$/),
-  orderId: z.string()
-});
-var deleteTpSlResultSchema = z.object({
-  status: z.literal("deleted"),
-  provider: providerSchema.optional(),
-  symbol: z.string(),
-  orderId: z.string()
-});
-var openOrderSchema = z.object({
-  coin: z.string(),
-  side: z.enum(["B", "A"]),
-  limitPx: z.string(),
-  sz: z.string(),
-  oid: z.number().int().nonnegative(),
-  timestamp: z.number().int().nonnegative(),
-  origSz: z.string(),
-  orderType: z.string(),
-  tif: z.string().nullable(),
-  reduceOnly: z.boolean(),
-  isTrigger: z.boolean(),
-  triggerPx: z.string(),
-  cloid: z.string().nullable(),
-  assetId: z.number().int().nonnegative().optional()
-});
-var cancelOrderInputSchema = z.object({
-  symbol: z.string().regex(/^[a-zA-Z0-9]+(?:USDT)?$/),
-  oid: z.number().int().nonnegative()
-});
-var cancelOrderResultSchema = z.object({
-  status: z.literal("cancelled"),
-  symbol: z.string(),
-  oid: z.number().int().nonnegative()
-});
-var heliosAgentErrorResponseSchema = z2.object({
-  error: z2.string().optional(),
-  errorDescription: z2.string().optional(),
-  message: z2.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(path4, body, schema) {
-    let response;
-    try {
-      response = await this.fetchImpl(`${this.baseUrl}${path4}`, {
-        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,
-      protectiveOrders: readProtectiveOrders(result.protectiveOrders)
-    });
-  }
-  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);
-    const payload = 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"
-    );
-    const outcome = this.tryUnwrapResult(payload)?.outcome;
-    return closePositionResultSchema.parse({
-      status: "submitted",
-      ...outcome === "closed" || outcome === "no_position" ? { outcome } : {},
-      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
-      });
-    }
-  }
-  /** The result of a mutation older data-bridges answer with nothing; null when there is none. */
-  tryUnwrapResult(payload) {
-    try {
-      return this.unwrapResult(payload) ?? null;
-    } catch {
-      return null;
-    }
-  }
-  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;
-  }
-};
-function readProtectiveOrders(value) {
-  if (!Array.isArray(value)) return [];
-  return value.flatMap((entry) => {
-    const parsed = protectiveOrderSchema.safeParse(entry);
-    return parsed.success ? [parsed.data] : [];
-  });
-}
-var DEFAULT_AGENT_REFRESH_WINDOW_MS = 60 * 1e3;
-var agentConnectionStatusSchema = z3.enum([
-  "disconnected",
-  "pending",
-  "connected",
-  "rejected",
-  "expired",
-  "failed"
-]);
-var storedAgentSessionSchema = z3.object({
-  accessToken: z3.string(),
-  refreshToken: z3.string(),
-  tokenType: agentTokenResponseSchema.shape.tokenType,
-  ownerUserId: z3.string(),
-  agentGrantId: z3.string(),
-  scope: z3.array(agentScopeSchema).min(1),
-  accessTokenExpiresAt: z3.string().datetime(),
-  createdAt: z3.string().datetime(),
-  lastRefreshedAt: z3.string().datetime()
-});
-var agentSessionViewSchema = z3.object({
-  connected: z3.boolean(),
-  status: agentConnectionStatusSchema,
-  ownerUserId: z3.string().optional(),
-  agentGrantId: z3.string().optional(),
-  scope: z3.array(agentScopeSchema).optional(),
-  accessTokenExpiresAt: z3.string().datetime().optional(),
-  lastRefreshedAt: z3.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
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
-import path2 from "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);
-    if (!existsSync(documentPath) || !statSync(documentPath).isFile()) {
-      throw new Error(`No document "${input.path}". helios_docs_get_index lists the documents.`);
-    }
-    const body = readFileSync(documentPath, "utf8");
-    const stats = statSync(documentPath);
-    const relativePath = toPosixPath(path2.relative(this.docsRoot, documentPath));
-    return {
-      path: relativePath,
-      section: getDocumentSection(relativePath),
-      title: extractDocumentTitle(body, relativePath),
-      body,
-      bytes: stats.size
-    };
-  }
-  readDocumentMetadata(documentPath) {
-    const body = readFileSync(documentPath, "utf8");
-    const stats = statSync(documentPath);
-    const relativePath = toPosixPath(path2.relative(this.docsRoot, documentPath));
-    return {
-      path: relativePath,
-      section: getDocumentSection(relativePath),
-      title: extractDocumentTitle(body, relativePath),
-      bytes: stats.size
-    };
-  }
-};
-function getDefaultHeliosAgentMcpDocsRoot() {
-  return path2.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 = readdirSync(currentPath, { withFileTypes: true });
-  const files = [];
-  for (const entry of entries) {
-    const nextPath = path2.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 = path2.resolve(root, normalizedPath);
-  const relativePath = path2.relative(root, resolvedPath);
-  if (!normalizedPath) {
-    throw new Error("Document path is required.");
-  }
-  if (path2.isAbsolute(normalizedPath) || relativePath.startsWith("..") || path2.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 path2.basename(relativePath, ".txt");
-}
-function getDocumentSection(relativePath) {
-  return relativePath.split("/")[0] ?? "docs";
-}
-function toPosixPath(value) {
-  return value.split(path2.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 DEFAULT_SNAPSHOT_TOP = 50;
-var DEFAULT_SNAPSHOT_FIELDS = [
-  // Price, size and returns.
-  "rank",
-  "lp",
-  "qv",
-  "r15m",
-  "r1h",
-  "r4h",
-  "r24h",
-  "r7d",
-  // Regime and momentum turn: the one edge that held out of sample is buying a sharp turn up in a BREAKDOWN/CRASH coin.
-  "reg",
-  "hmi",
-  "hmiv",
-  "hs",
-  // Stretch and location: fades beat chases in the wallet research.
-  "ob",
-  "obosp",
-  "de",
-  "ms",
-  "srs",
-  "srr",
-  "fh24",
-  "fl24",
-  "fh7",
-  "fl7",
-  "vwz",
-  "tri"
-];
-function withSnapshotDefaults(input) {
-  return {
-    ...input,
-    fields: input.fields ?? [...DEFAULT_SNAPSHOT_FIELDS],
-    sort: input.sort ?? "rank"
-  };
-}
-function topOfSnapshot(snapshot, input, top = DEFAULT_SNAPSHOT_TOP) {
-  if (input.symbols?.length || snapshot.table.rows.length <= top) return snapshot;
-  const baseIndex = snapshot.table.fieldIds.indexOf("base");
-  const rows = snapshot.table.rows.slice(0, top);
-  const returnedSymbols = baseIndex === -1 ? snapshot.returnedSymbols.slice(0, top) : rows.map((row) => String(row[baseIndex]));
-  return { ...snapshot, symbolCount: rows.length, returnedSymbols, table: { ...snapshot.table, rows } };
-}
-function compactSymbolDetail(detail, full) {
-  if (full) return detail;
-  return { ...detail, changeMap: {}, metrics: null };
-}
-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 = topOfSnapshot(await this.dataBridgeClient.getMarketSnapshot(session.accessToken, withSnapshotDefaults(input)), input);
-      return {
-        status: "connected",
-        connected: true,
-        snapshot
-      };
-    } catch (error) {
-      const recovery = await retryAfterUnauthorizedRefresh({
-        authService: this.authService,
-        error,
-        loginOptions,
-        retry: async (accessToken) => {
-          const snapshot = topOfSnapshot(await this.dataBridgeClient.getMarketSnapshot(accessToken, withSnapshotDefaults(input)), 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, withSnapshotDefaults(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, withSnapshotDefaults(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 = compactSymbolDetail(await this.dataBridgeClient.getMarketSymbolDetail(session.accessToken, { symbol: input.symbol }), input.full);
-      return {
-        status: "connected",
-        connected: true,
-        detail
-      };
-    } catch (error) {
-      const recovery = await retryAfterUnauthorizedRefresh({
-        authService: this.authService,
-        error,
-        loginOptions,
-        retry: async (accessToken) => {
-          const detail = compactSymbolDetail(await this.dataBridgeClient.getMarketSymbolDetail(accessToken, { symbol: input.symbol }), input.full);
-          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
-import { chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
-import { homedir } from "os";
-import path3 from "path";
-import { z as z4 } from "zod";
-function getDefaultHeliosAgentMcpSessionPath() {
-  return path3.join(homedir(), ".helios-agent-mcp", "session.json");
-}
-var pendingAgentLoginSchema = z4.object({
-  status: z4.literal("pending"),
-  deviceCode: z4.string(),
-  userCode: z4.string(),
-  verificationUri: z4.string().url(),
-  verificationUriComplete: z4.string().url(),
-  expiresInSeconds: z4.number().int().positive(),
-  pollIntervalSeconds: z4.number().int().positive(),
-  requestedScope: z4.array(agentScopeSchema).min(1),
-  startedAt: z4.string().datetime()
-});
-var mcpSessionStateSchema = z4.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 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 mkdir(path3.dirname(this.filePath), { recursive: true });
-    await writeFile(this.filePath, `${JSON.stringify(state, null, 2)}
-`, { encoding: "utf8", mode: 384 });
-    await 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 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
-import { randomUUID } from "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 ?? 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
-import { z as z5 } from "zod";
-var pollLoginInputSchema = z5.object({
-  /** Optional: defaults to the login started by helios_auth_ensure_login / helios_auth_start_login. */
-  deviceCode: z5.string().min(1).optional()
-});
-var startLoginOutputSchema = z5.object({
-  status: z5.literal("pending"),
-  deviceCode: z5.string(),
-  userCode: z5.string(),
-  verificationUri: z5.string().url(),
-  verificationUriComplete: z5.string().url(),
-  expiresInSeconds: z5.number().int().positive(),
-  pollIntervalSeconds: z5.number().int().positive(),
-  requestedScope: z5.array(agentScopeSchema).min(1),
-  startedAt: z5.string().datetime()
-});
-var ensureLoginInputSchema = z5.object({
-  clientName: z5.string().min(1).max(64).optional(),
-  scope: z5.array(agentScopeSchema).min(1).optional(),
-  constraints: agentConstraintsSchema.optional()
-});
-var providerSelectionInputSchema = z5.object({
-  provider: providerSchema.optional()
-});
-var providerSetInputSchema = z5.object({
-  provider: providerSchema
-});
-var activeProviderSchema = z5.object({
-  configured: z5.boolean(),
-  provider: providerSchema.nullable()
-});
-var ensureLoginOutputSchema = z5.discriminatedUnion("status", [
-  agentSessionViewSchema.extend({
-    status: z5.literal("connected"),
-    connected: z5.literal(true)
-  }),
-  startLoginOutputSchema.extend({
-    status: z5.literal("pending"),
-    connected: z5.literal(false),
-    message: z5.string()
-  })
-]);
-var pollLoginOutputSchema = z5.discriminatedUnion("status", [
-  agentSessionViewSchema.extend({
-    status: z5.literal("connected"),
-    connected: z5.literal(true)
-  }),
-  z5.object({
-    status: z5.enum(["pending", "rejected", "expired", "failed"]),
-    connected: z5.literal(false),
-    message: z5.string()
-  })
-]);
-var walletStateToolOutputSchema = z5.discriminatedUnion("status", [
-  z5.object({
-    status: z5.literal("connected"),
-    connected: z5.literal(true),
-    walletState: walletStateSchema
-  }),
-  startLoginOutputSchema.extend({
-    status: z5.literal("pending"),
-    connected: z5.literal(false),
-    message: z5.string()
-  })
-]);
-var portfolioToolOutputSchema = z5.discriminatedUnion("status", [
-  z5.object({
-    status: z5.literal("connected"),
-    connected: z5.literal(true),
-    portfolio: portfolioSnapshotSchema
-  }),
-  startLoginOutputSchema.extend({
-    status: z5.literal("pending"),
-    connected: z5.literal(false),
-    message: z5.string()
-  })
-]);
-var openPositionsToolOutputSchema = z5.discriminatedUnion("status", [
-  z5.object({
-    status: z5.literal("connected"),
-    connected: z5.literal(true),
-    openPositions: openPositionsSnapshotSchema
-  }),
-  startLoginOutputSchema.extend({
-    status: z5.literal("pending"),
-    connected: z5.literal(false),
-    message: z5.string()
-  })
-]);
-var ledgerFillsToolOutputSchema = z5.discriminatedUnion("status", [
-  z5.object({
-    status: z5.literal("connected"),
-    connected: z5.literal(true),
-    fills: ledgerFillsPageSchema
-  }),
-  startLoginOutputSchema.extend({
-    status: z5.literal("pending"),
-    connected: z5.literal(false),
-    message: z5.string()
-  })
-]);
-var ledgerSummaryToolOutputSchema = z5.discriminatedUnion("status", [
-  z5.object({
-    status: z5.literal("connected"),
-    connected: z5.literal(true),
-    summary: ledgerSummarySchema
-  }),
-  startLoginOutputSchema.extend({
-    status: z5.literal("pending"),
-    connected: z5.literal(false),
-    message: z5.string()
-  })
-]);
-var marketSnapshotToolOutputSchema = z5.discriminatedUnion("status", [
-  z5.object({
-    status: z5.literal("connected"),
-    connected: z5.literal(true),
-    snapshot: marketSnapshotSchema
-  }),
-  startLoginOutputSchema.extend({
-    status: z5.literal("pending"),
-    connected: z5.literal(false),
-    message: z5.string()
-  })
-]);
-var marketSnapshotChunkToolOutputSchema = z5.discriminatedUnion("status", [
-  z5.object({
-    status: z5.literal("connected"),
-    connected: z5.literal(true),
-    snapshotChunk: marketSnapshotChunkSchema
-  }),
-  startLoginOutputSchema.extend({
-    status: z5.literal("pending"),
-    connected: z5.literal(false),
-    message: z5.string()
-  })
-]);
-var marketSymbolDetailToolOutputSchema = z5.discriminatedUnion("status", [
-  z5.object({
-    status: z5.literal("connected"),
-    connected: z5.literal(true),
-    detail: marketSymbolDetailSchema
-  }),
-  startLoginOutputSchema.extend({
-    status: z5.literal("pending"),
-    connected: z5.literal(false),
-    message: z5.string()
-  })
-]);
-var tradeActionInputSchema = submitTradeIntentInputSchema.omit({
-  intentType: true
-});
-var tradeActionToolOutputSchema = z5.discriminatedUnion("status", [
-  z5.object({
-    status: z5.literal("connected"),
-    connected: z5.literal(true),
-    submission: submitTradeIntentResultSchema
-  }),
-  startLoginOutputSchema.extend({
-    status: z5.literal("pending"),
-    connected: z5.literal(false),
-    message: z5.string()
-  })
-]);
-var closeTradeToolOutputSchema = z5.discriminatedUnion("status", [
-  z5.object({
-    status: z5.literal("connected"),
-    connected: z5.literal(true),
-    closure: closePositionResultSchema
-  }),
-  startLoginOutputSchema.extend({
-    status: z5.literal("pending"),
-    connected: z5.literal(false),
-    message: z5.string()
-  })
-]);
-var setTpSlToolOutputSchema = z5.discriminatedUnion("status", [
-  z5.object({
-    status: z5.literal("connected"),
-    connected: z5.literal(true),
-    protection: setTpSlResultSchema
-  }),
-  startLoginOutputSchema.extend({
-    status: z5.literal("pending"),
-    connected: z5.literal(false),
-    message: z5.string()
-  })
-]);
-var deleteTpSlToolOutputSchema = z5.discriminatedUnion("status", [
-  z5.object({
-    status: z5.literal("connected"),
-    connected: z5.literal(true),
-    deletion: deleteTpSlResultSchema
-  }),
-  startLoginOutputSchema.extend({
-    status: z5.literal("pending"),
-    connected: z5.literal(false),
-    message: z5.string()
-  })
-]);
-var openOrdersToolOutputSchema = z5.discriminatedUnion("status", [
-  z5.object({
-    status: z5.literal("connected"),
-    connected: z5.literal(true),
-    orders: z5.array(openOrderSchema)
-  }),
-  startLoginOutputSchema.extend({
-    status: z5.literal("pending"),
-    connected: z5.literal(false),
-    message: z5.string()
-  })
-]);
-var cancelOrderToolOutputSchema = z5.discriminatedUnion("status", [
-  z5.object({
-    status: z5.literal("connected"),
-    connected: z5.literal(true),
-    cancellation: cancelOrderResultSchema
-  }),
-  startLoginOutputSchema.extend({
-    status: z5.literal("pending"),
-    connected: z5.literal(false),
-    message: z5.string()
-  })
-]);
-var documentPathInputSchema = z5.object({
-  path: z5.string().min(1)
-});
-var docsIndexSchema = z5.object({
-  root: z5.literal("docs"),
-  documents: z5.array(
-    z5.object({
-      path: z5.string(),
-      section: z5.string(),
-      title: z5.string(),
-      bytes: z5.number().int().nonnegative()
-    })
-  )
-});
-var documentSchema = z5.object({
-  path: z5.string(),
-  section: z5.string(),
-  title: z5.string(),
-  body: z5.string(),
-  bytes: z5.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: z5.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: z5.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: z5.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: z5.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 balances, open positions and their TP/SL (protectiveOrders, each with the id helios_positions_delete_tp_sl takes). 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: z5.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. By default: the top 50 coins by market cap with the main columns; name symbols to get other coins, pass fields for other columns. What each column means: helios_docs_get_document with path ai-agent-indicators/00_columns.txt (read it once).",
-      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 one coin: every snapshot column plus Hyperliquid context (funding, open interest, max leverage, mark price). For several coins, use helios_market_get_snapshot with symbols instead; pass full only when you need raw indicators.",
-      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" ? result.message : result.closure.outcome === "no_position" ? `No open ${result.closure.symbol} position: nothing was closed and no order was sent.` : `Sent a market order closing the full ${result.closure.provider ?? input.provider ?? "hyperliquid"} ${result.closure.symbol} position. Check helios_positions_get_open to confirm.`
-            }
-          ],
-          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 a take-profit or stop-loss. orderId is the id from helios_portfolio_get protectiveOrders, or the Hyperliquid order id of the TP/SL. 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: z5.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.9"
-  });
-  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 };
-}
-var TEXT_IS_RESULT = /* @__PURE__ */ new Set(["helios_docs_get_document"]);
-function withDataText(name, content, structuredContent) {
-  if (TEXT_IS_RESULT.has(name)) return content;
-  const summary = content.map((block) => block.text).join("\n\n");
-  return [{ type: "text", text: `${summary}
-
-${JSON.stringify(structuredContent)}` }];
-}
-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 {
-        content: withDataText(tool.name, result.content, result.structuredContent),
-        structuredContent: result.structuredContent
-      };
-    }
-  );
-}
-
-export {
-  HOSTED_RECONNECT_MESSAGE,
-  HeliosAgentMcpAuthService,
-  retryAfterUnauthorizedRefresh,
-  formatHeliosLoginPrompt,
-  HeliosAgentMcpAccountService,
-  HeliosAgentMcpDocsService,
-  getDefaultHeliosAgentMcpDocsRoot,
-  HeliosAgentMcpLedgerService,
-  DEFAULT_SNAPSHOT_TOP,
-  DEFAULT_SNAPSHOT_FIELDS,
-  withSnapshotDefaults,
-  topOfSnapshot,
-  compactSymbolDetail,
-  HeliosAgentMcpMarketService,
-  HeliosAgentMcpProviderService,
-  getDefaultHeliosAgentMcpSessionPath,
-  pendingAgentLoginSchema,
-  FileAgentSessionStore,
-  MemoryAgentMcpSessionStore,
-  HeliosAgentMcpTradingService,
-  createHeliosDocsToolDefinitions,
-  createHeliosAuthToolDefinitions,
-  createHeliosProviderToolDefinitions,
-  createHeliosAccountToolDefinitions,
-  createHeliosLedgerToolDefinitions,
-  createHeliosMarketToolDefinitions,
-  createHeliosTradingToolDefinitions,
-  createHeliosAgentMcpServer,
-  toolAnnotations,
-  withDataText
-};