opentool 0.8.1 → 0.8.4

package/dist/index.js

@@ -14,6 +14,7 @@ import { createAccount } from '@turnkey/viem';
 import { encode } from '@msgpack/msgpack';
 import { keccak_256 } from '@noble/hashes/sha3';
 import { hexToBytes, concatBytes, bytesToHex } from '@noble/hashes/utils';
+import { createHmac, randomBytes } from 'crypto';
 import { tmpdir } from 'os';
 import { build } from 'esbuild';
 import { createRequire } from 'module';
@@ -1479,6 +1480,29 @@ async function createTurnkeyProvider(config) {
   };
 }
 
+// src/wallet/env.ts
+function readTrimmed(name) {
+  const value = process.env[name];
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  return trimmed.length ? trimmed : void 0;
+}
+function readTurnkeyEnv() {
+  const suborgId = readTrimmed("TURNKEY_SUBORG_ID");
+  if (!suborgId) return void 0;
+  const apiPublicKey = readTrimmed("TURNKEY_API_PUBLIC_KEY");
+  const apiPrivateKey = readTrimmed("TURNKEY_API_PRIVATE_KEY");
+  const signWith = readTrimmed("TURNKEY_WALLET_ADDRESS");
+  if (!apiPublicKey || !apiPrivateKey || !signWith) return void 0;
+  const apiBaseUrl = readTrimmed("TURNKEY_API_BASE_URL");
+  return {
+    organizationId: suborgId,
+    apiPublicKey,
+    apiPrivateKey,
+    signWith,
+    ...apiBaseUrl ? { apiBaseUrl } : {}
+  };
+}
+
 // src/wallet/index.ts
 function resolveChainSlug(reference) {
   if (reference === void 0) {
@@ -1522,22 +1546,9 @@ function getRpcUrl(chain, options) {
 }
 async function wallet(options = {}) {
   const envPrivateKey = process.env.PRIVATE_KEY?.trim();
-  const envTurnkey = {
-    organizationId: process.env.TURNKEY_SUBORG_ID?.trim(),
-    apiPublicKey: process.env.TURNKEY_API_PUBLIC_KEY?.trim(),
-    apiPrivateKey: process.env.TURNKEY_API_PRIVATE_KEY?.trim(),
-    signWith: process.env.TURNKEY_WALLET_ADDRESS?.trim(),
-    apiBaseUrl: process.env.TURNKEY_API_BASE_URL?.trim()
-  };
+  const envTurnkey = readTurnkeyEnv();
   const effectivePrivateKey = options.privateKey ?? envPrivateKey;
-  const hasTurnkeyEnv = envTurnkey.organizationId && envTurnkey.apiPublicKey && envTurnkey.apiPrivateKey && envTurnkey.signWith;
-  const effectiveTurnkey = options.turnkey ?? (hasTurnkeyEnv ? {
-    organizationId: envTurnkey.organizationId,
-    apiPublicKey: envTurnkey.apiPublicKey,
-    apiPrivateKey: envTurnkey.apiPrivateKey,
-    signWith: envTurnkey.signWith,
-    ...envTurnkey.apiBaseUrl ? { apiBaseUrl: envTurnkey.apiBaseUrl } : {}
-  } : void 0);
+  const effectiveTurnkey = options.turnkey ?? envTurnkey;
   if (effectivePrivateKey && effectiveTurnkey) {
     throw new Error("wallet() cannot be initialized with both privateKey and turnkey credentials");
   }
@@ -1639,6 +1650,38 @@ function resolveConfig(options) {
   }
   return { baseUrl: normalizedBaseUrl, apiKey, fetchFn };
 }
+async function requestJson(url, options, init) {
+  const { apiKey, fetchFn } = resolveConfig(options);
+  const response = await fetchFn(url, {
+    ...init,
+    headers: {
+      "content-type": "application/json",
+      "openpond-api-key": apiKey,
+      ...init.headers ?? {}
+    }
+  });
+  if (!response.ok) {
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      body = await response.text().catch(() => void 0);
+    }
+    throw new StoreError(
+      `Request failed with status ${response.status}`,
+      response.status,
+      body
+    );
+  }
+  if (response.status === 204) {
+    return null;
+  }
+  try {
+    return await response.json();
+  } catch {
+    return await response.text().catch(() => null);
+  }
+}
 async function store(input, options) {
   const { baseUrl, apiKey, fetchFn } = resolveConfig(options);
   const url = `${baseUrl}/apps/positions/tx`;
@@ -1721,6 +1764,34 @@ async function retrieve(params, options) {
   }
   return data;
 }
+async function getMyTools(options) {
+  const { baseUrl } = resolveConfig(options);
+  const url = `${baseUrl}/apps/tools`;
+  const data = await requestJson(url, options, { method: "GET" });
+  return data;
+}
+async function getMyPerformance(options) {
+  const { baseUrl } = resolveConfig(options);
+  const url = `${baseUrl}/apps/performance`;
+  return requestJson(url, options, { method: "GET" });
+}
+async function postAgentDigest(input, options) {
+  const { baseUrl } = resolveConfig(options);
+  const url = `${baseUrl}/apps/agent/digest`;
+  return requestJson(url, options, {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+}
+async function executeTool(input, options) {
+  const { baseUrl } = resolveConfig(options);
+  const url = `${baseUrl}/apps/tools/execute`;
+  const data = await requestJson(url, options, {
+    method: "POST",
+    body: JSON.stringify(input)
+  });
+  return data;
+}
 var CACHE_TTL_MS = 5 * 60 * 1e3;
 var API_BASES = {
   mainnet: "https://api.hyperliquid.xyz",
@@ -1957,6 +2028,37 @@ async function signApproveBuilderFee(args) {
   });
   return splitSignature(signatureHex);
 }
+async function signUserPortfolioMargin(args) {
+  const { wallet: wallet2, action } = args;
+  const domain = {
+    name: "HyperliquidSignTransaction",
+    version: "1",
+    chainId: Number.parseInt(action.signatureChainId, 16),
+    verifyingContract: ZERO_ADDRESS
+  };
+  const message = {
+    enabled: action.enabled,
+    hyperliquidChain: action.hyperliquidChain,
+    user: action.user,
+    nonce: BigInt(action.nonce)
+  };
+  const types = {
+    "HyperliquidTransaction:UserPortfolioMargin": [
+      { name: "enabled", type: "bool" },
+      { name: "hyperliquidChain", type: "string" },
+      { name: "user", type: "address" },
+      { name: "nonce", type: "uint64" }
+    ]
+  };
+  const signatureHex = await wallet2.walletClient.signTypedData({
+    account: wallet2.account,
+    domain,
+    types,
+    primaryType: "HyperliquidTransaction:UserPortfolioMargin",
+    message
+  });
+  return splitSignature(signatureHex);
+}
 function splitSignature(signature) {
   const cleaned = signature.slice(2);
   const rHex = `0x${cleaned.slice(0, 64)}`;
@@ -2025,6 +2127,181 @@ function assertPositiveNumber(value, label) {
   }
 }
 
+// src/adapters/hyperliquid/info.ts
+async function postInfo(environment, payload) {
+  const baseUrl = API_BASES[environment];
+  const response = await fetch(`${baseUrl}/info`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+  const data = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new HyperliquidApiError(
+      "Hyperliquid info request failed.",
+      data ?? { status: response.status }
+    );
+  }
+  return data;
+}
+var HyperliquidInfoClient = class {
+  constructor(environment = "mainnet") {
+    this.environment = environment;
+  }
+  meta() {
+    return fetchHyperliquidMeta(this.environment);
+  }
+  metaAndAssetCtxs() {
+    return fetchHyperliquidMetaAndAssetCtxs(this.environment);
+  }
+  spotMeta() {
+    return fetchHyperliquidSpotMeta(this.environment);
+  }
+  spotMetaAndAssetCtxs() {
+    return fetchHyperliquidSpotMetaAndAssetCtxs(this.environment);
+  }
+  assetCtxs() {
+    return fetchHyperliquidAssetCtxs(this.environment);
+  }
+  spotAssetCtxs() {
+    return fetchHyperliquidSpotAssetCtxs(this.environment);
+  }
+  openOrders(user) {
+    return fetchHyperliquidOpenOrders({ user, environment: this.environment });
+  }
+  frontendOpenOrders(user) {
+    return fetchHyperliquidFrontendOpenOrders({
+      user,
+      environment: this.environment
+    });
+  }
+  orderStatus(user, oid) {
+    return fetchHyperliquidOrderStatus({
+      user,
+      oid,
+      environment: this.environment
+    });
+  }
+  historicalOrders(user) {
+    return fetchHyperliquidHistoricalOrders({
+      user,
+      environment: this.environment
+    });
+  }
+  userFills(user) {
+    return fetchHyperliquidUserFills({ user, environment: this.environment });
+  }
+  userFillsByTime(user, startTime, endTime) {
+    return fetchHyperliquidUserFillsByTime({
+      user,
+      startTime,
+      endTime,
+      environment: this.environment
+    });
+  }
+  userRateLimit(user) {
+    return fetchHyperliquidUserRateLimit({
+      user,
+      environment: this.environment
+    });
+  }
+  preTransferCheck(user, source) {
+    return fetchHyperliquidPreTransferCheck({
+      user,
+      source,
+      environment: this.environment
+    });
+  }
+  spotClearinghouseState(user) {
+    return fetchHyperliquidSpotClearinghouseState({
+      user,
+      environment: this.environment
+    });
+  }
+};
+async function fetchHyperliquidMeta(environment = "mainnet") {
+  return postInfo(environment, { type: "meta" });
+}
+async function fetchHyperliquidMetaAndAssetCtxs(environment = "mainnet") {
+  return postInfo(environment, { type: "metaAndAssetCtxs" });
+}
+async function fetchHyperliquidSpotMeta(environment = "mainnet") {
+  return postInfo(environment, { type: "spotMeta" });
+}
+async function fetchHyperliquidSpotMetaAndAssetCtxs(environment = "mainnet") {
+  return postInfo(environment, { type: "spotMetaAndAssetCtxs" });
+}
+async function fetchHyperliquidAssetCtxs(environment = "mainnet") {
+  return postInfo(environment, { type: "assetCtxs" });
+}
+async function fetchHyperliquidSpotAssetCtxs(environment = "mainnet") {
+  return postInfo(environment, { type: "spotAssetCtxs" });
+}
+async function fetchHyperliquidOpenOrders(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, { type: "openOrders", user: normalizeAddress(params.user) });
+}
+async function fetchHyperliquidFrontendOpenOrders(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, {
+    type: "frontendOpenOrders",
+    user: normalizeAddress(params.user)
+  });
+}
+async function fetchHyperliquidOrderStatus(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, {
+    type: "orderStatus",
+    user: normalizeAddress(params.user),
+    oid: params.oid
+  });
+}
+async function fetchHyperliquidHistoricalOrders(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, {
+    type: "historicalOrders",
+    user: normalizeAddress(params.user)
+  });
+}
+async function fetchHyperliquidUserFills(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, {
+    type: "userFills",
+    user: normalizeAddress(params.user)
+  });
+}
+async function fetchHyperliquidUserFillsByTime(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, {
+    type: "userFillsByTime",
+    user: normalizeAddress(params.user),
+    startTime: params.startTime,
+    endTime: params.endTime
+  });
+}
+async function fetchHyperliquidUserRateLimit(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, {
+    type: "userRateLimit",
+    user: normalizeAddress(params.user)
+  });
+}
+async function fetchHyperliquidPreTransferCheck(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, {
+    type: "preTransferCheck",
+    user: normalizeAddress(params.user),
+    source: normalizeAddress(params.source)
+  });
+}
+async function fetchHyperliquidSpotClearinghouseState(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, {
+    type: "spotClearinghouseState",
+    user: normalizeAddress(params.user)
+  });
+}
+
 // src/adapters/hyperliquid/exchange.ts
 var HyperliquidExchangeClient = class {
   constructor(args) {
@@ -2157,7 +2434,58 @@ var HyperliquidExchangeClient = class {
       ...params
     });
   }
