@pgnio/helios-mcp 0.2.9 → 0.4.0

package/dist/chunk-5LIHYXEF.mjs

@@ -0,0 +1,4274 @@
+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.31_tsx@4.20.6_typescript@5.9.3_yaml@2.9.1/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();
+
+// src/endpoints.ts
+var DEFAULT_HELIOS_BASE_URL = "https://helios.pgn.io";
+var DEFAULT_HELIOS_SESSION_ISSUER = {
+  identityServiceUrl: DEFAULT_HELIOS_BASE_URL,
+  dataBridgeUrl: DEFAULT_HELIOS_BASE_URL
+};
+var LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+function assertHeliosBaseUrl(name, value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`${name} must be a URL, got ${JSON.stringify(value)}`);
+  }
+  if (url.protocol === "https:") {
+    return value;
+  }
+  if (url.protocol === "http:" && LOOPBACK_HOSTNAMES.has(url.hostname)) {
+    return value;
+  }
+  throw new Error(`${name} must use https (plain http only for localhost, 127.0.0.1 or [::1]), got ${url.origin}`);
+}
+function isSameHeliosIssuer(stored, configured) {
+  const issuer = stored ?? DEFAULT_HELIOS_SESSION_ISSUER;
+  return normalizeBaseUrl(issuer.identityServiceUrl) === normalizeBaseUrl(configured.identityServiceUrl) && normalizeBaseUrl(issuer.dataBridgeUrl) === normalizeBaseUrl(configured.dataBridgeUrl);
+}
+function normalizeBaseUrl(value) {
+  try {
+    const url = new URL(value);
+    return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+  } catch {
+    return value.replace(/\/+$/, "");
+  }
+}
+
+// ../agent/dist/index.mjs
+import { z as z4 } from "zod";
+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 VERIFIED_AGENT_APPS = [
+  { name: "Claude", redirects: ["https://claude.ai/api/mcp/auth_callback", "https://claude.com/api/mcp/auth_callback"] },
+  { name: "ChatGPT", redirects: ["https://chatgpt.com/connector_platform_oauth_redirect"] },
+  { name: "Cursor", redirects: ["https://www.cursor.com/agents/mcp/oauth/callback"] }
+];
+var RESERVED_AGENT_APP_NAMES = [
+  ...VERIFIED_AGENT_APPS.map((app) => app.name),
+  "VS Code",
+  "Helios",
+  "Wagmi",
+  "Ares",
+  "OpenAI",
+  "Anthropic",
+  "Grok"
+];
+var heliosAgentErrorResponseSchema = z.object({
+  error: z.string().optional(),
+  errorDescription: z.string().optional(),
+  message: z.string().optional()
+});
+var HeliosAgentApiError = class extends Error {
+  constructor(options) {
+    super(options.message);
+    __publicField2(this, "status");
+    __publicField2(this, "code");
+    __publicField2(this, "errorDescription");
+    __publicField2(this, "payload");
+    this.name = "HeliosAgentApiError";
+    this.status = options.status;
+    this.code = options.code;
+    this.errorDescription = options.errorDescription;
+    this.payload = options.payload;
+    if (options.cause !== void 0) {
+      Object.defineProperty(this, "cause", {
+        configurable: true,
+        enumerable: false,
+        value: options.cause,
+        writable: true
+      });
+    }
+  }
+};
+function isHeliosAgentApiError(error) {
+  return error instanceof HeliosAgentApiError;
+}
+var 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 = z2.enum(AGENT_SCOPE_VALUES);
+var AGENT_TRADING_SCOPES = [AGENT_SCOPES.ORDERS_WRITE, AGENT_SCOPES.ORDERS_CANCEL];
+var agentGrantStatusSchema = z2.enum(["active", "revoked"]);
+var agentDeviceRequestStatusSchema = z2.enum(["pending", "approved", "rejected", "exchanged", "expired"]);
+var AGENT_CONSTRAINTS_MAX_KEYS = 16;
+var agentConstraintsSchema = z2.record(z2.string().max(64), z2.unknown()).refine((value) => Object.keys(value).length <= AGENT_CONSTRAINTS_MAX_KEYS, {
+  message: `At most ${AGENT_CONSTRAINTS_MAX_KEYS} constraints`
+}).default({});
+var agentGrantMetadataSchema = z2.object({
+  id: z2.string(),
+  userId: z2.string(),
+  clientName: z2.string(),
+  status: agentGrantStatusSchema,
+  scope: z2.array(agentScopeSchema).min(1),
+  constraints: agentConstraintsSchema,
+  tokenVersion: z2.number().int().nonnegative(),
+  createdAt: z2.string(),
+  approvedAt: z2.string().optional(),
+  lastUsedAt: z2.string().optional(),
+  revokedAt: z2.string().optional()
+});
+var AGENT_START_SECRET_HEADER = "x-helios-agent-start-secret";
+var AGENT_CLIENT_IP_HEADER = "x-helios-client-ip";
+var agentDeviceStartInputSchema = z2.object({
+  clientName: z2.string().trim().min(1).max(64),
+  scope: z2.array(agentScopeSchema).min(1),
+  constraints: agentConstraintsSchema.optional(),
+  /** The app was matched to a known client by the hosted MCP. Ignored unless the start carries the start secret. */
+  verified: z2.boolean().optional(),
+  /** The approval answers a one-time proof the device must send with the token exchange (the hosted MCP's redirect). */
+  requireApprovalProof: z2.boolean().optional()
+});
+var agentDeviceStartOutputSchema = z2.object({
+  deviceCode: z2.string(),
+  userCode: z2.string(),
+  verificationUri: z2.string().url(),
+  verificationUriComplete: z2.string().url(),
+  expiresInSeconds: z2.number().int().positive(),
+  pollIntervalSeconds: z2.number().int().positive()
+});
+var agentDeviceTokenInputSchema = z2.object({
+  deviceCode: z2.string().min(1),
+  /** Required when the login was started with requireApprovalProof: the proof the approval answered with. */
+  approvalProof: z2.string().min(1).max(128).optional()
+});
+var agentDeviceRequestViewSchema = z2.object({
+  userCode: z2.string(),
+  clientName: z2.string(),
+  scope: z2.array(agentScopeSchema).min(1),
+  constraints: agentConstraintsSchema,
+  status: agentDeviceRequestStatusSchema,
+  expiresAt: z2.string(),
+  /** False when the app's name wasn't checked by Helios (anyone can start a login under any name). */
+  verified: z2.boolean().optional(),
+  /** The signed-in viewer already has an active connection under this name, which approving would replace. */
+  replacesExisting: z2.boolean().optional(),
+  /** Where the login was started, as identity saw the device/start call. Absent from older identity builds. */
+  startedFrom: z2.object({
+    ip: z2.string().nullable(),
+    userAgent: z2.string().nullable(),
+    startedAt: z2.string()
+  }).optional()
+});
+var agentDeviceApproveInputSchema = z2.object({
+  /** The person confirmed replacing their existing connection of the same name. */
+  replaceExisting: z2.boolean().optional(),
+  /**
+   * The scopes the person allowed: a non-empty subset of the request's scope (identity answers 400 invalid_scope
+   * otherwise). The grant and its tokens get exactly these. Absent: everything the request asked for.
+   */
+  scope: z2.array(agentScopeSchema).min(1).max(AGENT_SCOPE_VALUES.length).optional(),
+  /**
+   * The person confirmed they trust an unverified app to trade. Required (else 409 trading_acknowledgement_required)
+   * when the login is unverified and the approved scope includes a trading scope (AGENT_TRADING_SCOPES).
+   */
+  acknowledgeTrading: z2.boolean().optional()
+});
+var agentTokenResponseSchema = z2.object({
+  accessToken: z2.string(),
+  refreshToken: z2.string(),
+  tokenType: z2.literal("Bearer"),
+  expiresInSeconds: z2.number().int().positive(),
+  scope: z2.array(agentScopeSchema).min(1),
+  ownerUserId: z2.string(),
+  agentGrantId: z2.string()
+});
+var agentRefreshInputSchema = z2.object({
+  refreshToken: z2.string().min(1)
+});
+var agentApprovalResponseSchema = z2.object({
+  request: agentDeviceRequestViewSchema,
+  grant: agentGrantMetadataSchema,
+  /** Present when the login asked for one: hand it back to the device, which sends it with the token exchange. */
+  approvalProof: z2.string().optional()
+});
+var agentSessionStateSchema = z2.object({
+  status: z2.enum(["pending", "authorized", "rejected", "revoked"]),
+  request: agentDeviceRequestViewSchema.optional(),
+  grant: agentGrantMetadataSchema.optional()
+});
+var providerSchema = z2.enum(["hyperliquid"]);
+var walletStateSchema = z2.object({
+  provider: z2.literal("hyperliquid"),
+  accountValue: z2.number(),
+  availableBalance: z2.number(),
+  withdrawable: z2.number(),
+  totalMarginUsed: z2.number(),
+  totalNotionalPosition: z2.number(),
+  crossMarginAccountValue: z2.number(),
+  isActivated: z2.boolean(),
+  fetchedAt: z2.string().datetime()
+});
+var openPositionSchema = z2.object({
+  symbol: z2.string(),
+  side: z2.enum(["LONG", "SHORT"]),
+  size: z2.number(),
+  entryPrice: z2.number(),
+  markPrice: z2.number(),
+  unrealizedPnl: z2.number(),
+  margin: z2.number(),
+  leverage: z2.number(),
+  liquidationPrice: z2.number().optional()
+});
+var openPositionsSnapshotSchema = z2.object({
+  provider: z2.literal("hyperliquid"),
+  fetchedAt: z2.string().datetime(),
+  totalUnrealizedPnl: z2.number(),
+  positions: z2.array(openPositionSchema)
+});
+var protectiveOrderKindSchema = z2.enum(["STOP_LOSS", "TAKE_PROFIT"]);
+var protectiveOrderSideSchema = z2.enum(["BUY", "SELL"]);
+var protectiveOrderPositionSideSchema = z2.enum(["BOTH", "LONG", "SHORT"]);
+var protectiveOrderSchema = z2.object({
+  /** Helios's record id: what helios_positions_delete_tp_sl takes (the Hyperliquid order id works there too). */
+  id: z2.string(),
+  /** The Hyperliquid order id (named after the retired Binance field). */
+  binanceOrderId: z2.number().int().nonnegative().nullish(),
+  clientOrderId: z2.string().nullish(),
+  symbol: z2.string(),
+  side: protectiveOrderSideSchema,
+  positionSide: protectiveOrderPositionSideSchema.nullish().transform((value) => value ?? "BOTH"),
+  status: z2.string(),
+  kind: protectiveOrderKindSchema,
+  groupId: z2.string().nullish(),
+  stopPrice: z2.union([z2.string(), z2.number()]).nullish().transform((value) => value == null ? value : String(value)),
+  parentClientOrderId: z2.string().nullish(),
+  assetId: z2.number().int().nonnegative().nullish(),
+  createdAt: z2.string().nullish()
+});
+var portfolioSnapshotSchema = z2.object({
+  provider: z2.literal("hyperliquid"),
+  totalBalance: z2.number(),
+  availableBalance: z2.number(),
+  totalMargin: z2.number(),
+  unrealizedPnl: z2.number(),
+  positions: z2.array(openPositionSchema),
+  /** Unreadable entries are dropped (see readProtectiveOrders) rather than failing the read. */
+  protectiveOrders: z2.array(protectiveOrderSchema)
+});
+var portfolioInputSchema = z2.object({
+  provider: providerSchema
+});
+var ledgerWindowSchema = z2.enum(["24h", "7d", "30d"]);
+var ledgerFillsInputSchema = z2.object({
+  window: ledgerWindowSchema.optional(),
+  limit: z2.number().int().positive().max(200).optional(),
+  before: z2.number().int().nonnegative().optional()
+});
+var ledgerFillSchema = z2.object({
+  coin: z2.string(),
+  px: z2.number(),
+  sz: z2.number(),
+  side: z2.enum(["B", "A"]),
+  time: z2.number().int().nonnegative(),
+  dir: z2.string(),
+  closedPnl: z2.number(),
+  fee: z2.number(),
+  crossed: z2.boolean(),
+  oid: z2.number().int().nonnegative(),
+  tid: z2.number().int().nonnegative()
+});
+var ledgerFillsPageSchema = z2.object({
+  window: ledgerWindowSchema,
+  limit: z2.number().int().positive(),
+  before: z2.number().int().nonnegative().optional(),
+  hasMore: z2.boolean(),
+  nextBefore: z2.number().int().nonnegative().optional(),
+  fetchedAt: z2.string().datetime(),
+  fills: z2.array(ledgerFillSchema)
+});
+var ledgerPeriodSummarySchema = z2.object({
+  realizedPnl: z2.number(),
+  totalFees: z2.number(),
+  fillCount: z2.number().int().nonnegative(),
+  closeCount: z2.number().int().nonnegative(),
+  winCount: z2.number().int().nonnegative(),
+  lossCount: z2.number().int().nonnegative(),
+  averageWin: z2.number(),
+  averageLoss: z2.number()
+});
+var ledgerSummaryInputSchema = z2.object({
+  window: ledgerWindowSchema.optional()
+});
+var ledgerSummarySchema = ledgerPeriodSummarySchema.extend({
+  window: ledgerWindowSchema,
+  generatedAt: z2.string().datetime(),
+  periods: z2.object({
+    "24h": ledgerPeriodSummarySchema,
+    "7d": ledgerPeriodSummarySchema
+  })
+});
+var marketSnapshotScopeSchema = z2.enum(["selected", "all"]);
+var marketSnapshotResolvedScopeSchema = z2.enum(["selected", "all", "explicit"]);
+var marketSnapshotValueSchema = z2.union([z2.string(), z2.number(), z2.boolean(), z2.null()]);
+var marketSnapshotInputSchema = z2.object({
+  scope: marketSnapshotScopeSchema.optional(),
+  symbols: z2.array(z2.string().min(1)).min(1).optional(),
+  fields: z2.array(z2.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: z2.enum(["rank"]).optional().describe('"rank" orders rows by market cap rank, unranked last.')
+});
+var marketSnapshotChunkInputSchema = marketSnapshotInputSchema.extend({
+  offset: z2.number().int().nonnegative().optional(),
+  limit: z2.number().int().positive().max(100).optional()
+});
+var marketFieldBlockSchema = z2.object({
+  fieldIds: z2.array(z2.string()).min(1),
+  values: z2.array(marketSnapshotValueSchema),
+  symbolLists: z2.record(z2.string(), z2.array(z2.string())).optional()
+});
+var marketMatrixSchema = z2.object({
+  fieldIds: z2.array(z2.string()).min(1),
+  rows: z2.array(z2.array(marketSnapshotValueSchema))
+});
+var marketFieldSemanticsSchema = z2.object({
+  nullMeans: z2.literal("unavailable"),
+  percentScale: z2.literal("already_percent"),
+  percentFields: z2.array(z2.string()).min(1),
+  changeMapPercentKeys: z2.array(z2.string()).min(1)
+});
+var marketSnapshotSchema = z2.object({
+  schema: z2.literal("helios.market_snapshot.v1"),
+  view: z2.literal("market_overview"),
+  scope: marketSnapshotResolvedScopeSchema,
+  symbolCount: z2.number().int().nonnegative(),
+  generatedAt: z2.string().datetime(),
+  returnedSymbols: z2.array(z2.string()),
+  semantics: marketFieldSemanticsSchema,
+  market: marketFieldBlockSchema,
+  table: marketMatrixSchema,
+  legend: z2.record(z2.string(), z2.union([z2.string(), z2.array(z2.string())]))
+});
+var marketSnapshotChunkSchema = z2.object({
+  schema: z2.literal("helios.market_snapshot_chunk.v1"),
+  view: z2.literal("market_overview_chunk"),
+  scope: marketSnapshotResolvedScopeSchema,
+  totalSymbolCount: z2.number().int().nonnegative(),
+  generatedAt: z2.string().datetime(),
+  offset: z2.number().int().nonnegative(),
+  limit: z2.number().int().positive(),
+  chunkSymbolCount: z2.number().int().nonnegative(),
+  hasMore: z2.boolean(),
+  nextOffset: z2.number().int().nonnegative().optional(),
+  returnedSymbols: z2.array(z2.string()),
+  semantics: marketFieldSemanticsSchema,
+  market: marketFieldBlockSchema,
+  table: marketMatrixSchema,
+  legend: z2.record(z2.string(), z2.union([z2.string(), z2.array(z2.string())]))
+});
+var marketSymbolDetailInputSchema = z2.object({
+  symbol: z2.string().min(1),
+  full: z2.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 = z2.object({
+  schema: z2.literal("helios.market_symbol_detail.v1"),
+  generatedAt: z2.string().datetime(),
+  symbol: z2.string(),
+  semantics: marketFieldSemanticsSchema,
+  market: marketFieldBlockSchema,
+  row: z2.record(z2.string(), marketSnapshotValueSchema),
+  symbolCtx: z2.record(z2.string(), marketSnapshotValueSchema),
+  changeMap: z2.record(z2.string(), z2.number().nullable()),
+  metrics: z2.record(z2.string(), z2.unknown()).nullable(),
+  legend: z2.record(z2.string(), z2.union([z2.string(), z2.array(z2.string())]))
+});
+var tradingDirectionSchema = z2.enum(["LONG", "SHORT"]);
+var tradingExecutionStyleSchema = z2.enum(["MARKET", "LIMIT_TAKER", "LIMIT_MAKER", "LIMIT_GTC"]);
+var tradingSizeSchema = z2.object({
+  mode: z2.enum(["MARGIN_USD", "BASE_QUANTITY"]),
+  value: z2.number().positive()
+});
+var tradingProtectionLegSchema = z2.object({
+  kind: z2.enum(["LIMIT", "MARKET"]),
+  triggerPrice: z2.number().positive(),
+  limitPrice: z2.number().positive().optional()
+});
+var tradingProtectionSchema = z2.object({
+  takeProfit: tradingProtectionLegSchema.optional(),
+  stopLoss: tradingProtectionLegSchema.optional()
+});
+var tradingSymbolSchema = z2.string().regex(/^(?:[a-zA-Z0-9]{1,10}:)?[a-zA-Z0-9]+(?:USDT)?$/);
+var tradeIntentTypeSchema = z2.enum(["OPEN", "DCA", "REVERSE", "CLOSE"]);
+var submitTradeIntentInputSchema = z2.object({
+  provider: providerSchema.optional(),
+  symbol: tradingSymbolSchema,
+  intentType: tradeIntentTypeSchema,
+  direction: tradingDirectionSchema,
+  size: tradingSizeSchema,
+  execution: z2.object({
+    style: tradingExecutionStyleSchema,
+    timeInForce: z2.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+    limitPrice: z2.number().positive().optional()
+  }),
+  maxSlippageBps: z2.number().int().nonnegative().max(1e3).optional(),
+  leverageOverride: z2.number().positive().optional(),
+  marginModeOverride: z2.enum(["ISOLATED", "CROSS"]).optional(),
+  reduceOnly: z2.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: z2.string().regex(/^[A-Za-z0-9_-]{8,64}$/).optional(),
+  /** With it, idempotencyKey is the order's fingerprint: repeats within this many seconds of the first are one order. */
+  idempotencyWindowSeconds: z2.number().int().min(10).max(600).optional()
+});
+var submitTradeIntentResultSchema = z2.object({
+  status: z2.literal("submitted"),
+  /** `replayed`: an earlier attempt of this action already placed the order; nothing new was sent. */
+  outcome: z2.enum(["placed", "replayed"]).optional(),
+  clientOrderId: z2.string().optional(),
+  orderStatus: z2.string().optional(),
+  /** TP/SL legs Hyperliquid refused while the entry went through: the position is open without them. */
+  rejectedProtection: z2.array(z2.object({ kind: z2.string(), reason: z2.string() })).optional(),
+  provider: providerSchema.optional(),
+  symbol: z2.string(),
+  intentType: tradeIntentTypeSchema,
+  direction: tradingDirectionSchema,
+  size: tradingSizeSchema,
+  execution: z2.object({
+    style: tradingExecutionStyleSchema,
+    timeInForce: z2.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+    limitPrice: z2.number().positive().optional()
+  }),
+  maxSlippageBps: z2.number().int().nonnegative().max(1e3).optional(),
+  leverageOverride: z2.number().positive().optional(),
+  marginModeOverride: z2.enum(["ISOLATED", "CROSS"]).optional(),
+  reduceOnly: z2.boolean(),
+  hasProtection: z2.boolean()
+});
+var closePositionInputSchema = z2.object({
+  provider: providerSchema.optional(),
+  symbol: tradingSymbolSchema,
+  maxSlippageBps: z2.number().int().nonnegative().max(1e3).optional(),
+  /** The share of the position to close (0 < fraction < 1 closes part of it); omitted or 1 closes it all. */
+  fraction: z2.number().positive().max(1).optional()
+});
+var closePositionResultSchema = z2.object({
+  status: z2.literal("submitted"),
+  /** `no_position`: nothing was open on this coin, so no order was sent. Absent from older data-bridges. */
+  outcome: z2.enum(["closed", "no_position"]).optional(),
+  provider: providerSchema.optional(),
+  symbol: z2.string(),
+  mode: z2.enum(["FULL", "PARTIAL"]),
+  fraction: z2.number().positive().max(1).optional(),
+  maxSlippageBps: z2.number().int().nonnegative().max(1e3).optional()
+});
+var setTpSlInputSchema = z2.object({
+  provider: providerSchema.optional(),
+  symbol: tradingSymbolSchema,
+  applyTo: z2.enum(["FULL_POSITION", "CUSTOM_QUANTITY"]),
+  quantity: z2.number().positive().optional(),
+  parentClientOrderId: z2.string(),
+  takeProfit: tradingProtectionLegSchema.optional(),
+  stopLoss: tradingProtectionLegSchema.optional()
+});
+var setTpSlResultSchema = z2.object({
+  status: z2.literal("submitted"),
+  provider: providerSchema.optional(),
+  symbol: z2.string(),
+  applyTo: z2.enum(["FULL_POSITION", "CUSTOM_QUANTITY"]),
+  quantity: z2.number().positive().optional(),
+  parentClientOrderId: z2.string(),
+  hasTakeProfit: z2.boolean(),
+  hasStopLoss: z2.boolean()
+});
+var deleteTpSlInputSchema = z2.object({
+  provider: providerSchema.optional(),
+  symbol: tradingSymbolSchema,
+  orderId: z2.string()
+});
+var deleteTpSlResultSchema = z2.object({
+  status: z2.literal("deleted"),
+  provider: providerSchema.optional(),
+  symbol: z2.string(),
+  orderId: z2.string()
+});
+var openOrderSchema = z2.object({
+  coin: z2.string(),
+  side: z2.enum(["B", "A"]),
+  limitPx: z2.string(),
+  sz: z2.string(),
+  oid: z2.number().int().nonnegative(),
+  timestamp: z2.number().int().nonnegative(),
+  origSz: z2.string(),
+  orderType: z2.string(),
+  tif: z2.string().nullable(),
+  reduceOnly: z2.boolean(),
+  isTrigger: z2.boolean(),
+  triggerPx: z2.string(),
+  cloid: z2.string().nullable(),
+  assetId: z2.number().int().nonnegative().optional()
+});
+var cancelOrderInputSchema = z2.object({
+  symbol: tradingSymbolSchema,
+  oid: z2.number().int().nonnegative()
+});
+var cancelOrderResultSchema = z2.object({
+  status: z2.literal("cancelled"),
+  symbol: z2.string(),
+  oid: z2.number().int().nonnegative()
+});
+var modifyOrderInputSchema = z2.object({
+  symbol: tradingSymbolSchema,
+  oid: z2.number().int().nonnegative(),
+  price: z2.number().positive().finite(),
+  /** Size in the coin (base quantity). */
+  size: z2.number().positive().finite()
+});
+var modifyOrderResultSchema = z2.object({
+  status: z2.literal("modified"),
+  symbol: z2.string(),
+  oid: z2.number().int().nonnegative(),
+  price: z2.number(),
+  size: z2.number()
+});
+var AGENT_PAPER_ACCOUNT = "agent";
+var paperFillSchema = z2.object({
+  ts: z2.number(),
+  coin: z2.string(),
+  kind: z2.string(),
+  side: z2.enum(["BUY", "SELL"]).nullable(),
+  size: z2.number(),
+  price: z2.number(),
+  fee: z2.number(),
+  pnl: z2.number()
+});
+var paperPortfolioSchema = portfolioSnapshotSchema.extend({
+  cash: z2.number().optional(),
+  realizedPnl: z2.number().optional(),
+  feesPaid: z2.number().optional(),
+  fundingPaid: z2.number().optional(),
+  liquidations: z2.number().optional()
+});
+var agentSetupSchema = z2.enum(["turning up from breakdown", "falling, no turn yet", "stretched up", "stretched down", "neutral"]);
+var smSideNameSchema = z2.enum(["long", "short"]);
+var agentMarketInputSchema = z2.object({
+  coins: z2.array(z2.string().min(1)).min(1).max(50).optional(),
+  limit: z2.number().int().min(1).max(300).optional(),
+  offset: z2.number().int().nonnegative().optional(),
+  sort: z2.enum(["volume", "rank", "move1h", "move24h", "funding", "lean", "edge"]).optional(),
+  filter: z2.enum(["turning", "falling", "stretched_up", "stretched_down", "sm_long", "sm_short", "discount"]).optional()
+});
+var agentMarketRowSchema = z2.object({
+  coin: z2.string(),
+  rank: z2.number().nullable(),
+  px: z2.number().nullable(),
+  r15m: z2.number().nullable(),
+  r1h: z2.number().nullable(),
+  r24h: z2.number().nullable(),
+  volUsd: z2.number().nullable(),
+  fundAprPct: z2.number().nullable(),
+  oiUsd: z2.number().nullable(),
+  setup: agentSetupSchema.nullable()
+});
+var agentMarketSchema = z2.object({
+  asOf: z2.string().nullable(),
+  smAsOf: z2.number().nullable(),
+  market: z2.object({ os: z2.number().nullable(), mti: z2.number().nullable(), Mti: z2.number().nullable() }),
+  total: z2.number().int().nonnegative(),
+  offset: z2.number().int().nonnegative(),
+  rows: z2.array(
+    agentMarketRowSchema.extend({
+      sm: z2.object({
+        side: smSideNameSchema.nullable(),
+        share: z2.number(),
+        edgePct: z2.number().nullable(),
+        discount: z2.enum(["strict", "fill"]).nullable()
+      }).nullable()
+    })
+  ),
+  next: z2.number().int().nonnegative().nullable(),
+  unknown: z2.array(z2.string())
+});
+var smPileInSchema = z2.object({
+  coin: z2.string(),
+  side: smSideNameSchema,
+  dir: z2.enum(["in", "out"]),
+  traders: z2.number(),
+  totalUsd: z2.number(),
+  weight: z2.number(),
+  names: z2.array(z2.string()),
+  first: z2.number(),
+  last: z2.number()
+});
+var smartMoneyBoardInputSchema = z2.object({
+  view: z2.enum(["conviction", "discount", "flows", "pileins"]).optional(),
+  side: z2.enum(["long", "short", "any"]).optional(),
+  limit: z2.number().int().min(1).max(25).optional()
+});
+var smartMoneyBoardSchema = z2.object({
+  asOf: z2.number().nullable(),
+  view: z2.enum(["conviction", "discount", "flows", "pileins"]),
+  wallets: z2.number(),
+  known: z2.number(),
+  rows: z2.array(
+    z2.object({
+      coin: z2.string(),
+      side: smSideNameSchema.nullable(),
+      share: z2.number(),
+      lean: z2.number(),
+      sideUsd: z2.number(),
+      heads: z2.number(),
+      traders: z2.number(),
+      entry: z2.number().nullable(),
+      mark: z2.number().nullable(),
+      edgePct: z2.number().nullable(),
+      flow1hUsd: z2.number(),
+      discount: z2.enum(["strict", "fill"]).nullable(),
+      setup: agentSetupSchema.nullable(),
+      r24h: z2.number().nullable()
+    })
+  ),
+  pileIns: z2.array(smPileInSchema),
+  note: z2.string().nullable()
+});
+var smartMoneyMovesInputSchema = z2.object({
+  since: z2.string().regex(/^\d{1,16}-\d{1,16}$/).optional(),
+  coin: z2.string().min(1).optional(),
+  kind: z2.enum(["entries", "exits", "all"]).optional(),
+  minUsd: z2.number().nonnegative().optional(),
+  limit: z2.number().int().min(1).max(50).optional()
+});
+var smMoveSchema = z2.object({
+  id: z2.string(),
+  t: z2.number(),
+  coin: z2.string(),
+  kind: z2.enum(["open", "add", "reduce", "close", "flip"]),
+  side: smSideNameSchema,
+  usd: z2.number(),
+  px: z2.number(),
+  lev: z2.number().nullable(),
+  pnl: z2.number().nullable(),
+  pnlPct: z2.number().nullable(),
+  nick: z2.string(),
+  rank: z2.number(),
+  style: z2.string(),
+  win: z2.number().nullable(),
+  w: z2.number()
+});
+var smartMoneyMovesSchema = z2.object({
+  order: z2.enum(["newest", "oldest"]),
+  moves: z2.array(smMoveSchema),
+  next: z2.string().nullable(),
+  more: z2.boolean(),
+  gap: z2.boolean(),
+  note: z2.string().nullable()
+});
+var smBookSideSchema = z2.object({ usd: z2.number(), heads: z2.number(), traders: z2.number(), entry: z2.number().nullable() });
+var smartMoneyCoinSchema = z2.object({
+  coin: z2.string(),
+  asOf: z2.number().nullable(),
+  sm: z2.object({
+    coin: z2.string(),
+    mark: z2.number().nullable(),
+    long: smBookSideSchema,
+    short: smBookSideSchema,
+    lean: z2.number(),
+    side: smSideNameSchema.nullable(),
+    share: z2.number(),
+    edgePct: z2.number().nullable(),
+    flow1hUsd: z2.number(),
+    conviction: z2.number().nullable(),
+    discount: z2.enum(["strict", "fill"]).nullable(),
+    pileIn: smPileInSchema.nullable()
+  }).nullable(),
+  market: agentMarketRowSchema.nullable(),
+  moves: z2.array(smMoveSchema),
+  note: z2.string().nullable()
+});
+var marketCandlesInputSchema = z2.object({
+  symbol: z2.string().regex(/^[A-Za-z0-9]{1,20}$/),
+  interval: z2.enum(["1m", "3m", "5m", "15m", "30m", "1h", "2h", "4h", "6h", "8h", "12h", "1d", "1w", "1M"]),
+  endTime: z2.number().int().positive().optional(),
+  limit: z2.number().int().min(1).max(10080).optional()
+});
+var marketCandlesSchema = z2.object({
+  candles: z2.array(z2.object({ t: z2.number(), o: z2.number(), h: z2.number(), l: z2.number(), c: z2.number(), v: z2.number() })),
+  complete: z2.boolean()
+});
+var DEFAULT_AGENT_REFRESH_WINDOW_MS = 60 * 1e3;
+var agentConnectionStatusSchema = z3.enum([
+  "disconnected",
+  "pending",
+  "connected",
+  "rejected",
+  "expired",
+  "failed"
+]);
+var agentSessionIssuerSchema = z3.object({
+  identityServiceUrl: z3.string(),
+  dataBridgeUrl: z3.string()
+});
+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(),
+  issuer: agentSessionIssuerSchema.nullish()
+});
+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;
+}
+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 DEFAULT_SCOPE = [AGENT_SCOPES.ACCOUNT_READ, AGENT_SCOPES.MARKET_READ];
+var AgentAuthService = class {
+  constructor(options) {
+    __publicField2(this, "client");
+    __publicField2(this, "sessionStore");
+    __publicField2(this, "messages");
+    __publicField2(this, "refreshWindowMs");
+    __publicField2(this, "now");
+    __publicField2(this, "defaultClientName");
+    __publicField2(this, "deviceLogin");
+    __publicField2(this, "reloginForMissingScope");
+    __publicField2(this, "refreshInFlight", null);
+    __publicField2(this, "exchangeInFlight", null);
+    this.client = options.client;
+    this.sessionStore = options.sessionStore;
+    this.messages = options.messages;
+    this.refreshWindowMs = options.refreshWindowMs ?? DEFAULT_AGENT_REFRESH_WINDOW_MS;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.defaultClientName = options.defaultClientName;
+    this.deviceLogin = options.deviceLogin ?? true;
+    this.reloginForMissingScope = options.reloginForMissingScope ?? false;
+  }
+  async startLogin(input) {
+    if (!this.deviceLogin) {
+      throw new Error(this.messages.reconnect);
+    }
+    const response = await this.client.startLogin(input);
+    const result = {
+      status: "pending",
+      ...response,
+      requestedScope: input.scope,
+      startedAt: this.now().toISOString()
+    };
+    await this.sessionStore.setPendingLogin(result);
+    return result;
+  }
+  async resetSessionAndStartLogin(input) {
+    await this.clearSessionState();
+    return this.startLogin(input);
+  }
+  async startRelogin(options = {}) {
+    const started = await this.resetSessionAndStartLogin(this.loginInput(options));
+    return this.pendingResult(started);
+  }
+  async clearSessionState() {
+    await this.sessionStore.clearSession();
+    await this.sessionStore.clearPendingLogin();
+  }
+  /** After a 401 from Helios: drops the session and starts a fresh login. Null for any other error. */
+  async invalidateIfUnauthorized(error, options = {}) {
+    if (!isHeliosAgentApiError(error) || error.status !== 401) {
+      return null;
+    }
+    return this.startRelogin(options);
+  }
+  /** After a 401 from Helios: refreshes the session even if it isn't near expiry. Null for any other error. */
+  async refreshSessionAfterUnauthorized(error) {
+    if (!isHeliosAgentApiError(error) || error.status !== 401) {
+      return null;
+    }
+    const session = await this.sessionStore.getSession();
+    return session ? this.refreshStoredSession(session, true) : null;
+  }
+  async ensureLogin(options = {}) {
+    const requestedScope = options.scope ?? DEFAULT_SCOPE;
+    const requestedConstraints = options.constraints ?? {};
+    const session = await this.getValidSession();
+    if (session) {
+      if (!this.reloginForMissingScope || hasScopes(session, requestedScope)) {
+        return connectedResult(session);
+      }
+      await this.sessionStore.clearSession();
+    }
+    const pendingLogin = await this.getPendingLogin(requestedScope, requestedConstraints);
+    if (pendingLogin) {
+      const polled = await this.exchangePendingLogin(pendingLogin.deviceCode).catch(() => null);
+      if (polled?.status === "connected") return polled;
+      const stillPending = await this.getPendingLogin(requestedScope, requestedConstraints);
+      if (stillPending) return this.pendingResult(stillPending);
+    }
+    return this.pendingResult(await this.startLogin(this.loginInput(options)));
+  }
+  /**
+   * Polls the stored pending login. A code, when given, must be that login's device code or the user code shown to the
+   * person: a code from anywhere else (a prompt injection carrying a login someone else approved) is never exchanged, so
+   * it can't swap the stored session for another account's.
+   */
+  async pollLogin(code) {
+    const pending = await this.sessionStore.getPendingLogin();
+    if (!pending) {
+      const session = await this.getValidSession();
+      if (session) return connectedResult(session);
+      return { status: "failed", connected: false, message: this.messages.noLoginInProgress };
+    }
+    const given = code?.trim();
+    if (given && given !== pending.deviceCode && given.toUpperCase() !== pending.userCode.toUpperCase()) {
+      return { status: "failed", connected: false, message: this.messages.wrongCode };
+    }
+    return this.exchangePendingLogin(pending.deviceCode);
+  }
+  async whoami() {
+    return sanitizeAgentSession(await this.getValidSession());
+  }
+  async getAccessToken() {
+    return (await this.getValidSession())?.accessToken ?? null;
+  }
+  async getPendingLoginState() {
+    return this.sessionStore.getPendingLogin();
+  }
+  async requireSession() {
+    const session = await this.getValidSession();
+    if (!session) {
+      throw new Error(this.deviceLogin ? "No Helios delegated agent session is connected" : this.messages.reconnect);
+    }
+    return session;
+  }
+  loginInput(options) {
+    return {
+      clientName: options.clientName ?? this.defaultClientName,
+      scope: options.scope ?? DEFAULT_SCOPE,
+      constraints: options.constraints
+    };
+  }
+  pendingResult(started) {
+    return { ...started, connected: false, message: this.messages.loginPrompt(started) };
+  }
+  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, false);
+  }
+  /**
+   * Refreshes `seen` (the session the caller read), joining a refresh already in progress. `force` refreshes even a
+   * session that isn't near expiry (Helios just answered 401 to it).
+   */
+  refreshStoredSession(seen, force) {
+    this.refreshInFlight ?? (this.refreshInFlight = this.refreshOnce(seen, force).finally(() => {
+      this.refreshInFlight = null;
+    }));
+    return this.refreshInFlight;
+  }
+  async refreshOnce(seen, force) {
+    const latest = await this.sessionStore.getSession();
+    if (!latest) {
+      return null;
+    }
+    const rotatedElsewhere = latest.refreshToken !== seen.refreshToken;
+    if ((rotatedElsewhere || !force) && !shouldRefreshAgentSession(latest, this.now(), this.refreshWindowMs)) {
+      return latest;
+    }
+    if (!latest.refreshToken) {
+      return null;
+    }
+    try {
+      const refreshed = await this.client.refreshSession(latest.refreshToken);
+      const nextSession = createStoredAgentSession(refreshed, this.now());
+      await this.sessionStore.setSession(nextSession);
+      return nextSession;
+    } catch (error) {
+      const stored = await this.sessionStore.getSession().catch(() => null);
+      if (stored && stored.refreshToken !== latest.refreshToken) {
+        return stored;
+      }
+      if (isHeliosAgentApiError(error) && error.code === "invalid_grant") {
+        await this.clearSessionState();
+        return null;
+      }
+      throw error;
+    }
+  }
+  exchangePendingLogin(deviceCode) {
+    if (this.exchangeInFlight?.deviceCode !== deviceCode) {
+      const flight = {
+        deviceCode,
+        promise: this.exchangeOnce(deviceCode).finally(() => {
+          if (this.exchangeInFlight === flight) this.exchangeInFlight = null;
+        })
+      };
+      this.exchangeInFlight = flight;
+    }
+    return this.exchangeInFlight.promise;
+  }
+  async exchangeOnce(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 connectedResult(session);
+    } catch (error) {
+      if (!isHeliosAgentApiError(error)) {
+        return {
+          status: "failed",
+          connected: false,
+          message: error instanceof Error ? error.message : "Unexpected Helios login error"
+        };
+      }
+      switch (error.code) {
+        case "authorization_pending":
+          return { status: "pending", connected: false, message: error.message };
+        case "access_denied":
+          await this.clearPendingLoginIfMatches(deviceCode);
+          return { status: "rejected", connected: false, message: error.message };
+        case "expired_token":
+          await this.clearPendingLoginIfMatches(deviceCode);
+          return { status: "expired", connected: false, message: error.message };
+        case "invalid_grant":
+          await this.clearPendingLoginIfMatches(deviceCode);
+          return { status: "failed", connected: false, message: this.messages.staleLogin };
+        default:
+          return { status: "failed", connected: false, message: error.message };
+      }
+    }
+  }
+  async getPendingLogin(requestedScope, requestedConstraints) {
+    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;
+    }
+    const pendingScope = new Set(pendingLogin.requestedScope);
+    if (!requestedScope.every((scope) => pendingScope.has(scope))) {
+      return null;
+    }
+    return Object.keys(requestedConstraints ?? {}).length === 0 ? pendingLogin : null;
+  }
+  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 connectedResult(session) {
+  return { ...sanitizeAgentSession(session), connected: true, status: "connected" };
+}
+function hasScopes(session, requestedScope) {
+  const granted = new Set(session.scope);
+  return requestedScope.every((scope) => granted.has(scope));
+}
+var HeliosAgentAuthClient = class {
+  constructor(options) {
+    __publicField2(this, "baseUrl");
+    __publicField2(this, "fetchImpl");
+    __publicField2(this, "headers");
+    __publicField2(this, "startSecret");
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.fetchImpl = options.fetch ?? fetch;
+    this.headers = options.headers ?? {};
+    this.startSecret = options.startSecret || void 0;
+  }
+  async startLogin(input, options = {}) {
+    const parsed = agentDeviceStartInputSchema.parse(input);
+    const headers = this.startSecret ? { [AGENT_START_SECRET_HEADER]: this.startSecret, ...options.clientIp ? { [AGENT_CLIENT_IP_HEADER]: options.clientIp } : {} } : void 0;
+    return this.post("/api/agents/device/start", parsed, agentDeviceStartOutputSchema, headers);
+  }
+  async exchangeDeviceCode(deviceCode, options = {}) {
+    const parsed = agentDeviceTokenInputSchema.parse({ deviceCode, approvalProof: options.approvalProof });
+    return this.post("/api/agents/device/token", parsed, agentTokenResponseSchema);
+  }
+  async refreshSession(refreshToken) {
+    const parsed = agentRefreshInputSchema.parse({ refreshToken });
+    return this.post("/api/agents/auth/refresh", parsed, agentTokenResponseSchema);
+  }
+  async post(path4, body, schema, extraHeaders) {
+    let response;
+    try {
+      response = await this.fetchImpl(`${this.baseUrl}${path4}`, {
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/json",
+          ...this.headers,
+          ...extraHeaders
+        },
+        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 text2 = await response.text();
+    if (!text2) {
+      return null;
+    }
+    try {
+      return JSON.parse(text2);
+    } 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));
+  }
+  /** The lean market table: price, two returns, volume, funding, open interest, setup label and the smart money lean. */
+  async getAgentMarket(accessToken, input = {}) {
+    const payload = await this.request(accessToken, "market.getAgentTable", agentMarketInputSchema.parse(input));
+    return agentMarketSchema.parse(this.unwrapResult(payload));
+  }
+  async getMarketCandles(accessToken, input) {
+    const payload = await this.request(accessToken, "market.getCandles", marketCandlesInputSchema.parse(input));
+    return marketCandlesSchema.parse(this.unwrapResult(payload));
+  }
+  /** The research wallets' smart money board (conviction, discount, flows or pile-ins). */
+  async getSmartMoneyBoard(accessToken, input = {}) {
+    const payload = await this.request(accessToken, "smartMoney.board", smartMoneyBoardInputSchema.parse(input));
+    return smartMoneyBoardSchema.parse(this.unwrapResult(payload));
+  }
+  /** Their trades by nickname: the latest, or only what came after an earlier call's `next`. */
+  async getSmartMoneyMoves(accessToken, input = {}) {
+    const payload = await this.request(accessToken, "smartMoney.moves", smartMoneyMovesInputSchema.parse(input));
+    return smartMoneyMovesSchema.parse(this.unwrapResult(payload));
+  }
+  /** One coin: their book, its market row and their latest trades on it. */
+  async getSmartMoneyCoin(accessToken, coin2) {
+    const payload = await this.request(accessToken, "smartMoney.coin", { coin: coin2 });
+    return smartMoneyCoinSchema.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 partial = parsedInput.fraction !== void 0 && parsedInput.fraction < 1;
+    const payload = await this.request(
+      accessToken,
+      "positions.close",
+      {
+        ...parsedInput.provider !== void 0 ? { provider: parsedInput.provider } : {},
+        symbol: parsedInput.symbol,
+        mode: partial ? "PARTIAL" : "FULL",
+        ...partial ? { fraction: parsedInput.fraction } : {},
+        ...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: partial ? "PARTIAL" : "FULL",
+      ...partial ? { fraction: parsedInput.fraction } : {},
+      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 modifyOrder(accessToken, input) {
+    const parsedInput = modifyOrderInputSchema.parse(input);
+    await this.request(accessToken, "positions.modifyOrder", parsedInput, "POST");
+    return modifyOrderResultSchema.parse({ status: "modified", ...parsedInput });
+  }
+  // ---------------------------------------------------------------- paper (AGENT_PAPER_ACCOUNT unless told otherwise)
+  async getPaperPortfolio(accessToken, accountId = AGENT_PAPER_ACCOUNT) {
+    const payload = await this.request(accessToken, "paper.getPortfolio", { accountId, fills: 0 });
+    return paperPortfolioSchema.parse(this.unwrapResult(payload));
+  }
+  /** A paper market order; answers with its fills (none when nothing filled). */
+  async submitPaperIntent(accessToken, input, accountId = AGENT_PAPER_ACCOUNT) {
+    const parsedInput = submitTradeIntentInputSchema.parse(input);
+    const payload = await this.request(accessToken, "paper.submitIntent", { ...parsedInput, accountId }, "POST");
+    return paperFillSchema.array().parse(this.tryUnwrapResult(payload) ?? []);
+  }
+  /** Closes all or part of a paper position; no fills when there was none. */
+  async closePaperPosition(accessToken, input, accountId = AGENT_PAPER_ACCOUNT) {
+    const parsedInput = closePositionInputSchema.parse(input);
+    const partial = parsedInput.fraction !== void 0 && parsedInput.fraction < 1;
+    const payload = await this.request(
+      accessToken,
+      "paper.close",
+      { symbol: parsedInput.symbol, mode: partial ? "PARTIAL" : "FULL", ...partial ? { fraction: parsedInput.fraction } : {}, accountId },
+      "POST"
+    );
+    return paperFillSchema.array().parse(this.tryUnwrapResult(payload) ?? []);
+  }
+  async setPaperTpSl(accessToken, input, accountId = AGENT_PAPER_ACCOUNT) {
+    const parsedInput = setTpSlInputSchema.parse(input);
+    await this.request(accessToken, "paper.setTpSl", { ...parsedInput, accountId }, "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 deletePaperTpSl(accessToken, input, accountId = AGENT_PAPER_ACCOUNT) {
+    const parsedInput = deleteTpSlInputSchema.parse(input);
+    await this.request(accessToken, "paper.deleteTpSl", { ...parsedInput, accountId }, "POST");
+    return deleteTpSlResultSchema.parse({ status: "deleted", provider: parsedInput.provider, symbol: parsedInput.symbol, orderId: parsedInput.orderId });
+  }
+  async getPaperLedgerFills(accessToken, input = {}, accountId = AGENT_PAPER_ACCOUNT) {
+    const parsedInput = ledgerFillsInputSchema.parse(input);
+    const payload = await this.request(accessToken, "paper.getLedgerFills", { ...parsedInput, accountId });
+    return ledgerFillsPageSchema.parse(this.unwrapResult(payload));
+  }
+  /** Starts the paper account over with `startingBalance` USD (data-bridge's default when omitted). */
+  async resetPaperAccount(accessToken, startingBalance, accountId = AGENT_PAPER_ACCOUNT) {
+    await this.request(accessToken, "paper.reset", { accountId, ...startingBalance ? { startingBalance } : {} }, "POST");
+  }
+  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 text2 = await response.text();
+    if (!text2) {
+      return null;
+    }
+    try {
+      return JSON.parse(text2);
+    } 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] : [];
+  });
+}
+
+// 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 extends AgentAuthService {
+  constructor(options) {
+    super({
+      ...options,
+      defaultClientName: "Helios MCP",
+      messages: {
+        loginPrompt: formatHeliosLoginPrompt,
+        noLoginInProgress: "No Helios login is in progress. Call helios_auth_ensure_login to start one.",
+        wrongCode: "That code is not the Helios login in progress. Call helios_auth_poll_login without a code to check it.",
+        staleLogin: "Helios no longer knows this login request. Call helios_auth_ensure_login to start a fresh one.",
+        reconnect: HOSTED_RECONNECT_MESSAGE
+      }
+    });
+  }
+};
+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.`;
+}
+
+// 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 { randomBytes } from "crypto";
+import { constants as fsConstants } from "fs";
+import { chmod, lstat, mkdir, open, rename, rm } from "fs/promises";
+import { homedir } from "os";
+import path3 from "path";
+import { z as z5 } from "zod";
+function getDefaultHeliosAgentMcpSessionPath() {
+  return path3.join(homedir(), ".helios-agent-mcp", "session.json");
+}
+var pendingAgentLoginSchema2 = pendingAgentLoginSchema.extend({
+  /** The hosts the login was started with (FileAgentSessionStoreOptions.issuer); its device code is only polled there. */
+  issuer: agentSessionIssuerSchema.nullish()
+});
+var mcpSessionStateSchema = z5.object({
+  session: storedAgentSessionSchema.nullish(),
+  pendingLogin: pendingAgentLoginSchema2.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 EMPTY_STATE = { session: null, pendingLogin: null, activeProvider: null };
+var FileAgentSessionStore = class {
+  constructor(filePath = getDefaultHeliosAgentMcpSessionPath(), options = {}) {
+    __publicField(this, "filePath", filePath);
+    __publicField(this, "issuer");
+    this.issuer = options.issuer ?? null;
+  }
+  async getSession() {
+    const { session } = await this.readState();
+    if (!session || !this.isFromIssuer(session.issuer)) return null;
+    const { issuer: _issuer, ...rest } = session;
+    return rest;
+  }
+  async getPendingLogin() {
+    const { pendingLogin } = await this.readState();
+    if (!pendingLogin || !this.isFromIssuer(pendingLogin.issuer)) return null;
+    const { issuer: _issuer, ...rest } = pendingLogin;
+    return rest;
+  }
+  async getActiveProvider() {
+    return (await this.readState()).activeProvider;
+  }
+  async setSession(session) {
+    await this.update((state) => ({
+      ...state,
+      session: this.issuer ? { ...session, issuer: this.issuer } : session
+    }));
+  }
+  async setPendingLogin(pendingLogin) {
+    await this.update((state) => ({
+      ...state,
+      pendingLogin: this.issuer ? { ...pendingLogin, issuer: this.issuer } : pendingLogin
+    }));
+  }
+  async setActiveProvider(activeProvider) {
+    await this.update((state) => ({
+      ...state,
+      activeProvider
+    }));
+  }
+  async clearSession() {
+    await this.update((state) => ({ ...state, session: null }), { deleteWhenEmpty: true });
+  }
+  async clearPendingLogin() {
+    await this.update((state) => ({ ...state, pendingLogin: null }), { deleteWhenEmpty: true });
+  }
+  async clearActiveProvider() {
+    await this.update((state) => ({ ...state, activeProvider: null }), { deleteWhenEmpty: true });
+  }
+  isFromIssuer(issuer) {
+    return !this.issuer || isSameHeliosIssuer(issuer, this.issuer);
+  }
+  /**
+   * Read-modify-write under the file's lock: tool calls run concurrently and several MCP processes can share the file,
+   * so without it one write could drop another's (a refreshed session, a pending login).
+   */
+  async update(change, options = {}) {
+    await withSessionFileLock(this.filePath, async () => {
+      const state = change(await this.readState());
+      if (options.deleteWhenEmpty && !state.session && !state.pendingLogin && !state.activeProvider) {
+        await this.deleteFile();
+        return;
+      }
+      await this.writeState(state);
+    });
+  }
+  async readState() {
+    let parsed;
+    try {
+      parsed = JSON.parse(await readFileNoFollow(this.filePath));
+    } catch (error) {
+      if (isErrnoException(error, "ENOENT") || isErrnoException(error, "ELOOP") || error instanceof SyntaxError) {
+        return { ...EMPTY_STATE };
+      }
+      throw error;
+    }
+    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 { ...EMPTY_STATE };
+  }
+  async writeState(state) {
+    const directory = path3.dirname(this.filePath);
+    await mkdir(directory, { recursive: true, mode: 448 });
+    if (path3.resolve(directory) === path3.dirname(getDefaultHeliosAgentMcpSessionPath())) {
+      await chmod(directory, 448).catch(() => void 0);
+    }
+    const tempPath = `${this.filePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+    const handle = await open(tempPath, "wx", 384);
+    try {
+      try {
+        await handle.writeFile(`${JSON.stringify(state, null, 2)}
+`, "utf8");
+        await handle.chmod(384);
+        await handle.sync();
+      } finally {
+        await handle.close();
+      }
+      await rename(tempPath, this.filePath);
+    } catch (error) {
+      await rm(tempPath, { force: true }).catch(() => void 0);
+      throw error;
+    }
+  }
+  async deleteFile() {
+    try {
+      await rm(this.filePath, { force: true });
+    } catch (error) {
+      if (!isErrnoException(error, "ENOENT")) {
+        throw error;
+      }
+    }
+  }
+};
+var MemoryAgentMcpSessionStore = class {
+  constructor(session = null, activeProvider = "hyperliquid") {
+    __publicField(this, "session", session);
+    __publicField(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 isErrnoException(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+async function readFileNoFollow(filePath) {
+  const flags = process.platform === "win32" || fsConstants.O_NOFOLLOW === void 0 ? "r" : fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW;
+  const handle = await open(filePath, flags);
+  try {
+    return await handle.readFile("utf8");
+  } finally {
+    await handle.close();
+  }
+}
+var sessionFileQueues = /* @__PURE__ */ new Map();
+var LOCK_FILE_STALE_MS = 1e4;
+var LOCK_FILE_WAIT_MS = 2e3;
+async function withSessionFileLock(filePath, task) {
+  const key = path3.resolve(filePath);
+  const previous = sessionFileQueues.get(key) ?? Promise.resolve();
+  let release;
+  const done = new Promise((resolve) => release = resolve);
+  const queued = previous.then(() => done);
+  sessionFileQueues.set(key, queued);
+  await previous;
+  try {
+    const locked = await acquireLockFile(`${key}.lock`);
+    try {
+      return await task();
+    } finally {
+      if (locked) await rm(`${key}.lock`, { force: true }).catch(() => void 0);
+    }
+  } finally {
+    release();
+    if (sessionFileQueues.get(key) === queued) sessionFileQueues.delete(key);
+  }
+}
+async function acquireLockFile(lockPath) {
+  const deadline = Date.now() + LOCK_FILE_WAIT_MS;
+  for (; ; ) {
+    try {
+      await (await open(lockPath, "wx", 384)).close();
+      return true;
+    } catch (error) {
+      if (!isErrnoException(error, "EEXIST")) return false;
+    }
+    const stats = await lstat(lockPath).catch(() => null);
+    if (stats && Date.now() - stats.mtimeMs > LOCK_FILE_STALE_MS) {
+      await rm(lockPath, { force: true }).catch(() => void 0);
+      continue;
+    }
+    if (Date.now() >= deadline) return false;
+    await new Promise((resolve) => setTimeout(resolve, 20 + Math.floor(Math.random() * 30)));
+  }
+}
+
+// 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/lean/format.ts
+var usd = (v, signed = false) => {
+  if (v === null || v === void 0 || !Number.isFinite(v)) return "n/a";
+  const sign = v < 0 ? "-" : signed && v > 0 ? "+" : "";
+  const a = Math.abs(v);
+  const body = a >= 1e9 ? `${trim(a / 1e9, 2)}B` : a >= 1e6 ? `${trim(a / 1e6, 2)}M` : a >= 1e4 ? `${Math.round(a / 1e3)}k` : a >= 1e3 ? `${trim(a / 1e3, 1)}k` : `${Math.round(a)}`;
+  return `${sign}$${body}`;
+};
+var trim = (v, places) => String(Number(v.toFixed(places)));
+var pct = (v, places = 1) => v === null || v === void 0 || !Number.isFinite(v) ? "n/a" : `${v > 0 ? "+" : ""}${v.toFixed(places)}%`;
+var price = (v) => {
+  if (v === null || v === void 0 || !Number.isFinite(v)) return "n/a";
+  const a = Math.abs(v);
+  if (a >= 1e3) return v.toLocaleString("en-US", { maximumFractionDigits: a >= 1e4 ? 0 : 2 });
+  if (a >= 1) return v.toFixed(a >= 100 ? 2 : a >= 10 ? 2 : 3);
+  return v.toPrecision(4);
+};
+var ago = (t, now) => {
+  if (t === null || t === void 0) return "n/a";
+  const s = Math.max(0, Math.round((now - t) / 1e3));
+  if (s < 60) return `${s}s`;
+  if (s < 3600) return `${Math.round(s / 60)}m`;
+  if (s < 172800) return `${Math.round(s / 3600)}h`;
+  return `${Math.round(s / 86400)}d`;
+};
+var STYLE = {
+  scalper: "scalper",
+  "intraday trader": "intraday",
+  "swing trader": "swing",
+  "position trader": "position"
+};
+var trader = (m) => {
+  const tags = [STYLE[m.style], m.win === null ? null : `${Math.round(m.win)}% win`].filter(Boolean);
+  return `${m.nick} #${m.rank}${tags.length ? ` (${tags.join(", ")})` : ""}`;
+};
+var VERB = { open: "opened", add: "added", reduce: "trimmed", close: "closed", flip: "flipped to" };
+var moveText = (m) => {
+  const pnl = m.pnl === null ? "" : ` ${usd(m.pnl, true)}${m.pnlPct === null ? "" : ` (${pct(m.pnlPct)})`}`;
+  const lev = m.lev && (m.kind === "open" || m.kind === "add" || m.kind === "flip") ? ` ${trim(m.lev, 1)}x` : "";
+  return `${VERB[m.kind]} ${m.side} ${m.coin} ${usd(m.usd)} @ ${price(m.px)}${lev}${pnl}`;
+};
+var entryText = (side, edgePct) => {
+  if (!side || edgePct === null) return null;
+  const below = side === "long" ? edgePct >= 0 : edgePct < 0;
+  return `${Math.abs(edgePct).toFixed(1)}% ${below ? "under" : "over"} their entry`;
+};
+function renderMarket(m, now = Date.now()) {
+  const head = [`market \xB7 ${m.rows.length} of ${m.total}${m.offset ? ` from #${m.offset + 1}` : ""}`];
+  if (m.market.os !== null) head.push(`${m.market.os} of 23 large coins down >7% in 24h`);
+  if (m.market.Mti !== null) head.push(`majors trend ${pct(m.market.Mti, 2)}`);
+  if (m.asOf) head.push(`as of ${ago(Date.parse(m.asOf), now)} ago`);
+  const lines = [head.join(" \xB7 ")];
+  if (m.rows.length) {
+    lines.push("coin | price | 1h | 24h | vol 24h | funding APR | open interest | setup | top traders");
+    for (const r of m.rows) {
+      const sm = r.sm?.side ? [`${r.sm.side} ${Math.round(r.sm.share * 100)}%`, entryText(r.sm.side, r.sm.edgePct), r.sm.discount === "strict" ? "discount" : null].filter(Boolean).join(", ") : "none";
+      lines.push(
+        [r.coin, price(r.px), pct(r.r1h), pct(r.r24h), usd(r.volUsd), pct(r.fundAprPct, 0), usd(r.oiUsd), r.setup ?? "n/a", sm].join(
+          " | "
+        )
+      );
+    }
+  } else lines.push("No coins match.");
+  if (m.unknown.length) lines.push(`Not listed on Hyperliquid: ${m.unknown.join(", ")}`);
+  if (m.next !== null) lines.push(`More: call again with offset=${m.next}.`);
+  return lines.join("\n");
+}
+var pileText = (p, now) => `${p.coin} | ${p.traders} traders ${p.dir === "in" ? "into" : "out of"} ${p.side} | ${usd(p.totalUsd)} | ${ago(p.first, now)} to ${ago(p.last, now)} ago | ${p.names.join(", ")}`;
+function renderBoard(b, now = Date.now()) {
+  const title = {
+    conviction: "where the top traders agree (weighted by track record)",
+    discount: "coins below the top traders\u2019 entry (longs) or above it (shorts)",
+    flows: "biggest net flows of the last hour",
+    pileins: "pile-ins: 3+ top traders moving the same way within 45 min, last 2h"
+  };
+  const lines = [`smart money \xB7 ${title[b.view]}${b.asOf ? ` \xB7 as of ${ago(b.asOf, now)} ago` : ""}`];
+  if (b.view === "pileins") {
+    if (b.pileIns.length) lines.push("coin | who | size | when | biggest movers", ...b.pileIns.map((p) => pileText(p, now)));
+    else lines.push("No pile-ins in the last 2 hours.");
+  } else if (b.rows.length) {
+    lines.push("coin | side | share | size | traders | their entry | price | vs entry | 1h flow | setup | 24h");
+    for (const r of b.rows)
+      lines.push(
+        [
+          r.coin,
+          r.side ?? "n/a",
+          `${Math.round(r.share * 100)}%`,
+          usd(r.sideUsd),
+          `${r.traders} (${trim(r.heads, 1)} weighted)`,
+          price(r.entry),
+          price(r.mark),
+          entryText(r.side, r.edgePct) ?? "n/a",
+          usd(r.flow1hUsd, true),
+          r.setup ?? "n/a",
+          pct(r.r24h)
+        ].join(" | ")
+      );
+  } else lines.push("No coins on this board right now.");
+  if (b.note) lines.push(b.note);
+  return lines.join("\n");
+}
+function renderMoves(m, now = Date.now()) {
+  const lines = [];
+  if (m.order === "oldest") lines.push(m.moves.length ? `${m.moves.length} new move${m.moves.length === 1 ? "" : "s"}, oldest first` : "No new moves.");
+  else lines.push(m.moves.length ? `latest ${m.moves.length} moves, newest first` : "No moves match.");
+  for (const mv of m.moves) lines.push(`${ago(mv.t, now)} ago | ${trader(mv)} | ${moveText(mv)}`);
+  if (m.gap) lines.push("Some moves before these were missed: the cursor was older than the moves kept.");
+  if (m.more) lines.push(`More waiting: call again with since=${m.next}.`);
+  else if (m.next) lines.push(`next=${m.next} (pass as since to get only newer moves)`);
+  if (m.note) lines.push(m.note);
+  return lines.join("\n");
+}
+function renderCoin(c, you, now = Date.now()) {
+  const lines = [];
+  const sm = c.sm;
+  const mk = c.market;
+  if (sm && sm.side) {
+    const ours = sm.side === "long" ? sm.long : sm.short;
+    const theirs = sm.side === "long" ? sm.short : sm.long;
+    const tags = [sm.discount === "strict" ? "on the discount board" : null, sm.conviction !== null ? "on the conviction board" : null].filter(Boolean);
+    lines.push(
+      `${c.coin}: top traders lean ${sm.side.toUpperCase()} ${Math.round(sm.share * 100)}% (${usd(ours.usd)} vs ${usd(theirs.usd)})${tags.length ? ` \xB7 ${tags.join(", ")}` : ""}`
+    );
+    lines.push(
+      `book | long ${sm.long.traders} traders (${trim(sm.long.heads, 1)} weighted), avg entry ${price(sm.long.entry)} | short ${sm.short.traders} traders (${trim(sm.short.heads, 1)} weighted), avg entry ${price(sm.short.entry)}`
+    );
+  } else lines.push(`${c.coin}: no top-trader positions right now`);
+  if (mk) {
+    const vs = sm?.side ? entryText(sm.side, sm.edgePct) : null;
+    lines.push(`price | ${price(mk.px)}${vs ? ` (${vs})` : ""} \xB7 15m ${pct(mk.r15m)} \xB7 1h ${pct(mk.r1h)} \xB7 24h ${pct(mk.r24h)}`);
+    lines.push(`setup | ${mk.setup ?? "n/a"} \xB7 funding ${pct(mk.fundAprPct, 0)} APR \xB7 open interest ${usd(mk.oiUsd)} \xB7 vol ${usd(mk.volUsd)}`);
+  } else lines.push("price | no market data for this coin");
+  if (sm && sm.flow1hUsd !== 0) lines.push(`flow | ${usd(Math.abs(sm.flow1hUsd))} net toward ${sm.flow1hUsd > 0 ? "long" : "short"} in the last hour`);
+  if (sm?.pileIn) lines.push(`pile-in | ${pileText(sm.pileIn, now)}`);
+  if (c.moves.length) lines.push(...c.moves.map((m) => `move | ${ago(m.t, now)} ago | ${trader(m)} | ${moveText(m)}`));
+  else lines.push("move | none of $10k+ recently");
+  if (you) {
+    const p = you.position;
+    lines.push(
+      p ? `you | ${p.side.toLowerCase()} ${trim(Math.abs(p.size), 6)} @ ${price(p.entryPrice)}, open PnL ${usd(p.unrealizedPnl, true)}, ${trim(p.leverage, 1)}x \xB7 ${usd(you.availableBalance)} free` : `you | no ${c.coin} position \xB7 ${usd(you.availableBalance)} free`
+    );
+  }
+  if (c.note) lines.push(c.note);
+  return lines.join("\n");
+}
+function renderAccount(p, orders, summary) {
+  const lines = [
+    `account \xB7 value ${usd(p.totalBalance)} \xB7 free ${usd(p.availableBalance)} \xB7 margin used ${usd(p.totalMargin)} \xB7 open PnL ${usd(p.unrealizedPnl, true)}`
+  ];
+  if (p.positions.length) {
+    lines.push("positions: coin | side | size @ entry | now | open PnL | leverage | liquidation | TP/SL (id)");
+    for (const pos of p.positions) {
+      const prot = p.protectiveOrders.filter((o) => o.symbol.replace(/USDT$/, "").toUpperCase() === pos.symbol.replace(/USDT$/, "").toUpperCase()).map((o) => `${o.kind === "TAKE_PROFIT" ? "TP" : "SL"} ${o.stopPrice ?? "n/a"} (${o.id})`);
+      lines.push(
+        [
+          pos.symbol,
+          pos.side.toLowerCase(),
+          `${trim(Math.abs(pos.size), 6)} @ ${price(pos.entryPrice)}`,
+          price(pos.markPrice),
+          usd(pos.unrealizedPnl, true),
+          `${trim(pos.leverage, 1)}x`,
+          price(pos.liquidationPrice ?? null),
+          prot.length ? prot.join(", ") : "none"
+        ].join(" | ")
+      );
+    }
+  } else lines.push("positions: none");
+  if (orders) {
+    const working = orders.filter((o) => !o.isTrigger);
+    if (working.length) {
+      lines.push("open orders: coin | side | size @ price | type | oid");
+      for (const o of working) lines.push([o.coin, o.side === "B" ? "buy" : "sell", `${o.sz} @ ${o.limitPx}`, `${o.orderType}${o.tif ? ` ${o.tif}` : ""}${o.reduceOnly ? " reduce-only" : ""}`, o.oid].join(" | "));
+    } else lines.push("open orders: none");
+  }
+  if (summary)
+    lines.push(
+      `${summary.window}: realized ${usd(summary.realizedPnl, true)} \xB7 fees ${usd(summary.totalFees)} \xB7 ${summary.winCount} wins / ${summary.lossCount} losses`
+    );
+  return lines.join("\n");
+}
+function positionLine(pos) {
+  return [
+    `${pos.side.toLowerCase()} ${trim(Math.abs(pos.size), 6)} ${pos.symbol.replace(/USDT$/, "")} @ ${price(pos.entryPrice)}`,
+    `mark ${price(pos.markPrice)}`,
+    `open PnL ${usd(pos.unrealizedPnl, true)}`,
+    `${trim(pos.leverage, 1)}x`,
+    `liquidation ${price(pos.liquidationPrice ?? null)}`
+  ].join(" \xB7 ");
+}
+var cents = (v, signed = false) => Math.abs(v) >= 1e3 ? usd(v, signed) : `${v < 0 ? "-" : signed && v > 0 ? "+" : ""}$${Math.abs(v).toFixed(2)}`;
+function renderTrades(page, paper2, coin2, now = Date.now()) {
+  const f = page.fills;
+  const closes = f.filter((x) => x.closedPnl !== 0);
+  const pnl = f.reduce((sum, x) => sum + x.closedPnl, 0);
+  const fees = f.reduce((sum, x) => sum + x.fee, 0);
+  const wins = closes.filter((x) => x.closedPnl > 0).length;
+  const head = `${paper2 ? "PRACTICE " : ""}trades ${page.window}${coin2 ? ` ${coin2}` : ""} \xB7 ${f.length} fills \xB7 realized ${cents(pnl, true)} \xB7 fees ${cents(fees)} \xB7 net ${cents(pnl - fees, true)} \xB7 ${wins} wins / ${closes.length - wins} losses`;
+  if (!f.length) return `${head}
+no fills in this window`;
+  const lines = [head, "ago | coin | what | size @ price | realized PnL | fee"];
+  for (const x of f)
+    lines.push([ago(x.time, now), x.coin, x.dir, `${x.sz} @ ${price(x.px)}`, x.closedPnl === 0 ? "-" : cents(x.closedPnl, true), cents(x.fee)].join(" | "));
+  if (page.hasMore) lines.push("more fills are older: widen window or raise limit");
+  return lines.join("\n");
+}
+function renderCandles(coin2, interval, c) {
+  const iso = (t) => new Date(t).toISOString().slice(0, 16).replace("T", " ");
+  const lines = [`${coin2} ${interval} candles \xB7 ${c.candles.length}, oldest first${c.complete ? "" : " \xB7 some missing minutes left gaps"}`, "time UTC,open,high,low,close,volume"];
+  for (const k of c.candles) lines.push([iso(k.t), k.o, k.h, k.l, k.c, k.v].join(","));
+  return lines.join("\n");
+}
+
+// src/lean/tools.ts
+import { createHash } from "crypto";
+import { z as z6 } from "zod";
+var text = (body, data) => ({
+  content: [{ type: "text", text: body }],
+  structuredContent: data
+});
+var loginText = (login) => `Helios is not connected yet. Open this link to approve access, then call this tool again:
+${login.verificationUriComplete}
+User code: ${login.userCode}`;
+var pendingResult = (login) => text(loginText(login), {
+  status: "pending",
+  connected: false,
+  actionRequired: true,
+  loginUrl: login.verificationUriComplete,
+  userCode: login.userCode
+});
+async function withSession(auth, scope, call) {
+  const loginOptions = { clientName: "Helios MCP", scope };
+  const login = await auth.ensureLogin(loginOptions);
+  if (login.status !== "connected") return { ok: false, pending: login };
+  const session = await auth.requireSession();
+  try {
+    return { ok: true, value: await call(session.accessToken) };
+  } catch (error) {
+    const recovery = await retryAfterUnauthorizedRefresh({ authService: auth, error, loginOptions, retry: call });
+    if (recovery === null) throw error;
+    if (isPending(recovery)) return { ok: false, pending: recovery };
+    return { ok: true, value: recovery };
+  }
+}
+function isPending(value) {
+  return Boolean(value && typeof value === "object" && value.connected === false && "verificationUriComplete" in value);
+}
+async function sessionScopes(auth) {
+  const session = await auth.requireSession().catch(() => null);
+  return new Set(session?.scope ?? []);
+}
+var coin = z6.string().trim().min(1).max(36).describe("e.g. BTC, kPEPE, xyz:TSLA");
+var smBoardInputSchema = z6.object({
+  view: z6.enum(["conviction", "discount", "flows", "pileins"]).optional().describe("conviction (default): where they agree; discount: price better than their entry; flows: last hour; pileins: 3+ moving together"),
+  side: z6.enum(["long", "short", "any"]).optional(),
+  limit: z6.number().int().min(1).max(25).optional().describe("Default 8")
+});
+var smMovesInputSchema = z6.object({
+  since: z6.string().regex(/^\d{1,16}-\d{1,16}$/).optional().describe("next from your last call: only newer moves"),
+  coin: coin.optional(),
+  kind: z6.enum(["entries", "exits", "all"]).optional().describe("entries = opens, adds; exits = trims, closes"),
+  min_usd: z6.number().nonnegative().optional().describe("Default 25000"),
+  limit: z6.number().int().min(1).max(50).optional().describe("Default 15")
+});
+var smCoinInputSchema = z6.object({ coin });
+var marketInputSchema = z6.object({
+  coins: z6.string().max(400).optional().describe('Comma list, e.g. "BTC,HYPE"; omit for all'),
+  limit: z6.number().int().min(1).max(300).optional().describe("Default 20"),
+  offset: z6.number().int().nonnegative().optional(),
+  sort: z6.enum(["volume", "rank", "move1h", "move24h", "funding", "lean", "edge"]).optional(),
+  filter: z6.enum(["turning", "falling", "stretched_up", "stretched_down", "sm_long", "sm_short", "discount"]).optional().describe("turning = turning up from breakdown (held up in backtests); discount = better than their entry")
+});
+var paper = z6.boolean().optional().describe("true = your practice account: live prices, simulated fills, no real money (market orders only)");
+var accountInputSchema = z6.object({ paper });
+var tradeInputSchema = z6.object({
+  coin,
+  action: z6.enum(["open", "add", "close", "reverse", "reset"]).describe("reset = start the practice account over (paper only; margin_usd = starting balance, default $10k)"),
+  side: z6.enum(["long", "short"]).optional().describe("For open, add, reverse"),
+  // Only obviously absurd values are cut here; Hyperliquid's margin check and the person's approval do the rest.
+  margin_usd: z6.number().positive().max(1e6).optional().describe("Size = margin x leverage"),
+  leverage: z6.number().positive().max(100).optional(),
+  sl_pct: z6.number().positive().max(95).optional().describe("Stop, % from entry"),
+  tp_pct: z6.number().positive().max(1e3).optional().describe("Take profit, % from entry"),
+  limit_px: z6.number().positive().optional().describe("Omit for market"),
+  slippage_bps: z6.number().int().min(1).max(1e3).optional().describe("Market only: worst fill vs price, bps. Default 300 (3%)"),
+  fraction: z6.number().positive().max(1).optional().describe("close only: share to close, e.g. 0.5 = half. Default 1 = all"),
+  paper,
+  key: z6.string().regex(/^[A-Za-z0-9_-]{8,64}$/).optional().describe("Same key on retry = never placed twice. Omitted: repeats of the same call within 60s of the first are placed once")
+});
+var TRADE_KEY_WINDOW_SECONDS = 60;
+function tradeKeyFor(input, account) {
+  const order = [
+    account,
+    input.coin.toUpperCase(),
+    input.action,
+    input.side ?? "",
+    input.margin_usd ?? "",
+    input.leverage ?? "",
+    input.sl_pct ?? "",
+    input.tp_pct ?? "",
+    input.limit_px ?? "",
+    input.slippage_bps ?? "",
+    input.fraction ?? ""
+  ];
+  return `mcpw-${createHash("sha256").update(`trade:${order.join("|")}`).digest("base64url")}`;
+}
+var protectInputSchema = z6.object({
+  coin,
+  op: z6.enum(["set", "remove", "cancel", "move"]).describe("set TP/SL; remove a TP/SL; cancel an order; move an open order to px"),
+  tp_px: z6.number().positive().optional(),
+  sl_px: z6.number().positive().optional(),
+  order_id: z6.string().max(64).optional().describe("From account: TP/SL id or order oid"),
+  px: z6.number().positive().optional().describe("move only: the new limit (or trigger) price"),
+  paper
+});
+var tradesInputSchema = z6.object({
+  window: z6.enum(["24h", "7d", "30d"]).optional().describe("Default 7d"),
+  coin: coin.optional(),
+  limit: z6.number().int().min(1).max(100).optional().describe("Default 20"),
+  paper
+});
+var candlesInputSchema = z6.object({
+  coin: z6.string().regex(/^[A-Za-z0-9]{1,20}$/).describe("e.g. BTC, kPEPE"),
+  interval: z6.enum(["1m", "5m", "15m", "1h", "4h", "1d"]),
+  limit: z6.number().int().min(1).max(1e3).optional().describe("Default 100")
+});
+var READ = [AGENT_SCOPES.MARKET_READ];
+var sameCoinName = (a, b) => a.replace(/USDT$/, "").toUpperCase() === b.replace(/USDT$/, "").toUpperCase();
+var sameCoin = (pos, coin2) => sameCoinName(pos.symbol, coin2);
+var paperTotals = (p) => p.realizedPnl === void 0 ? "" : `
+practice totals: realized ${p.realizedPnl >= 0 ? "+" : "-"}$${Math.abs(p.realizedPnl).toFixed(2)} \xB7 fees $${(p.feesPaid ?? 0).toFixed(2)} \xB7 funding $${(p.fundingPaid ?? 0).toFixed(2)} \xB7 liquidations ${p.liquidations ?? 0}`;
+function wrongSideTpSl(side, mark, tp, sl) {
+  const long = side === "LONG";
+  const at = `${side.toLowerCase()} (price ${price(mark)})`;
+  if (sl !== void 0 && (long ? sl >= mark : sl <= mark)) return `Stop ${price(sl)} must be ${long ? "under" : "over"} the price for a ${at}`;
+  if (tp !== void 0 && (long ? tp <= mark : tp >= mark)) return `Take profit ${price(tp)} must be ${long ? "over" : "under"} the price for a ${at}`;
+  return null;
+}
+function createLeanToolDefinitions(services) {
+  const { auth, dataBridge } = services;
+  const smBoard = {
+    name: "sm_board",
+    title: "Smart Money Board",
+    description: "Where the top Hyperliquid traders (ranked on a year of results) are positioned: side, size, entry vs price.",
+    inputSchema: smBoardInputSchema,
+    async execute(input) {
+      const r = await withSession(auth, READ, (token) => dataBridge.getSmartMoneyBoard(token, input));
+      return r.ok ? text(renderBoard(r.value), r.value) : pendingResult(r.pending);
+    }
+  };
+  const smMoves = {
+    name: "sm_moves",
+    title: "Smart Money Moves",
+    description: "Top traders\u2019 latest trades. Poll with since=next for new ones only.",
+    inputSchema: smMovesInputSchema,
+    async execute(input) {
+      const r = await withSession(
+        auth,
+        READ,
+        (token) => dataBridge.getSmartMoneyMoves(token, { since: input.since, coin: input.coin, kind: input.kind, minUsd: input.min_usd, limit: input.limit })
+      );
+      return r.ok ? text(renderMoves(r.value), r.value) : pendingResult(r.pending);
+    }
+  };
+  const smCoin = {
+    name: "sm_coin",
+    title: "Smart Money Coin Brief",
+    description: "One coin in one call: top traders\u2019 book, entries and trades, price, setup, funding, OI, your position.",
+    inputSchema: smCoinInputSchema,
+    async execute(input) {
+      const r = await withSession(auth, READ, (token) => dataBridge.getSmartMoneyCoin(token, input.coin));
+      if (!r.ok) return pendingResult(r.pending);
+      let you = null;
+      if ((await sessionScopes(auth)).has(AGENT_SCOPES.ACCOUNT_READ)) {
+        const p = await withSession(auth, [AGENT_SCOPES.ACCOUNT_READ], (token) => dataBridge.getPortfolio(token, { provider: "hyperliquid" })).catch(
+          () => null
+        );
+        if (p?.ok) {
+          you = {
+            position: p.value.positions.find((pos) => sameCoin(pos, r.value.coin)) ?? null,
+            availableBalance: p.value.availableBalance
+          };
+        }
+      }
+      return text(renderCoin(r.value, you), { ...r.value, you });
+    }
+  };
+  const market = {
+    name: "market",
+    title: "Market Scan",
+    description: "All coins: price, moves, volume, funding, OI, setup label, top traders\u2019 lean. Filter, sort, page.",
+    inputSchema: marketInputSchema,
+    async execute(input) {
+      const coins = input.coins?.split(",").map((c) => c.trim()).filter(Boolean).slice(0, 50);
+      const r = await withSession(
+        auth,
+        READ,
+        (token) => dataBridge.getAgentMarket(token, {
+          ...coins?.length ? { coins } : {},
+          limit: input.limit,
+          offset: input.offset,
+          sort: input.sort,
+          filter: input.filter
+        })
+      );
+      return r.ok ? text(renderMarket(r.value), r.value) : pendingResult(r.pending);
+    }
+  };
+  const account = {
+    name: "account",
+    title: "Account",
+    description: "Balance, positions with TP/SL ids, open orders, 30-day result. paper=true for the practice account.",
+    inputSchema: accountInputSchema,
+    async execute(input) {
+      if (input.paper) {
+        const p = await withSession(auth, [AGENT_SCOPES.ACCOUNT_READ], (token) => dataBridge.getPaperPortfolio(token));
+        if (!p.ok) return pendingResult(p.pending);
+        return text(`PRACTICE ${renderAccount(p.value, null, null)}${paperTotals(p.value)}`, { paper: true, portfolio: p.value });
+      }
+      const r = await withSession(
+        auth,
+        [AGENT_SCOPES.ACCOUNT_READ],
+        (token) => Promise.all([
+          dataBridge.getPortfolio(token, { provider: "hyperliquid" }),
+          dataBridge.getOpenOrders(token).catch(() => null),
+          dataBridge.getLedgerSummary(token, { window: "30d" }).catch(() => null)
+        ])
+      );
+      if (!r.ok) return pendingResult(r.pending);
+      const [portfolio, orders, summary] = r.value;
+      return text(renderAccount(portfolio, orders, summary), { portfolio, orders, summary });
+    }
+  };
+  const trade = {
+    name: "trade",
+    title: "Trade",
+    description: "Open, add to, close (all or part) or reverse a position, sized by margin in USD. Answers with the position after the order. paper=true to practice.",
+    inputSchema: tradeInputSchema,
+    acts: true,
+    async execute(input) {
+      if (input.fraction !== void 0 && input.action !== "close") throw new Error("fraction is for close only");
+      if (input.action === "reset") {
+        if (!input.paper) throw new Error("reset is for the practice account only: pass paper=true");
+        const r2 = await withSession(auth, [AGENT_SCOPES.ORDERS_WRITE], (token) => dataBridge.resetPaperAccount(token, input.margin_usd));
+        if (!r2.ok) return pendingResult(r2.pending);
+        return text(`Practice account started over with ${input.margin_usd ? `$${input.margin_usd}` : "the default balance"}.`, { paper: true, reset: true });
+      }
+      if (input.paper) return paperTrade(input);
+      if (input.action === "close") {
+        const r2 = await withSession(
+          auth,
+          [AGENT_SCOPES.ORDERS_WRITE],
+          (token) => dataBridge.closePosition(token, {
+            provider: "hyperliquid",
+            symbol: input.coin,
+            ...input.fraction !== void 0 && input.fraction < 1 ? { fraction: input.fraction } : {},
+            // A close is a market order: the same cap applies (unset, data-bridge uses its default).
+            ...input.slippage_bps ? { maxSlippageBps: input.slippage_bps } : {}
+          })
+        );
+        if (!r2.ok) return pendingResult(r2.pending);
+        if (r2.value.outcome === "no_position") return text(`No open ${input.coin} position: nothing was sent.`, r2.value);
+        const after2 = await positionAfter(input.coin, false);
+        const what = r2.value.mode === "PARTIAL" ? `${Math.round((input.fraction ?? 1) * 100)}% of the ${input.coin} position` : `the whole ${input.coin} position`;
+        return text(`Sent a market order closing ${what}. ${after2.text}`, { ...r2.value, after: after2.position });
+      }
+      if (!input.side || !input.margin_usd) throw new Error(`${input.action} needs side and margin_usd`);
+      if (input.limit_px && input.slippage_bps) throw new Error("slippage_bps is for market orders: a limit order fills at limit_px or better");
+      const prot = await protectionFor(input);
+      if ("pending" in prot) return pendingResult(prot.pending);
+      const protection = prot.value;
+      const intentType = input.action === "open" ? "OPEN" : input.action === "add" ? "DCA" : "REVERSE";
+      let idempotencyKey = input.key;
+      const r = await withSession(auth, [AGENT_SCOPES.ORDERS_WRITE], async (token) => {
+        if (!idempotencyKey) {
+          const session = await auth.requireSession();
+          idempotencyKey = tradeKeyFor(input, `${session.ownerUserId}|${session.agentGrantId}`);
+        }
+        return dataBridge.submitTradeIntent(token, {
+          provider: "hyperliquid",
+          symbol: input.coin,
+          intentType,
+          direction: input.side === "long" ? "LONG" : "SHORT",
+          size: { mode: "MARGIN_USD", value: input.margin_usd },
+          execution: input.limit_px ? { style: "LIMIT_GTC", limitPrice: input.limit_px } : { style: "MARKET" },
+          // Unset, data-bridge caps a market order at its own default (300 bps).
+          ...input.slippage_bps ? { maxSlippageBps: input.slippage_bps } : {},
+          ...input.leverage ? { leverageOverride: input.leverage } : {},
+          ...protection ? { protection } : {},
+          idempotencyKey,
+          ...input.key ? {} : { idempotencyWindowSeconds: TRADE_KEY_WINDOW_SECONDS }
+        });
+      }).catch((error) => {
+        if (!isHeliosAgentApiError(error) || error.code !== "CONFLICT" || !/being placed/.test(error.message)) throw error;
+        const why = input.key ? `key ${idempotencyKey} was already used` : `an identical trade call within ${TRADE_KEY_WINDOW_SECONDS}s of the first is the same order`;
+        throw new Error(
+          `${error.message} (${why}, so this may be that earlier order.) Call account to see whether it went through. To place another one on purpose, call trade again with a new key.`
+        );
+      });
+      if (!r.ok) return pendingResult(r.pending);
+      const s = r.value;
+      const parts = [
+        s.outcome === "replayed" ? `Already sent earlier with key ${idempotencyKey}${input.key ? "" : ` (an identical call within ${TRADE_KEY_WINDOW_SECONDS}s of the first is the same order)`}: nothing new was placed. To place another on purpose, pass a new key.` : `Sent: ${input.action} ${input.side} ${input.coin}, $${input.margin_usd} margin${input.leverage ? ` at ${input.leverage}x` : ""}, ${input.limit_px ? `limit ${price(input.limit_px)}` : "market"}.`
+      ];
+      if (protection?.stopLoss) parts.push(`Stop ${price(protection.stopLoss.triggerPrice)}.`);
+      if (protection?.takeProfit) parts.push(`Take profit ${price(protection.takeProfit.triggerPrice)}.`);
+      if (s.orderStatus) parts.push(`Order status: ${s.orderStatus}.`);
+      if (s.rejectedProtection?.length) parts.push(`Hyperliquid refused part of the TP/SL; check account and set it with protect.`);
+      parts.push(input.key ? `key=${idempotencyKey}` : `key=${idempotencyKey} (an identical call within ${TRADE_KEY_WINDOW_SECONDS}s of the first is the same order)`);
+      let after;
+      if (!input.limit_px && s.outcome !== "replayed") {
+        const a = await positionAfter(input.coin, false);
+        parts.push(a.text);
+        after = a.position;
+      } else if (input.limit_px) parts.push("A limit order rests until filled: see it in account; move it with protect op=move.");
+      return text(parts.join(" "), { ...s, idempotencyKey, ...after !== void 0 ? { after } : {} });
+    }
+  };
+  const protect = {
+    name: "protect",
+    title: "Protect",
+    description: "Set or remove TP/SL on a position, or cancel an order.",
+    inputSchema: protectInputSchema,
+    acts: true,
+    async execute(input) {
+      if (input.op === "set") {
+        if (!input.tp_px && !input.sl_px) throw new Error("set needs tp_px, sl_px or both");
+        const p = await withSession(
+          auth,
+          [AGENT_SCOPES.ACCOUNT_READ],
+          (token) => input.paper ? dataBridge.getPaperPortfolio(token) : dataBridge.getPortfolio(token, { provider: "hyperliquid" })
+        ).catch(
+          (error) => {
+            throw new Error(
+              `Could not read your ${input.coin} position to check the TP/SL side (${error instanceof Error ? error.message : String(error)}); nothing was set.`
+            );
+          }
+        );
+        if (!p.ok) return pendingResult(p.pending);
+        const position = p.value.positions.find((pos) => sameCoin(pos, input.coin));
+        if (!position) throw new Error(`No open ${input.coin} position: nothing was set.`);
+        if (!(position.markPrice > 0)) throw new Error(`No price for ${input.coin} to check the TP/SL against: nothing was set. Try again shortly.`);
+        const wrong = wrongSideTpSl(position.side, position.markPrice, input.tp_px, input.sl_px);
+        if (wrong) throw new Error(`${wrong}: it would trigger at once and close the position. Nothing was set.`);
+        const tpSl = {
+          provider: "hyperliquid",
+          symbol: input.coin,
+          applyTo: "FULL_POSITION",
+          // TP/SL attach to the position on Hyperliquid; data-bridge links them to the order that opened it.
+          parentClientOrderId: `hl-position:${input.coin}`,
+          ...input.tp_px ? { takeProfit: { kind: "MARKET", triggerPrice: input.tp_px } } : {},
+          ...input.sl_px ? { stopLoss: { kind: "MARKET", triggerPrice: input.sl_px } } : {}
+        };
+        const r2 = await withSession(
+          auth,
+          [AGENT_SCOPES.ORDERS_WRITE],
+          (token) => input.paper ? dataBridge.setPaperTpSl(token, tpSl) : dataBridge.setTpSl(token, tpSl)
+        );
+        if (!r2.ok) return pendingResult(r2.pending);
+        const legs = [input.tp_px ? `take profit ${price(input.tp_px)}` : null, input.sl_px ? `stop ${price(input.sl_px)}` : null].filter(Boolean);
+        return text(`${input.paper ? "Practice: s" : "S"}et on the whole ${input.coin} position: ${legs.join(", ")}.`, r2.value);
+      }
+      if (!input.order_id) throw new Error(`${input.op} needs order_id (from account)`);
+      if (input.op === "remove") {
+        const del = { provider: "hyperliquid", symbol: input.coin, orderId: input.order_id };
+        const r2 = await withSession(
+          auth,
+          [AGENT_SCOPES.ORDERS_CANCEL],
+          (token) => input.paper ? dataBridge.deletePaperTpSl(token, del) : dataBridge.deleteTpSl(token, del)
+        );
+        return r2.ok ? text(`Removed TP/SL ${input.order_id} on ${input.coin}.`, r2.value) : pendingResult(r2.pending);
+      }
+      if (input.paper) throw new Error("The practice account has no resting orders (every order fills at market): nothing to cancel or move");
+      const oid = Number(input.order_id);
+      if (!Number.isInteger(oid) || oid < 0) throw new Error(`${input.op} needs the numeric order oid from account`);
+      if (input.op === "move") {
+        if (!input.px) throw new Error("move needs px, the new price");
+        const o = await withSession(auth, [AGENT_SCOPES.ACCOUNT_READ], (token) => dataBridge.getOpenOrders(token));
+        if (!o.ok) return pendingResult(o.pending);
+        const order = o.value.find((x) => x.oid === oid);
+        if (!order) throw new Error(`No open order ${oid}: it may have filled or been cancelled. Call account.`);
+        const size = Number(order.sz);
+        const r2 = await withSession(auth, [AGENT_SCOPES.ORDERS_WRITE], (token) => dataBridge.modifyOrder(token, { symbol: order.coin, oid, price: input.px, size }));
+        return r2.ok ? text(`Moved order ${oid} on ${order.coin} to ${price(input.px)} (size ${order.sz}).`, r2.value) : pendingResult(r2.pending);
+      }
+      const r = await withSession(auth, [AGENT_SCOPES.ORDERS_CANCEL], (token) => dataBridge.cancelOrder(token, { symbol: input.coin, oid }));
+      return r.ok ? text(`Cancelled order ${oid} on ${input.coin}.`, r.value) : pendingResult(r.pending);
+    }
+  };
+  const trades = {
+    name: "trades",
+    title: "Your Trades",
+    description: "Your recent fills, newest first: price, size, realized PnL and fees, with totals. Learn from results. paper=true for practice.",
+    inputSchema: tradesInputSchema,
+    async execute(input) {
+      const window = input.window ?? "7d";
+      const want = input.limit ?? 20;
+      const ask = { window, limit: input.coin ? 200 : want };
+      const r = await withSession(
+        auth,
+        [AGENT_SCOPES.ACCOUNT_READ],
+        (token) => input.paper ? dataBridge.getPaperLedgerFills(token, ask) : dataBridge.getLedgerFills(token, ask)
+      );
+      if (!r.ok) return pendingResult(r.pending);
+      const fills = r.value.fills.filter((f) => !input.coin || sameCoinName(f.coin, input.coin)).slice(0, want);
+      const page = { ...r.value, fills };
+      return text(renderTrades(page, Boolean(input.paper), input.coin ?? null), { paper: Boolean(input.paper), ...page });
+    }
+  };
+  const candles = {
+    name: "candles",
+    title: "Candles",
+    description: "OHLCV candles for one coin (up to 7 days), oldest first, as CSV.",
+    inputSchema: candlesInputSchema,
+    async execute(input) {
+      const r = await withSession(
+        auth,
+        READ,
+        (token) => dataBridge.getMarketCandles(token, { symbol: input.coin, interval: input.interval, limit: input.limit ?? 100 })
+      );
+      return r.ok ? text(renderCandles(input.coin, input.interval, r.value), r.value) : pendingResult(r.pending);
+    }
+  };
+  async function positionAfter(coinName, isPaper) {
+    const p = await withSession(
+      auth,
+      [AGENT_SCOPES.ACCOUNT_READ],
+      (token) => isPaper ? dataBridge.getPaperPortfolio(token) : dataBridge.getPortfolio(token, { provider: "hyperliquid" })
+    ).catch(() => null);
+    if (!p?.ok || !Array.isArray(p.value?.positions)) return { text: "Call account to see the position.", position: null };
+    const position = p.value.positions.find((pos) => sameCoin(pos, coinName)) ?? null;
+    return { text: position ? `Now: ${positionLine(position)}.` : `Now: no ${coinName} position.`, position };
+  }
+  async function paperTrade(input) {
+    if (input.limit_px) throw new Error("The practice account fills market orders only: leave out limit_px");
+    if (input.action === "close") {
+      const r2 = await withSession(
+        auth,
+        [AGENT_SCOPES.ORDERS_WRITE],
+        (token) => dataBridge.closePaperPosition(token, { symbol: input.coin, ...input.fraction !== void 0 && input.fraction < 1 ? { fraction: input.fraction } : {} })
+      );
+      if (!r2.ok) return pendingResult(r2.pending);
+      if (!r2.value.length) return text(`Practice: no open ${input.coin} position, nothing closed.`, { paper: true, fills: [] });
+      const after2 = await positionAfter(input.coin, true);
+      const pnl = r2.value.reduce((sum, f) => sum + f.pnl - f.fee, 0);
+      return text(`Practice: closed ${input.fraction && input.fraction < 1 ? `${Math.round(input.fraction * 100)}% of ` : ""}${input.coin} @ ${price(r2.value[r2.value.length - 1].price)}, ${pnl >= 0 ? "+" : "-"}$${Math.abs(pnl).toFixed(2)} after fees. ${after2.text}`, {
+        paper: true,
+        fills: r2.value,
+        after: after2.position
+      });
+    }
+    if (!input.side || !input.margin_usd) throw new Error(`${input.action} needs side and margin_usd`);
+    const protection = await protectionFor(input);
+    if ("pending" in protection) return pendingResult(protection.pending);
+    const r = await withSession(
+      auth,
+      [AGENT_SCOPES.ORDERS_WRITE],
+      (token) => dataBridge.submitPaperIntent(token, {
+        provider: "hyperliquid",
+        symbol: input.coin,
+        intentType: input.action === "open" ? "OPEN" : input.action === "add" ? "DCA" : "REVERSE",
+        direction: input.side === "long" ? "LONG" : "SHORT",
+        size: { mode: "MARGIN_USD", value: input.margin_usd },
+        execution: { style: "MARKET" },
+        ...input.leverage ? { leverageOverride: input.leverage } : {},
+        ...protection.value ? { protection: protection.value } : {}
+      })
+    );
+    if (!r.ok) return pendingResult(r.pending);
+    const after = await positionAfter(input.coin, true);
+    const filled = r.value.filter((f) => f.side !== null);
+    const parts = [
+      filled.length ? `Practice: ${input.action} ${input.side} ${input.coin} filled @ ${price(filled[filled.length - 1].price)}, $${input.margin_usd} margin${input.leverage ? ` at ${input.leverage}x` : ""}.` : `Practice: ${input.action} ${input.side} ${input.coin} sent, no fill reported.`
+    ];
+    if (protection.value?.stopLoss) parts.push(`Stop ${price(protection.value.stopLoss.triggerPrice)}.`);
+    if (protection.value?.takeProfit) parts.push(`Take profit ${price(protection.value.takeProfit.triggerPrice)}.`);
+    parts.push(after.text);
+    return text(parts.join(" "), { paper: true, fills: r.value, after: after.position });
+  }
+  async function protectionFor(input) {
+    if (input.side === "short" && (input.tp_pct ?? 0) >= 100) throw new Error("A short can gain at most 100%: tp_pct must be under 100");
+    if (!input.sl_pct && !input.tp_pct) return { value: void 0 };
+    let ref = input.limit_px ?? null;
+    if (ref === null) {
+      const m = await withSession(auth, READ, (token) => dataBridge.getAgentMarket(token, { coins: [input.coin], limit: 1 }));
+      if (!m.ok) return { pending: m.pending };
+      ref = m.value.rows[0]?.px ?? null;
+    }
+    if (ref === null) throw new Error(`No price for ${input.coin} to place the stop from; trade without sl_pct/tp_pct, then use protect`);
+    const long = input.side === "long";
+    const at = (p, away) => Number((p * (1 + away / 100)).toPrecision(6));
+    return {
+      value: {
+        ...input.sl_pct ? { stopLoss: { kind: "MARKET", triggerPrice: at(ref, long ? -input.sl_pct : input.sl_pct) } } : {},
+        ...input.tp_pct ? { takeProfit: { kind: "MARKET", triggerPrice: at(ref, long ? input.tp_pct : -input.tp_pct) } } : {}
+      }
+    };
+  }
+  return { smBoard, smMoves, smCoin, market, account, trade, protect, trades, candles };
+}
+function leanToolsFor(tools, profile) {
+  const reads = [tools.smBoard, tools.smMoves, tools.smCoin, tools.market];
+  const list = profile === "signals" ? [...reads, tools.account, tools.trades, tools.candles] : [...reads, tools.account, tools.trades, tools.trade, tools.protect, tools.candles];
+  return list;
+}
+
+// src/tools.ts
+import { z as z7 } from "zod";
+var pollLoginInputSchema = z7.object({
+  /**
+   * Optional, kept for older agents: the login in progress is always the one polled, and any other code (one that isn't
+   * its user code) is refused.
+   */
+  deviceCode: z7.string().min(1).optional()
+});
+var startLoginOutputSchema = z7.object({
+  status: z7.literal("pending"),
+  userCode: z7.string(),
+  verificationUri: z7.string().url(),
+  verificationUriComplete: z7.string().url(),
+  expiresInSeconds: z7.number().int().positive(),
+  pollIntervalSeconds: z7.number().int().positive(),
+  requestedScope: z7.array(agentScopeSchema).min(1),
+  startedAt: z7.string().datetime()
+});
+var ensureLoginInputSchema = z7.object({
+  clientName: z7.string().min(1).max(64).optional(),
+  scope: z7.array(agentScopeSchema).min(1).optional(),
+  constraints: agentConstraintsSchema.optional()
+});
+var providerSelectionInputSchema = z7.object({
+  provider: providerSchema.optional()
+});
+var providerSetInputSchema = z7.object({
+  provider: providerSchema
+});
+var activeProviderSchema = z7.object({
+  configured: z7.boolean(),
+  provider: providerSchema.nullable()
+});
+var ensureLoginOutputSchema = z7.discriminatedUnion("status", [
+  agentSessionViewSchema.extend({
+    status: z7.literal("connected"),
+    connected: z7.literal(true)
+  }),
+  startLoginOutputSchema.extend({
+    status: z7.literal("pending"),
+    connected: z7.literal(false),
+    message: z7.string()
+  })
+]);
+var pollLoginOutputSchema = z7.discriminatedUnion("status", [
+  agentSessionViewSchema.extend({
+    status: z7.literal("connected"),
+    connected: z7.literal(true)
+  }),
+  z7.object({
+    status: z7.enum(["pending", "rejected", "expired", "failed"]),
+    connected: z7.literal(false),
+    message: z7.string()
+  })
+]);
+var walletStateToolOutputSchema = z7.discriminatedUnion("status", [
+  z7.object({
+    status: z7.literal("connected"),
+    connected: z7.literal(true),
+    walletState: walletStateSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: z7.literal("pending"),
+    connected: z7.literal(false),
+    message: z7.string()
+  })
+]);
+var portfolioToolOutputSchema = z7.discriminatedUnion("status", [
+  z7.object({
+    status: z7.literal("connected"),
+    connected: z7.literal(true),
+    portfolio: portfolioSnapshotSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: z7.literal("pending"),
+    connected: z7.literal(false),
+    message: z7.string()
+  })
+]);
+var openPositionsToolOutputSchema = z7.discriminatedUnion("status", [
+  z7.object({
+    status: z7.literal("connected"),
+    connected: z7.literal(true),
+    openPositions: openPositionsSnapshotSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: z7.literal("pending"),
+    connected: z7.literal(false),
+    message: z7.string()
+  })
+]);
+var ledgerFillsToolOutputSchema = z7.discriminatedUnion("status", [
+  z7.object({
+    status: z7.literal("connected"),
+    connected: z7.literal(true),
+    fills: ledgerFillsPageSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: z7.literal("pending"),
+    connected: z7.literal(false),
+    message: z7.string()
+  })
+]);
+var ledgerSummaryToolOutputSchema = z7.discriminatedUnion("status", [
+  z7.object({
+    status: z7.literal("connected"),
+    connected: z7.literal(true),
+    summary: ledgerSummarySchema
+  }),
+  startLoginOutputSchema.extend({
+    status: z7.literal("pending"),
+    connected: z7.literal(false),
+    message: z7.string()
+  })
+]);
+var marketSnapshotToolOutputSchema = z7.discriminatedUnion("status", [
+  z7.object({
+    status: z7.literal("connected"),
+    connected: z7.literal(true),
+    snapshot: marketSnapshotSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: z7.literal("pending"),
+    connected: z7.literal(false),
+    message: z7.string()
+  })
+]);
+var marketSnapshotChunkToolOutputSchema = z7.discriminatedUnion("status", [
+  z7.object({
+    status: z7.literal("connected"),
+    connected: z7.literal(true),
+    snapshotChunk: marketSnapshotChunkSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: z7.literal("pending"),
+    connected: z7.literal(false),
+    message: z7.string()
+  })
+]);
+var marketSymbolDetailToolOutputSchema = z7.discriminatedUnion("status", [
+  z7.object({
+    status: z7.literal("connected"),
+    connected: z7.literal(true),
+    detail: marketSymbolDetailSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: z7.literal("pending"),
+    connected: z7.literal(false),
+    message: z7.string()
+  })
+]);
+var tradeActionInputSchema = submitTradeIntentInputSchema.omit({
+  intentType: true
+});
+var tradeActionToolOutputSchema = z7.discriminatedUnion("status", [
+  z7.object({
+    status: z7.literal("connected"),
+    connected: z7.literal(true),
+    submission: submitTradeIntentResultSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: z7.literal("pending"),
+    connected: z7.literal(false),
+    message: z7.string()
+  })
+]);
+var closeTradeToolOutputSchema = z7.discriminatedUnion("status", [
+  z7.object({
+    status: z7.literal("connected"),
+    connected: z7.literal(true),
+    closure: closePositionResultSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: z7.literal("pending"),
+    connected: z7.literal(false),
+    message: z7.string()
+  })
+]);
+var setTpSlToolOutputSchema = z7.discriminatedUnion("status", [
+  z7.object({
+    status: z7.literal("connected"),
+    connected: z7.literal(true),
+    protection: setTpSlResultSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: z7.literal("pending"),
+    connected: z7.literal(false),
+    message: z7.string()
+  })
+]);
+var deleteTpSlToolOutputSchema = z7.discriminatedUnion("status", [
+  z7.object({
+    status: z7.literal("connected"),
+    connected: z7.literal(true),
+    deletion: deleteTpSlResultSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: z7.literal("pending"),
+    connected: z7.literal(false),
+    message: z7.string()
+  })
+]);
+var openOrdersToolOutputSchema = z7.discriminatedUnion("status", [
+  z7.object({
+    status: z7.literal("connected"),
+    connected: z7.literal(true),
+    orders: z7.array(openOrderSchema)
+  }),
+  startLoginOutputSchema.extend({
+    status: z7.literal("pending"),
+    connected: z7.literal(false),
+    message: z7.string()
+  })
+]);
+var cancelOrderToolOutputSchema = z7.discriminatedUnion("status", [
+  z7.object({
+    status: z7.literal("connected"),
+    connected: z7.literal(true),
+    cancellation: cancelOrderResultSchema
+  }),
+  startLoginOutputSchema.extend({
+    status: z7.literal("pending"),
+    connected: z7.literal(false),
+    message: z7.string()
+  })
+]);
+var documentPathInputSchema = z7.object({
+  path: z7.string().min(1)
+});
+var docsIndexSchema = z7.object({
+  root: z7.literal("docs"),
+  documents: z7.array(
+    z7.object({
+      path: z7.string(),
+      section: z7.string(),
+      title: z7.string(),
+      bytes: z7.number().int().nonnegative()
+    })
+  )
+});
+var documentSchema = z7.object({
+  path: z7.string(),
+  section: z7.string(),
+  title: z7.string(),
+  body: z7.string(),
+  bytes: z7.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: z7.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 in progress was approved and finishes connecting. No code is needed.",
+      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: z7.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: z7.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: z7.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: z7.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: z7.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
+var MCP_PROFILES = ["lean", "signals", "full"];
+var MAX_TOOL_INPUT_ELEMENTS = 1e4;
+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.4.0"
+    },
+    // Caps the array elements plus object keys one tools/call may carry (GHSA-46jr-4wx8-v453: without it, one request
+    // under the body size limit could run the hosted server out of memory while validating). The largest real input is
+    // a snapshot over every symbol and field, a few hundred entries, so this is far above normal use.
+    { maxToolInputElements: MAX_TOOL_INPUT_ELEMENTS }
+  );
+  if (!options.hosted) {
+    assertHeliosBaseUrl("identityServiceUrl (HELIOS_IDENTITY_SERVICE_URL)", options.identityServiceUrl);
+    assertHeliosBaseUrl("dataBridgeUrl (HELIOS_DATA_BRIDGE_URL)", options.dataBridgeUrl);
+  }
+  const sessionStore = options.sessionStore ?? new FileAgentSessionStore(options.sessionPath ?? getDefaultHeliosAgentMcpSessionPath(), {
+    issuer: { identityServiceUrl: options.identityServiceUrl, dataBridgeUrl: options.dataBridgeUrl }
+  });
+  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 profile = options.profile ?? "full";
+  const lean = createLeanToolDefinitions({ auth: authService, dataBridge: dataBridgeClient });
+  for (const tool of leanToolsFor(lean, profile)) {
+    registerTool(server, { ...tool, textIsResult: true });
+  }
+  if (profile === "full") {
+    const docsTools = createHeliosDocsToolDefinitions(docsService);
+    const authTools = createHeliosAuthToolDefinitions(authService);
+    const ledgerTools = createHeliosLedgerToolDefinitions(ledgerService);
+    const marketTools = createHeliosMarketToolDefinitions(marketService);
+    if (!options.hosted) {
+      registerTool(server, authTools[0]);
+      registerTool(server, authTools[1]);
+      registerTool(server, authTools[2]);
+    }
+    registerTool(server, authTools[3]);
+    registerTool(server, marketTools[0]);
+    registerTool(server, marketTools[1]);
+    registerTool(server, marketTools[2]);
+    registerTool(server, ledgerTools[1]);
+    registerTool(server, docsTools[0]);
+    registerTool(server, docsTools[1]);
+  }
+  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 LEAN_ACTS = /* @__PURE__ */ new Set(["trade", "protect"]);
+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) || LEAN_ACTS.has(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: tool.textIsResult ? result.content : withDataText(tool.name, result.content, result.structuredContent),
+        structuredContent: result.structuredContent
+      };
+    }
+  );
+}
+
+export {
+  DEFAULT_HELIOS_BASE_URL,
+  DEFAULT_HELIOS_SESSION_ISSUER,
+  assertHeliosBaseUrl,
+  isSameHeliosIssuer,
+  retryAfterUnauthorizedRefresh,
+  HOSTED_RECONNECT_MESSAGE,
+  HeliosAgentMcpAuthService,
+  formatHeliosLoginPrompt,
+  HeliosAgentMcpAccountService,
+  HeliosAgentMcpDocsService,
+  getDefaultHeliosAgentMcpDocsRoot,
+  HeliosAgentMcpLedgerService,
+  DEFAULT_SNAPSHOT_TOP,
+  DEFAULT_SNAPSHOT_FIELDS,
+  withSnapshotDefaults,
+  topOfSnapshot,
+  compactSymbolDetail,
+  HeliosAgentMcpMarketService,
+  HeliosAgentMcpProviderService,
+  getDefaultHeliosAgentMcpSessionPath,
+  pendingAgentLoginSchema2 as pendingAgentLoginSchema,
+  FileAgentSessionStore,
+  MemoryAgentMcpSessionStore,
+  HeliosAgentMcpTradingService,
+  usd,
+  pct,
+  price,
+  ago,
+  trader,
+  moveText,
+  entryText,
+  renderMarket,
+  renderBoard,
+  renderMoves,
+  renderCoin,
+  renderAccount,
+  positionLine,
+  renderTrades,
+  renderCandles,
+  smBoardInputSchema,
+  smMovesInputSchema,
+  smCoinInputSchema,
+  marketInputSchema,
+  accountInputSchema,
+  tradeInputSchema,
+  TRADE_KEY_WINDOW_SECONDS,
+  tradeKeyFor,
+  protectInputSchema,
+  tradesInputSchema,
+  candlesInputSchema,
+  wrongSideTpSl,
+  createLeanToolDefinitions,
+  leanToolsFor,
+  createHeliosDocsToolDefinitions,
+  createHeliosAuthToolDefinitions,
+  createHeliosProviderToolDefinitions,
+  createHeliosAccountToolDefinitions,
+  createHeliosLedgerToolDefinitions,
+  createHeliosMarketToolDefinitions,
+  createHeliosTradingToolDefinitions,
+  MCP_PROFILES,
+  MAX_TOOL_INPUT_ELEMENTS,
+  createHeliosAgentMcpServer,
+  toolAnnotations,
+  withDataText
+};