+  setPortfolioMargin(params) {
+    const base2 = {
+      wallet: this.wallet,
+      enabled: params.enabled,
+      environment: this.environment,
+      vaultAddress: this.vaultAddress,
+      expiresAfter: this.expiresAfter,
+      nonceSource: this.nonceSource
+    };
+    return setHyperliquidPortfolioMargin(
+      params.user ? { ...base2, user: params.user } : base2
+    );
+  }
 };
+async function setHyperliquidPortfolioMargin(options) {
+  const env = options.environment ?? "mainnet";
+  if (!options.wallet?.account || !options.wallet.walletClient) {
+    throw new Error(
+      "Wallet with signing capability is required for portfolio margin."
+    );
+  }
+  const nonce = options.nonce ?? options.walletNonceProvider?.() ?? options.wallet.nonceSource?.() ?? options.nonceSource?.() ?? Date.now();
+  const signatureChainId = getSignatureChainId(env);
+  const hyperliquidChain = HL_CHAIN_LABEL[env];
+  const user = normalizeAddress(
+    options.user ?? options.wallet.address
+  );
+  const action = {
+    type: "userPortfolioMargin",
+    enabled: Boolean(options.enabled),
+    hyperliquidChain,
+    signatureChainId,
+    user,
+    nonce
+  };
+  const signature = await signUserPortfolioMargin({
+    wallet: options.wallet,
+    action
+  });
+  const body = {
+    action,
+    nonce,
+    signature
+  };
+  if (options.vaultAddress) {
+    body.vaultAddress = normalizeAddress(options.vaultAddress);
+  }
+  if (typeof options.expiresAfter === "number") {
+    body.expiresAfter = options.expiresAfter;
+  }
+  return postExchange(env, body);
+}
 async function cancelHyperliquidOrders(options) {
   options.cancels.forEach((c) => assertSymbol(c.symbol));
   const action = {
@@ -2474,198 +2802,43 @@ function assertPositiveDecimal(value, label) {
   }
   assertString(value, label);
 }
-async function postExchange(env, body) {
-  const response = await fetch(`${API_BASES[env]}/exchange`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify(body)
-  });
-  const json = await response.json().catch(() => null);
-  if (!response.ok || !json) {
-    throw new HyperliquidApiError(
-      "Hyperliquid exchange action failed.",
-      json ?? { status: response.status }
-    );
-  }
-  if (json.status !== "ok") {
-    throw new HyperliquidApiError("Hyperliquid exchange returned error.", json);
-  }
-  return json;
-}
-
-// src/adapters/hyperliquid/info.ts
-async function postInfo(environment, payload) {
-  const baseUrl = API_BASES[environment];
-  const response = await fetch(`${baseUrl}/info`, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify(payload)
-  });
-  const data = await response.json().catch(() => null);
-  if (!response.ok) {
-    throw new HyperliquidApiError(
-      "Hyperliquid info request failed.",
-      data ?? { status: response.status }
-    );
-  }
-  return data;
-}
-var HyperliquidInfoClient = class {
-  constructor(environment = "mainnet") {
-    this.environment = environment;
-  }
-  meta() {
-    return fetchHyperliquidMeta(this.environment);
-  }
-  metaAndAssetCtxs() {
-    return fetchHyperliquidMetaAndAssetCtxs(this.environment);
-  }
-  spotMeta() {
-    return fetchHyperliquidSpotMeta(this.environment);
-  }
-  spotMetaAndAssetCtxs() {
-    return fetchHyperliquidSpotMetaAndAssetCtxs(this.environment);
-  }
-  assetCtxs() {
-    return fetchHyperliquidAssetCtxs(this.environment);
-  }
-  spotAssetCtxs() {
-    return fetchHyperliquidSpotAssetCtxs(this.environment);
-  }
-  openOrders(user) {
-    return fetchHyperliquidOpenOrders({ user, environment: this.environment });
-  }
-  frontendOpenOrders(user) {
-    return fetchHyperliquidFrontendOpenOrders({
-      user,
-      environment: this.environment
-    });
-  }
-  orderStatus(user, oid) {
-    return fetchHyperliquidOrderStatus({
-      user,
-      oid,
-      environment: this.environment
-    });
-  }
-  historicalOrders(user) {
-    return fetchHyperliquidHistoricalOrders({
-      user,
-      environment: this.environment
-    });
-  }
-  userFills(user) {
-    return fetchHyperliquidUserFills({ user, environment: this.environment });
-  }
-  userFillsByTime(user, startTime, endTime) {
-    return fetchHyperliquidUserFillsByTime({
-      user,
-      startTime,
-      endTime,
-      environment: this.environment
-    });
-  }
-  userRateLimit(user) {
-    return fetchHyperliquidUserRateLimit({
-      user,
-      environment: this.environment
-    });
-  }
-  preTransferCheck(user, source) {
-    return fetchHyperliquidPreTransferCheck({
-      user,
-      source,
-      environment: this.environment
-    });
-  }
-  spotClearinghouseState(user) {
-    return fetchHyperliquidSpotClearinghouseState({
-      user,
-      environment: this.environment
-    });
-  }
-};
-async function fetchHyperliquidMeta(environment = "mainnet") {
-  return postInfo(environment, { type: "meta" });
-}
-async function fetchHyperliquidMetaAndAssetCtxs(environment = "mainnet") {
-  return postInfo(environment, { type: "metaAndAssetCtxs" });
-}
-async function fetchHyperliquidSpotMeta(environment = "mainnet") {
-  return postInfo(environment, { type: "spotMeta" });
-}
-async function fetchHyperliquidSpotMetaAndAssetCtxs(environment = "mainnet") {
-  return postInfo(environment, { type: "spotMetaAndAssetCtxs" });
-}
-async function fetchHyperliquidAssetCtxs(environment = "mainnet") {
-  return postInfo(environment, { type: "assetCtxs" });
-}
-async function fetchHyperliquidSpotAssetCtxs(environment = "mainnet") {
-  return postInfo(environment, { type: "spotAssetCtxs" });
-}
-async function fetchHyperliquidOpenOrders(params) {
-  const env = params.environment ?? "mainnet";
-  return postInfo(env, { type: "openOrders", user: normalizeAddress(params.user) });
-}
-async function fetchHyperliquidFrontendOpenOrders(params) {
-  const env = params.environment ?? "mainnet";
-  return postInfo(env, {
-    type: "frontendOpenOrders",
-    user: normalizeAddress(params.user)
-  });
-}
-async function fetchHyperliquidOrderStatus(params) {
-  const env = params.environment ?? "mainnet";
-  return postInfo(env, {
-    type: "orderStatus",
-    user: normalizeAddress(params.user),
-    oid: params.oid
-  });
-}
-async function fetchHyperliquidHistoricalOrders(params) {
-  const env = params.environment ?? "mainnet";
-  return postInfo(env, {
-    type: "historicalOrders",
-    user: normalizeAddress(params.user)
-  });
-}
-async function fetchHyperliquidUserFills(params) {
-  const env = params.environment ?? "mainnet";
-  return postInfo(env, {
-    type: "userFills",
-    user: normalizeAddress(params.user)
-  });
-}
-async function fetchHyperliquidUserFillsByTime(params) {
-  const env = params.environment ?? "mainnet";
-  return postInfo(env, {
-    type: "userFillsByTime",
-    user: normalizeAddress(params.user),
-    startTime: params.startTime,
-    endTime: params.endTime
-  });
-}
-async function fetchHyperliquidUserRateLimit(params) {
-  const env = params.environment ?? "mainnet";
-  return postInfo(env, {
-    type: "userRateLimit",
-    user: normalizeAddress(params.user)
-  });
-}
-async function fetchHyperliquidPreTransferCheck(params) {
-  const env = params.environment ?? "mainnet";
-  return postInfo(env, {
-    type: "preTransferCheck",
-    user: normalizeAddress(params.user),
-    source: normalizeAddress(params.source)
-  });
-}
-async function fetchHyperliquidSpotClearinghouseState(params) {
-  const env = params.environment ?? "mainnet";
-  return postInfo(env, {
-    type: "spotClearinghouseState",
-    user: normalizeAddress(params.user)
+async function postExchange(env, body) {
+  const response = await fetch(`${API_BASES[env]}/exchange`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
   });
+  const text = await response.text().catch(() => "");
+  const json = (() => {
+    if (!text) return null;
+    try {
+      return JSON.parse(text);
+    } catch {
+      return null;
+    }
+  })();
+  if (!response.ok) {
+    throw new HyperliquidApiError("Hyperliquid exchange action failed.", {
+      status: response.status,
+      statusText: response.statusText,
+      body: json ?? (text ? text : null)
+    });
+  }
+  if (!json) {
+    throw new HyperliquidApiError("Hyperliquid exchange action failed.", {
+      status: response.status,
+      statusText: response.statusText,
+      body: text ? text : null
+    });
+  }
+  if (json.status !== "ok") {
+    throw new HyperliquidApiError("Hyperliquid exchange returned error.", {
+      status: response.status,
+      statusText: response.statusText,
+      body: json
+    });
+  }
+  return json;
 }
 
 // src/adapters/hyperliquid/index.ts
@@ -3055,6 +3228,833 @@ var __hyperliquidInternals = {
   createL1ActionHash,
   splitSignature
 };
+var PolymarketApiError = class extends Error {
+  constructor(message, response) {
+    super(message);
+    this.response = response;
+    this.name = "PolymarketApiError";
+  }
+};
+var PolymarketAuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PolymarketAuthError";
+  }
+};
+var POLYMARKET_ENDPOINTS = {
+  gamma: {
+    mainnet: "https://gamma-api.polymarket.com",
+    testnet: "https://gamma-api.polymarket.com"
+  },
+  clob: {
+    mainnet: "https://clob.polymarket.com",
+    testnet: "https://clob.polymarket.com"
+  },
+  data: {
+    mainnet: "https://data-api.polymarket.com",
+    testnet: "https://data-api.polymarket.com"
+  }
+};
+var POLYMARKET_CHAIN_ID = {
+  mainnet: 137,
+  testnet: 80002
+};
+var POLYMARKET_EXCHANGE_ADDRESSES = {
+  mainnet: {
+    ctf: "0x4bfb41d5b3570defd03c39a9a4d8de6bd8b8982e",
+    negRisk: "0xc5d563a36ae78145c45a50134d48a1215220f80a"
+  },
+  testnet: {
+    ctf: "0xdfe02eb6733538f8ea35d585af8de5958ad99e40",
+    negRisk: "0xdfe02eb6733538f8ea35d585af8de5958ad99e40"
+  }
+};
+var POLYMARKET_CLOB_DOMAIN = {
+  name: "Polymarket CTF Exchange",
+  version: "1"
+};
+var POLYMARKET_CLOB_AUTH_DOMAIN = {
+  name: "ClobAuthDomain",
+  version: "1"
+};
+var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
+function resolvePolymarketBaseUrl(service, environment) {
+  return POLYMARKET_ENDPOINTS[service][environment];
+}
+function assertWalletSigner(wallet2) {
+  if (!wallet2?.account || !wallet2.walletClient) {
+    throw new Error("Polymarket requires a wallet with signing capabilities.");
+  }
+}
+function toDecimalString2(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "bigint") return value.toString();
+  if (!Number.isFinite(value)) {
+    throw new Error("Numeric values must be finite.");
+  }
+  const asString = value.toString();
+  if (/e/i.test(asString)) {
+    const [mantissa, exponentPart] = asString.split(/e/i);
+    const exponent = Number(exponentPart);
+    const [integerPart, fractionalPart = ""] = mantissa.split(".");
+    if (exponent >= 0) {
+      return integerPart + fractionalPart.padEnd(exponent + fractionalPart.length, "0");
+    }
+    const zeros = "0".repeat(Math.abs(exponent) - 1);
+    return `0.${zeros}${integerPart}${fractionalPart}`.replace(/\.0+$/, "");
+  }
+  return asString;
+}
+function normalizeArrayish(value) {
+  if (Array.isArray(value)) return value;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return [];
+    if (trimmed.startsWith("[")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        return Array.isArray(parsed) ? parsed : [];
+      } catch {
+        return [];
+      }
+    }
+    return [trimmed];
+  }
+  return [];
+}
+function normalizeStringArrayish(value) {
+  return normalizeArrayish(value).map((entry) => entry == null ? "" : String(entry).trim()).filter((entry) => entry.length > 0);
+}
+function normalizeNumberArrayish(value) {
+  return normalizeArrayish(value).map(
+    (entry) => typeof entry === "number" ? entry : Number.parseFloat(String(entry))
+  ).filter((entry) => Number.isFinite(entry));
+}
+function normalizeTags(value) {
+  if (!Array.isArray(value)) return [];
+  const tags = value.map((entry) => {
+    if (entry && typeof entry === "object") {
+      const record = entry;
+      const label = record.label ?? record.id ?? record.tag;
+      return label ? String(label).trim() : "";
+    }
+    return String(entry ?? "").trim();
+  }).filter((entry) => entry.length > 0);
+  return Array.from(new Set(tags));
+}
+function parseOptionalDate(value) {
+  if (!value) return null;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const ts = value > 1e12 ? value : value * 1e3;
+    const date = new Date(ts);
+    return Number.isNaN(date.getTime()) ? null : date.toISOString();
+  }
+  return null;
+}
+function buildHmacSignature(args) {
+  const timestamp2 = args.timestamp.toString();
+  const method = args.method.toUpperCase();
+  const path7 = args.path;
+  const body = args.body == null ? "" : typeof args.body === "string" ? args.body : JSON.stringify(args.body);
+  const payload = `${timestamp2}${method}${path7}${body}`;
+  const key = Buffer.from(args.secret, "base64");
+  return createHmac("sha256", key).update(payload).digest("hex");
+}
+function buildL2Headers(args) {
+  const timestamp2 = args.timestamp ?? Math.floor(Date.now() / 1e3);
+  const signature = buildHmacSignature({
+    secret: args.credentials.secret,
+    timestamp: timestamp2,
+    method: args.method,
+    path: args.path,
+    body: args.body ?? null
+  });
+  return {
+    POLY_ADDRESS: args.address,
+    POLY_API_KEY: args.credentials.apiKey,
+    POLY_PASSPHRASE: args.credentials.passphrase,
+    POLY_TIMESTAMP: timestamp2.toString(),
+    POLY_SIGNATURE: signature
+  };
+}
+async function buildL1Headers(args) {
+  assertWalletSigner(args.wallet);
+  const timestamp2 = args.timestamp ?? Math.floor(Date.now() / 1e3);
+  const nonce = args.nonce ?? Date.now();
+  const chainId = POLYMARKET_CHAIN_ID[args.environment ?? "mainnet"];
+  const address = args.wallet.address;
+  const message = args.message ?? "Create or derive a Polymarket API key";
+  const signature = await args.wallet.walletClient.signTypedData({
+    account: args.wallet.account,
+    domain: {
+      ...POLYMARKET_CLOB_AUTH_DOMAIN,
+      chainId
+    },
+    types: {
+      ClobAuth: [
+        { name: "address", type: "address" },
+        { name: "timestamp", type: "string" },
+        { name: "nonce", type: "uint256" },
+        { name: "message", type: "string" }
+      ]
+    },
+    primaryType: "ClobAuth",
+    message: {
+      address,
+      timestamp: timestamp2.toString(),
+      nonce: BigInt(nonce),
+      message
+    }
+  });
+  return {
+    POLY_ADDRESS: address,
+    POLY_TIMESTAMP: timestamp2.toString(),
+    POLY_NONCE: nonce.toString(),
+    POLY_SIGNATURE: signature
+  };
+}
+function resolveExchangeAddress(args) {
+  if (args.exchangeAddress) return args.exchangeAddress;
+  const env = args.environment;
+  return args.negRisk ? POLYMARKET_EXCHANGE_ADDRESSES[env].negRisk : POLYMARKET_EXCHANGE_ADDRESSES[env].ctf;
+}
+function parseUintString(value, name) {
+  const trimmed = value.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    throw new Error(`${name} must be a base-10 integer string.`);
+  }
+  return BigInt(trimmed);
+}
+function buildPolymarketOrderAmounts(args) {
+  const priceStr = toDecimalString2(args.price);
+  const sizeStr = toDecimalString2(args.size);
+  if (!priceStr || !sizeStr) {
+    throw new Error("Order price and size are required.");
+  }
+  const priceFloat = Number(priceStr);
+  if (!Number.isFinite(priceFloat) || priceFloat <= 0 || priceFloat >= 1) {
+    throw new Error("Order price must be between 0 and 1 (exclusive).");
+  }
+  const sizeFloat = Number(sizeStr);
+  if (!Number.isFinite(sizeFloat) || sizeFloat <= 0) {
+    throw new Error("Order size must be positive.");
+  }
+  let priceUnits = parseUnits(priceStr, 6);
+  if (args.tickSize !== void 0) {
+    const tickUnits = parseUnits(toDecimalString2(args.tickSize), 6);
+    if (tickUnits <= 0n) {
+      throw new Error("tickSize must be positive.");
+    }
+    priceUnits = priceUnits / tickUnits * tickUnits;
+  }
+  const sizeUnits = parseUnits(sizeStr, 6);
+  const quoteUnits = priceUnits * sizeUnits / 1000000n;
+  if (args.side === "BUY") {
+    return { makerAmount: quoteUnits, takerAmount: sizeUnits };
+  }
+  return { makerAmount: sizeUnits, takerAmount: quoteUnits };
+}
+async function buildSignedOrderPayload(args) {
+  assertWalletSigner(args.wallet);
+  const environment = args.environment ?? "mainnet";
+  const chainId = POLYMARKET_CHAIN_ID[environment];
+  const exchangeAddress = resolveExchangeAddress({
+    environment,
+    ...args.negRisk !== void 0 ? { negRisk: args.negRisk } : {},
+    ...args.exchangeAddress ? { exchangeAddress: args.exchangeAddress } : {}
+  });
+  const maker = args.maker ?? args.wallet.address;
+  const signer = args.signer ?? args.wallet.address;
+  const taker = args.taker ?? ZERO_ADDRESS2;
+  const sideValue = args.side === "BUY" ? 0 : 1;
+  const signatureType = args.signatureType ?? 0;
+  const tokenIdValue = args.tokenId.startsWith("0x") ? BigInt(args.tokenId) : parseUintString(args.tokenId, "tokenId");
+  const { makerAmount, takerAmount } = buildPolymarketOrderAmounts({
+    side: args.side,
+    price: args.price,
+    size: args.size,
+    ...args.tickSize !== void 0 ? { tickSize: args.tickSize } : {}
+  });
+  const salt = BigInt(`0x${randomBytes(16).toString("hex")}`);
+  const expiration = BigInt(args.expiration ?? 0);
+  const nonce = BigInt(args.nonce ?? 0);
+  const feeRateBps = BigInt(args.feeRateBps ?? 0);
+  const message = {
+    salt,
+    maker,
+    signer,
+    taker,
+    tokenId: tokenIdValue,
+    makerAmount,
+    takerAmount,
+    expiration,
+    nonce,
+    feeRateBps,
+    side: sideValue,
+    signatureType
+  };
+  const signature = await args.wallet.walletClient.signTypedData({
+    account: args.wallet.account,
+    domain: {
+      ...POLYMARKET_CLOB_DOMAIN,
+      chainId,
+      verifyingContract: exchangeAddress
+    },
+    types: {
+      Order: [
+        { name: "salt", type: "uint256" },
+        { name: "maker", type: "address" },
+        { name: "signer", type: "address" },
+        { name: "taker", type: "address" },
+        { name: "tokenId", type: "uint256" },
+        { name: "makerAmount", type: "uint256" },
+        { name: "takerAmount", type: "uint256" },
+        { name: "expiration", type: "uint256" },
+        { name: "nonce", type: "uint256" },
+        { name: "feeRateBps", type: "uint256" },
+        { name: "side", type: "uint8" },
+        { name: "signatureType", type: "uint8" }
+      ]
+    },
+    primaryType: "Order",
+    message
+  });
+  return {
+    salt: message.salt.toString(),
+    maker,
+    signer,
+    taker,
+    tokenId: tokenIdValue.toString(),
+    makerAmount: message.makerAmount.toString(),
+    takerAmount: message.takerAmount.toString(),
+    expiration: message.expiration.toString(),
+    nonce: message.nonce.toString(),
+    feeRateBps: message.feeRateBps.toString(),
+    side: sideValue,
+    signatureType,
+    signature
+  };
+}
+
+// src/adapters/polymarket/exchange.ts
+async function resolveAuthContext(args) {
+  if (args.wallet) {
+    const credentials = args.credentials ?? await createPolymarketApiKey({
+      wallet: args.wallet,
+      ...args.environment ? { environment: args.environment } : {}
+    });
+    return {
+      credentials,
+      address: args.wallet.address
+    };
+  }
+  if (args.walletAddress && args.credentials) {
+    return { credentials: args.credentials, address: args.walletAddress };
+  }
+  throw new PolymarketAuthError(
+    "Polymarket auth requires a wallet (preferred) or credentials + walletAddress."
+  );
+}
+async function requestJson2(url, init) {
+  const response = await fetch(url, init);
+  const text = await response.text().catch(() => "");
+  let data = null;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    data = text;
+  }
+  if (!response.ok) {
+    throw new PolymarketApiError(
+      `Polymarket request failed (${response.status}).`,
+      data ?? { status: response.status }
+    );
+  }
+  return data;
+}
+function resolvePath(url) {
+  const parsed = new URL(url);
+  return `${parsed.pathname}${parsed.search}`;
+}
+async function createPolymarketApiKey(args) {
+  const environment = args.environment ?? "mainnet";
+  const baseUrl = resolvePolymarketBaseUrl("clob", environment);
+  const url = `${baseUrl}/auth/api-key`;
+  const headers = await buildL1Headers({
+    wallet: args.wallet,
+    environment,
+    ...args.timestamp !== void 0 ? { timestamp: args.timestamp } : {},
+    ...args.nonce !== void 0 ? { nonce: args.nonce } : {},
+    ...args.message !== void 0 ? { message: args.message } : {}
+  });
+  const data = await requestJson2(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...headers
+    },
+    body: JSON.stringify({})
+  });
+  if (!data?.apiKey || !data?.secret || !data?.passphrase) {
+    throw new PolymarketAuthError("Failed to create Polymarket API key.");
+  }
+  return {
+    apiKey: data.apiKey,
+    secret: data.secret,
+    passphrase: data.passphrase
+  };
+}
+async function derivePolymarketApiKey(args) {
+  const environment = args.environment ?? "mainnet";
+  const baseUrl = resolvePolymarketBaseUrl("clob", environment);
+  const url = `${baseUrl}/auth/derive-api-key`;
+  const headers = await buildL1Headers({
+    wallet: args.wallet,
+    environment,
+    ...args.timestamp !== void 0 ? { timestamp: args.timestamp } : {},
+    ...args.nonce !== void 0 ? { nonce: args.nonce } : {},
+    ...args.message !== void 0 ? { message: args.message } : {}
+  });
+  const data = await requestJson2(url, {
+    method: "GET",
+    headers: {
+      "content-type": "application/json",
+      ...headers
+    }
+  });
+  if (!data?.apiKey || !data?.secret || !data?.passphrase) {
+    throw new PolymarketAuthError("Failed to derive Polymarket API key.");
+  }
+  return {
+    apiKey: data.apiKey,
+    secret: data.secret,
+    passphrase: data.passphrase
+  };
+}
+async function placePolymarketOrder(args) {
+  const environment = args.environment ?? "mainnet";
+  const baseUrl = resolvePolymarketBaseUrl("clob", environment);
+  const url = `${baseUrl}/order`;
+  const signedOrder = await buildSignedOrderPayload({
+    wallet: args.wallet,
+    environment,
+    ...args.order
+  });
+  const auth = await resolveAuthContext({
+    wallet: args.wallet,
+    ...args.credentials ? { credentials: args.credentials } : {},
+    environment
+  });
+  const body = {
+    order: signedOrder,
+    owner: auth.credentials.apiKey,
+    orderType: args.orderType ?? "GTC"
+  };
+  const headers = buildL2Headers({
+    credentials: auth.credentials,
+    address: auth.address,
+    method: "POST",
+    path: resolvePath(url),
+    body
+  });
+  return await requestJson2(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...headers
+    },
+    body: JSON.stringify(body)
+  });
+}
+async function cancelPolymarketOrder(args) {
+  const environment = args.environment ?? "mainnet";
+  const baseUrl = resolvePolymarketBaseUrl("clob", environment);
+  const url = `${baseUrl}/order`;
+  const body = { orderID: args.orderId };
+  const auth = await resolveAuthContext({
+    ...args.wallet ? { wallet: args.wallet } : {},
+    ...args.walletAddress ? { walletAddress: args.walletAddress } : {},
+    ...args.credentials ? { credentials: args.credentials } : {},
+    environment
+  });
+  const headers = buildL2Headers({
+    credentials: auth.credentials,
+    address: auth.address,
+    method: "DELETE",
+    path: resolvePath(url),
+    body
+  });
+  return await requestJson2(url, {
+    method: "DELETE",
+    headers: {
+      "content-type": "application/json",
+      ...headers
+    },
+    body: JSON.stringify(body)
+  });
+}
+async function cancelPolymarketOrders(args) {
+  const environment = args.environment ?? "mainnet";
+  const baseUrl = resolvePolymarketBaseUrl("clob", environment);
+  const url = `${baseUrl}/orders`;
+  const body = { orderIDs: args.orderIds };
+  const auth = await resolveAuthContext({
+    ...args.wallet ? { wallet: args.wallet } : {},
+    ...args.walletAddress ? { walletAddress: args.walletAddress } : {},
+    ...args.credentials ? { credentials: args.credentials } : {},
+    environment
+  });
+  const headers = buildL2Headers({
+    credentials: auth.credentials,
+    address: auth.address,
+    method: "DELETE",
+    path: resolvePath(url),
+    body
+  });
+  return await requestJson2(url, {
+    method: "DELETE",
+    headers: {
+      "content-type": "application/json",
+      ...headers
+    },
+    body: JSON.stringify(body)
+  });
+}
+async function cancelAllPolymarketOrders(args) {
+  const environment = args.environment ?? "mainnet";
+  const baseUrl = resolvePolymarketBaseUrl("clob", environment);
+  const url = `${baseUrl}/cancel-all`;
+  const auth = await resolveAuthContext({
+    ...args.wallet ? { wallet: args.wallet } : {},
+    ...args.walletAddress ? { walletAddress: args.walletAddress } : {},
+    ...args.credentials ? { credentials: args.credentials } : {},
+    environment
+  });
+  const headers = buildL2Headers({
+    credentials: auth.credentials,
+    address: auth.address,
+    method: "DELETE",
+    path: resolvePath(url)
+  });
+  return await requestJson2(url, {
+    method: "DELETE",
+    headers: {
+      "content-type": "application/json",
+      ...headers
+    }
+  });
+}
+async function cancelMarketPolymarketOrders(args) {
+  const environment = args.environment ?? "mainnet";
+  const baseUrl = resolvePolymarketBaseUrl("clob", environment);
+  const url = `${baseUrl}/cancel-market-orders`;
+  const body = { market: args.tokenId };
+  const auth = await resolveAuthContext({
+    ...args.wallet ? { wallet: args.wallet } : {},
+    ...args.walletAddress ? { walletAddress: args.walletAddress } : {},
+    ...args.credentials ? { credentials: args.credentials } : {},
+    environment
+  });
+  const headers = buildL2Headers({
+    credentials: auth.credentials,
+    address: auth.address,
+    method: "DELETE",
+    path: resolvePath(url),
+    body
+  });
+  return await requestJson2(url, {
+    method: "DELETE",
+    headers: {
+      "content-type": "application/json",
+      ...headers
+    },
+    body: JSON.stringify(body)
+  });
+}
+var PolymarketExchangeClient = class {
+  constructor(args) {
+    this.wallet = args.wallet;
+    this.credentials = args.credentials;
+    this.environment = args.environment ?? "mainnet";
+  }
+  async getCredentials() {
+    if (this.cachedCredentials) return this.cachedCredentials;
+    const resolved = await resolveAuthContext({
+      wallet: this.wallet,
+      ...this.credentials ? { credentials: this.credentials } : {},
+      environment: this.environment
+    });
+    this.cachedCredentials = resolved.credentials;
+    return resolved.credentials;
+  }
+  async placeOrder(order, orderType) {
+    const credentials = await this.getCredentials();
+    return placePolymarketOrder({
+      wallet: this.wallet,
+      credentials,
+      environment: this.environment,
+      order,
+      ...orderType !== void 0 ? { orderType } : {}
+    });
+  }
+  async cancelOrder(orderId) {
+    const credentials = await this.getCredentials();
+    return cancelPolymarketOrder({
+      orderId,
+      wallet: this.wallet,
+      credentials,
+      environment: this.environment
+    });
+  }
+  async cancelOrders(orderIds) {
+    const credentials = await this.getCredentials();
+    return cancelPolymarketOrders({
+      orderIds,
+      wallet: this.wallet,
+      credentials,
+      environment: this.environment
+    });
+  }
+  async cancelAll() {
+    const credentials = await this.getCredentials();
+    return cancelAllPolymarketOrders({
+      wallet: this.wallet,
+      credentials,
+      environment: this.environment
+    });
+  }
+  async cancelMarket(tokenId) {
+    const credentials = await this.getCredentials();
+    return cancelMarketPolymarketOrders({
+      tokenId,
+      wallet: this.wallet,
+      credentials,
+      environment: this.environment
+    });
+  }
+};
+
+// src/adapters/polymarket/info.ts
+var DEFAULT_EVENT_LIMIT = 50;
+async function requestJson3(url, init) {
+  const response = await fetch(url, init);
+  const text = await response.text().catch(() => "");
+  let data = null;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    data = text;
+  }
+  if (!response.ok) {
+    throw new PolymarketApiError(
+      `Polymarket request failed (${response.status}).`,
+      data ?? { status: response.status }
+    );
+  }
+  return data;
+}
+function getString(value) {
+  if (value == null) return null;
+  const str = String(value).trim();
+  return str.length ? str : null;
+}
+function normalizeOrderbookLevels(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.map((entry) => {
+    if (Array.isArray(entry)) {
+      const [price, size] = entry;
+      const p = Number(price);
+      const s = Number(size);
+      if (!Number.isFinite(p) || !Number.isFinite(s)) return null;
+      return { price: p, size: s };
+    }
+    if (entry && typeof entry === "object") {
+      const record = entry;
+      const p = Number(record.price ?? record.p);
+      const s = Number(record.size ?? record.s ?? record.quantity);
+      if (!Number.isFinite(p) || !Number.isFinite(s)) return null;
+      return { price: p, size: s };
+    }
+    return null;
+  }).filter((entry) => Boolean(entry));
+}
+function normalizeGammaMarket(market, event) {
+  const eventTags = normalizeTags(event?.tags);
+  const marketTags = normalizeTags(market.tags);
+  const mergedTags = Array.from(/* @__PURE__ */ new Set([...marketTags, ...eventTags]));
+  const category = getString(market.category) ?? getString(event?.category) ?? getString(event?.title) ?? null;
+  const normalized = {
+    id: getString(market.id) ?? "",
+    slug: getString(market.slug),
+    question: getString(market.question),
+    description: getString(market.description),
+    eventId: getString(market.eventId ?? event?.id),
+    eventSlug: getString(event?.slug),
+    conditionId: getString(market.conditionId),
+    marketMakerAddress: getString(market.marketMakerAddress),
+    category,
+    startDate: parseOptionalDate(market.startDate) ?? parseOptionalDate(event?.startDate) ?? parseOptionalDate(event?.eventStartTime),
+    endDate: parseOptionalDate(market.endDate) ?? parseOptionalDate(event?.endDate) ?? parseOptionalDate(event?.eventEndTime),
+    createdAt: parseOptionalDate(market.createdAt) ?? parseOptionalDate(event?.createdAt) ?? parseOptionalDate(event?.creationDate),
+    updatedAt: parseOptionalDate(market.updatedAt) ?? parseOptionalDate(event?.updatedAt),
+    closedTime: parseOptionalDate(market.closedTime) ?? parseOptionalDate(event?.closedTime),
+    volume: getString(market.volume),
+    liquidity: getString(market.liquidity),
+    openInterest: getString(market.openInterest),
+    outcomes: normalizeStringArrayish(market.outcomes),
+    outcomePrices: normalizeNumberArrayish(market.outcomePrices),
+    clobTokenIds: normalizeStringArrayish(market.clobTokenIds),
+    icon: getString(market.icon),
+    image: getString(market.image)
+  };
+  if (mergedTags.length) {
+    normalized.tags = mergedTags;
+  }
+  if (typeof market.active === "boolean") {
+    normalized.active = market.active;
+  }
+  if (typeof market.closed === "boolean") {
+    normalized.closed = market.closed;
+  }
+  if (typeof market.resolved === "boolean") {
+    normalized.resolved = market.resolved;
+  }
+  return normalized;
+}
+var PolymarketInfoClient = class {
+  constructor(environment = "mainnet") {
+    this.environment = environment;
+  }
+  markets(params = {}) {
+    return fetchPolymarketMarkets({ ...params, environment: this.environment });
+  }
+  market(params) {
+    return fetchPolymarketMarket({ ...params, environment: this.environment });
+  }
+  orderbook(tokenId) {
+    return fetchPolymarketOrderbook({ tokenId, environment: this.environment });
+  }
+  price(tokenId, side) {
+    return fetchPolymarketPrice({ tokenId, side, environment: this.environment });
+  }
+  midpoint(tokenId) {
+    return fetchPolymarketMidpoint({ tokenId, environment: this.environment });
+  }
+  priceHistory(params) {
+    return fetchPolymarketPriceHistory({ ...params, environment: this.environment });
+  }
+};
+async function fetchPolymarketMarkets(params = {}) {
+  if (params.active !== void 0 && params.active !== true) {
+    throw new Error("Polymarket market list requires active=true.");
+  }
+  if (params.closed !== void 0 && params.closed !== false) {
+    throw new Error("Polymarket market list requires closed=false.");
+  }
+  const environment = params.environment ?? "mainnet";
+  const baseUrl = resolvePolymarketBaseUrl("gamma", environment);
+  const url = new URL("/events", baseUrl);
+  const limit = params.limit ?? DEFAULT_EVENT_LIMIT;
+  const offset = params.offset ?? 0;
+  url.searchParams.set("limit", String(limit));
+  url.searchParams.set("offset", String(offset));
+  url.searchParams.set("active", "true");
+  url.searchParams.set("closed", "false");
+  url.searchParams.set("order", params.order ?? "id");
+  url.searchParams.set("ascending", params.ascending ? "true" : "false");
+  if (params.tagId) url.searchParams.set("tag_id", params.tagId);
+  if (params.relatedTags) url.searchParams.set("related_tags", "true");
+  if (params.excludeTagId) url.searchParams.set("exclude_tag_id", params.excludeTagId);
+  if (params.slug) url.searchParams.set("slug", params.slug);
+  const data = await requestJson3(url.toString());
+  const markets = data.flatMap(
+    (event) => Array.isArray(event?.markets) ? event.markets.map(
+      (market) => normalizeGammaMarket(market, event)
+    ) : []
+  );
+  const filtered = params.category ? markets.filter(
+    (market) => (market.category ?? "").toLowerCase().includes(params.category.toLowerCase())
+  ) : markets;
+  return typeof params.limit === "number" ? filtered.slice(0, params.limit) : filtered;
+}
+async function fetchPolymarketMarket(params) {
+  const environment = params.environment ?? "mainnet";
+  const baseUrl = resolvePolymarketBaseUrl("gamma", environment);
+  if (params.slug) {
+    const url = new URL(`/markets/slug/${params.slug}`, baseUrl);
+    const data = await requestJson3(url.toString());
+    if (!data) return null;
+    return normalizeGammaMarket(data);
+  }
+  if (params.id) {
+    const url = new URL(`/markets/${params.id}`, baseUrl);
+    const data = await requestJson3(url.toString());
+    if (!data) return null;
+    return normalizeGammaMarket(data);
+  }
+  if (params.conditionId) {
+    const url = new URL(`/markets`, baseUrl);
+    url.searchParams.set("condition_id", params.conditionId);
+    const data = await requestJson3(url.toString());
+    if (!data) return null;
+    const market = Array.isArray(data) ? data[0] : data;
+    return market ? normalizeGammaMarket(market) : null;
+  }
+  throw new Error("id, slug, or conditionId is required.");
+}
+async function fetchPolymarketOrderbook(params) {
+  const environment = params.environment ?? "mainnet";
+  const baseUrl = resolvePolymarketBaseUrl("clob", environment);
+  const url = new URL("/book", baseUrl);
+  url.searchParams.set("token_id", params.tokenId);
+  const data = await requestJson3(url.toString());
+  return {
+    market: params.tokenId,
+    bids: normalizeOrderbookLevels(data.bids),
+    asks: normalizeOrderbookLevels(data.asks),
+    timestamp: getString(data.timestamp)
+  };
+}
+async function fetchPolymarketPrice(params) {
+  const environment = params.environment ?? "mainnet";
+  const baseUrl = resolvePolymarketBaseUrl("clob", environment);
+  const url = new URL("/price", baseUrl);
+  url.searchParams.set("token_id", params.tokenId);
+  url.searchParams.set("side", params.side);
+  const data = await requestJson3(url.toString());
+  const price = Number(data.price ?? data?.p);
+  return Number.isFinite(price) ? price : null;
+}
+async function fetchPolymarketMidpoint(params) {
+  const baseArgs = {
+    tokenId: params.tokenId,
+    ...params.environment ? { environment: params.environment } : {}
+  };
+  const buy = await fetchPolymarketPrice({ ...baseArgs, side: "BUY" });
+  const sell = await fetchPolymarketPrice({ ...baseArgs, side: "SELL" });
+  if (buy == null || sell == null) return null;
+  return (buy + sell) / 2;
+}
+async function fetchPolymarketPriceHistory(params) {
+  const environment = params.environment ?? "mainnet";
+  const baseUrl = resolvePolymarketBaseUrl("clob", environment);
+  const url = new URL("/prices-history", baseUrl);
+  url.searchParams.set("market", params.tokenId);
+  if (params.startTs) url.searchParams.set("startTs", params.startTs.toString());
+  if (params.endTs) url.searchParams.set("endTs", params.endTs.toString());
+  if (params.interval) url.searchParams.set("interval", params.interval);
+  if (params.fidelity) url.searchParams.set("fidelity", params.fidelity.toString());
+  const data = await requestJson3(url.toString());
+  const points = Array.isArray(data) ? data : data?.history ?? [];
+  return points.map((point) => ({
+    t: Number(point.t),
+    p: Number(point.p)
+  })).filter((point) => Number.isFinite(point.t) && Number.isFinite(point.p));
+}
 
 // src/ai/errors.ts
 var AIError = class extends Error {
@@ -4363,6 +5363,9 @@ async function loadAndValidateTools(toolsDir, options = {}) {
         if (typeof schedule.enabled === "boolean") {
           normalizedSchedule.authoredEnabled = schedule.enabled;
         }
+        if (typeof schedule.notifyEmail === "boolean") {
+          normalizedSchedule.notifyEmail = schedule.notifyEmail;
+        }
       }
       if (hasPOST) {
         if (!schema) {
@@ -4656,6 +5659,6 @@ function timestamp() {
   return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
 }
 
-export { AIAbortError, AIError, AIFetchError, AIResponseError, DEFAULT_BASE_URL, DEFAULT_CHAIN, DEFAULT_FACILITATOR, DEFAULT_MODEL, DEFAULT_TIMEOUT_MS, DEFAULT_TOKENS, HTTP_METHODS2 as HTTP_METHODS, HyperliquidApiError, HyperliquidBuilderApprovalError, HyperliquidExchangeClient, HyperliquidGuardError, HyperliquidInfoClient, HyperliquidTermsError, PAYMENT_HEADERS, SUPPORTED_CURRENCIES, StoreError, WEBSEARCH_TOOL_DEFINITION, WEBSEARCH_TOOL_NAME, X402BrowserClient, X402Client, X402PaymentRequiredError, __hyperliquidInternals, approveHyperliquidBuilderFee, batchModifyHyperliquidOrders, cancelAllHyperliquidOrders, cancelHyperliquidOrders, cancelHyperliquidOrdersByCloid, cancelHyperliquidTwapOrder, chains, createAIClient, createDevServer, createHyperliquidSubAccount, createMcpAdapter, createMonotonicNonceFactory, createStdioServer, defineX402Payment, depositToHyperliquidBridge, ensureTextContent, fetchHyperliquidAssetCtxs, fetchHyperliquidClearinghouseState, fetchHyperliquidFrontendOpenOrders, fetchHyperliquidHistoricalOrders, fetchHyperliquidMeta, fetchHyperliquidMetaAndAssetCtxs, fetchHyperliquidOpenOrders, fetchHyperliquidOrderStatus, fetchHyperliquidPreTransferCheck, fetchHyperliquidSpotAssetCtxs, fetchHyperliquidSpotClearinghouseState, fetchHyperliquidSpotMeta, fetchHyperliquidSpotMetaAndAssetCtxs, fetchHyperliquidUserFills, fetchHyperliquidUserFillsByTime, fetchHyperliquidUserRateLimit, flattenMessageContent, generateMetadata, generateMetadataCommand, generateText, getHyperliquidMaxBuilderFee, getModelConfig, getRpcUrl, getX402PaymentContext, isStreamingSupported, isToolCallingSupported, listModels, loadAndValidateTools, modifyHyperliquidOrder, normalizeModelName, payX402, payX402WithWallet, placeHyperliquidOrder, placeHyperliquidTwapOrder, recordHyperliquidBuilderApproval, recordHyperliquidTermsAcceptance, registry, requireX402Payment, reserveHyperliquidRequestWeight, resolveConfig2 as resolveConfig, resolveRuntimePath, resolveToolset, responseToToolResponse, retrieve, scheduleHyperliquidCancel, sendHyperliquidSpot, store, streamText, tokens, transferHyperliquidSubAccount, updateHyperliquidIsolatedMargin, updateHyperliquidLeverage, validateCommand, wallet, walletToolkit, withX402Payment, withdrawFromHyperliquid };
+export { AIAbortError, AIError, AIFetchError, AIResponseError, DEFAULT_BASE_URL, DEFAULT_CHAIN, DEFAULT_FACILITATOR, DEFAULT_MODEL, DEFAULT_TIMEOUT_MS, DEFAULT_TOKENS, HTTP_METHODS2 as HTTP_METHODS, HyperliquidApiError, HyperliquidBuilderApprovalError, HyperliquidExchangeClient, HyperliquidGuardError, HyperliquidInfoClient, HyperliquidTermsError, PAYMENT_HEADERS, POLYMARKET_CHAIN_ID, POLYMARKET_CLOB_AUTH_DOMAIN, POLYMARKET_CLOB_DOMAIN, POLYMARKET_ENDPOINTS, POLYMARKET_EXCHANGE_ADDRESSES, PolymarketApiError, PolymarketAuthError, PolymarketExchangeClient, PolymarketInfoClient, SUPPORTED_CURRENCIES, StoreError, WEBSEARCH_TOOL_DEFINITION, WEBSEARCH_TOOL_NAME, X402BrowserClient, X402Client, X402PaymentRequiredError, __hyperliquidInternals, approveHyperliquidBuilderFee, batchModifyHyperliquidOrders, buildHmacSignature, buildL1Headers, buildL2Headers, buildPolymarketOrderAmounts, buildSignedOrderPayload, cancelAllHyperliquidOrders, cancelAllPolymarketOrders, cancelHyperliquidOrders, cancelHyperliquidOrdersByCloid, cancelHyperliquidTwapOrder, cancelMarketPolymarketOrders, cancelPolymarketOrder, cancelPolymarketOrders, chains, createAIClient, createDevServer, createHyperliquidSubAccount, createMcpAdapter, createMonotonicNonceFactory, createPolymarketApiKey, createStdioServer, defineX402Payment, depositToHyperliquidBridge, derivePolymarketApiKey, ensureTextContent, executeTool, fetchHyperliquidAssetCtxs, fetchHyperliquidClearinghouseState, fetchHyperliquidFrontendOpenOrders, fetchHyperliquidHistoricalOrders, fetchHyperliquidMeta, fetchHyperliquidMetaAndAssetCtxs, fetchHyperliquidOpenOrders, fetchHyperliquidOrderStatus, fetchHyperliquidPreTransferCheck, fetchHyperliquidSpotAssetCtxs, fetchHyperliquidSpotClearinghouseState, fetchHyperliquidSpotMeta, fetchHyperliquidSpotMetaAndAssetCtxs, fetchHyperliquidUserFills, fetchHyperliquidUserFillsByTime, fetchHyperliquidUserRateLimit, fetchPolymarketMarket, fetchPolymarketMarkets, fetchPolymarketMidpoint, fetchPolymarketOrderbook, fetchPolymarketPrice, fetchPolymarketPriceHistory, flattenMessageContent, generateMetadata, generateMetadataCommand, generateText, getHyperliquidMaxBuilderFee, getModelConfig, getMyPerformance, getMyTools, getRpcUrl, getX402PaymentContext, isStreamingSupported, isToolCallingSupported, listModels, loadAndValidateTools, modifyHyperliquidOrder, normalizeModelName, normalizeNumberArrayish, normalizeStringArrayish, payX402, payX402WithWallet, placeHyperliquidOrder, placeHyperliquidTwapOrder, placePolymarketOrder, postAgentDigest, recordHyperliquidBuilderApproval, recordHyperliquidTermsAcceptance, registry, requireX402Payment, reserveHyperliquidRequestWeight, resolveConfig2 as resolveConfig, resolveExchangeAddress, resolvePolymarketBaseUrl, resolveRuntimePath, resolveToolset, responseToToolResponse, retrieve, scheduleHyperliquidCancel, sendHyperliquidSpot, setHyperliquidPortfolioMargin, store, streamText, tokens, transferHyperliquidSubAccount, updateHyperliquidIsolatedMargin, updateHyperliquidLeverage, validateCommand, wallet, walletToolkit, withX402Payment, withdrawFromHyperliquid };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map