@elizaos/plugin-polymarket-app 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/actions.js

@@ -0,0 +1,661 @@
+import { Service } from "@elizaos/core";
+import { resolveApiToken, resolveDesktopApiPort } from "@elizaos/shared";
+const ACTION_TIMEOUT_MS = 15e3;
+const PREDICTION_MARKET_SERVICE_TYPE = "prediction-market";
+const POLYMARKET_CONTEXTS = ["finance", "crypto", "prediction-market"];
+const POLYMARKET_ACTION_CONTEXTS = [
+  ...POLYMARKET_CONTEXTS,
+  "payments"
+];
+const POLYMARKET_ACTION_NAME = "PREDICTION_MARKET";
+const POLYMARKET_READ_COMPAT_NAME = "POLYMARKET_READ";
+const POLYMARKET_PLACE_ORDER_COMPAT_NAME = "POLYMARKET_PLACE_ORDER";
+function toCallbackData(data) {
+  return data;
+}
+const POLYMARKET_READ_KEYWORDS = [
+  "polymarket",
+  "prediction market",
+  "market",
+  "markets",
+  "orderbook",
+  "positions",
+  "odds",
+  "forecast",
+  "predicci\xF3n",
+  "mercado",
+  "pron\xF3stico",
+  "march\xE9",
+  "pr\xE9vision",
+  "prognose",
+  "markt",
+  "mercado",
+  "previs\xE3o",
+  "mercato",
+  "previsione",
+  "\u4E88\u6E2C\u5E02\u5834",
+  "\u30AA\u30C3\u30BA",
+  "\u9884\u6D4B\u5E02\u573A",
+  "\u8D54\u7387",
+  "\uC608\uCE21 \uC2DC\uC7A5",
+  "\uBC30\uB2F9"
+];
+const POLYMARKET_TRADE_KEYWORDS = [
+  ...POLYMARKET_READ_KEYWORDS,
+  "buy",
+  "sell",
+  "trade",
+  "order",
+  "comprar",
+  "vender",
+  "orden",
+  "acheter",
+  "vendre",
+  "ordre",
+  "kaufen",
+  "verkaufen",
+  "auftrag",
+  "comprare",
+  "vendere",
+  "\u6CE8\u6587",
+  "\u8CB7\u3046",
+  "\u58F2\u308B",
+  "\u4E70\u5165",
+  "\u5356\u51FA",
+  "\u8BA2\u5355",
+  "\uB9E4\uC218",
+  "\uB9E4\uB3C4"
+];
+const READ_KINDS = [
+  "status",
+  "markets",
+  "market",
+  "orderbook",
+  "positions"
+];
+const POLYMARKET_OPS = ["read", "place_order"];
+const POLYMARKET_READ_COMPAT_SIMILES = [
+  POLYMARKET_READ_COMPAT_NAME,
+  "POLYMARKET_STATUS",
+  "POLYMARKET_READINESS",
+  "POLYMARKET_HEALTH",
+  "POLYMARKET_GET_MARKETS",
+  "POLYMARKET_MARKETS",
+  "SEARCH_POLYMARKET_MARKETS",
+  "POLYMARKET_GET_MARKET",
+  "POLYMARKET_MARKET",
+  "POLYMARKET_MARKET_DETAILS",
+  "POLYMARKET_GET_ORDERBOOK",
+  "POLYMARKET_ORDERBOOK",
+  "POLYMARKET_QUOTE",
+  "POLYMARKET_TOKEN_INFO",
+  "POLYMARKET_GET_POSITIONS",
+  "POLYMARKET_POSITIONS",
+  "POLYMARKET_WALLET_POSITIONS"
+];
+const POLYMARKET_PLACE_ORDER_COMPAT_SIMILES = [
+  POLYMARKET_PLACE_ORDER_COMPAT_NAME,
+  "POLYMARKET_TRADE",
+  "POLYMARKET_BUY",
+  "POLYMARKET_SELL"
+];
+const POLYMARKET_READ_OP_ALIASES = /* @__PURE__ */ new Set([
+  ...READ_KINDS,
+  ...POLYMARKET_READ_COMPAT_SIMILES.map((name) => name.toLowerCase())
+]);
+const POLYMARKET_PLACE_ORDER_OP_ALIASES = /* @__PURE__ */ new Set([
+  ...POLYMARKET_PLACE_ORDER_COMPAT_SIMILES.map((name) => name.toLowerCase()),
+  "trade",
+  "order",
+  "buy",
+  "sell"
+]);
+function getApiBase() {
+  return `http://127.0.0.1:${resolveDesktopApiPort(process.env)}`;
+}
+function buildAuthHeaders() {
+  const token = resolveApiToken(process.env);
+  if (!token) return {};
+  return {
+    Authorization: /^Bearer\s+/i.test(token) ? token : `Bearer ${token}`
+  };
+}
+function readParam(options, key) {
+  const maybeOptions = options;
+  if (maybeOptions?.parameters && key in maybeOptions.parameters) {
+    return maybeOptions.parameters[key];
+  }
+  return options?.[key];
+}
+function readStringParam(options, key) {
+  const value = readParam(options, key);
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function readNumberParam(options, key, fallback) {
+  const value = readParam(options, key);
+  const parsed = typeof value === "number" ? value : typeof value === "string" ? Number.parseInt(value, 10) : Number.NaN;
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function readKind(options) {
+  const raw = readStringParam(options, "kind");
+  if (!raw) return null;
+  const normalized = raw.toLowerCase();
+  return READ_KINDS.includes(normalized) ? normalized : null;
+}
+function normalizeOp(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
+  if (POLYMARKET_OPS.includes(normalized)) {
+    return normalized;
+  }
+  if (POLYMARKET_READ_OP_ALIASES.has(normalized)) {
+    return "read";
+  }
+  if (POLYMARKET_PLACE_ORDER_OP_ALIASES.has(normalized)) {
+    return "place_order";
+  }
+  return null;
+}
+function readOp(options) {
+  const rawOp = readStringParam(options, "action") ?? readStringParam(options, "subaction") ?? readStringParam(options, "op") ?? readStringParam(options, "operation") ?? readStringParam(options, "name");
+  const explicit = normalizeOp(rawOp);
+  if (explicit) return explicit;
+  if (readKind(options)) return "read";
+  if (readStringParam(options, "side") || readStringParam(options, "marketId") || readStringParam(options, "market_id") || readParam(options, "amount") !== void 0) {
+    return "place_order";
+  }
+  return null;
+}
+function hasSelectedContext(state, contexts = POLYMARKET_ACTION_CONTEXTS) {
+  const selected = /* @__PURE__ */ new Set();
+  const collect = (value) => {
+    if (!Array.isArray(value)) return;
+    for (const item of value) {
+      if (typeof item === "string") selected.add(item);
+    }
+  };
+  collect(
+    state?.values?.selectedContexts
+  );
+  collect(
+    state?.data?.selectedContexts
+  );
+  const contextObject = state?.data?.contextObject;
+  collect(contextObject?.trajectoryPrefix?.selectedContexts);
+  collect(contextObject?.metadata?.selectedContexts);
+  return contexts.some((context) => selected.has(context));
+}
+function hasKeywordIntent(message, state, keywords) {
+  const text = [
+    typeof message.content?.text === "string" ? message.content.text : "",
+    typeof state?.values?.recentMessages === "string" ? state.values.recentMessages : ""
+  ].join("\n").toLowerCase();
+  return keywords.some((keyword) => text.includes(keyword.toLowerCase()));
+}
+async function fetchPolymarketJson(path, options = {}) {
+  const response = await fetch(`${getApiBase()}${path}`, {
+    headers: { accept: "application/json", ...buildAuthHeaders() },
+    signal: AbortSignal.timeout(ACTION_TIMEOUT_MS)
+  });
+  const payload = await response.json().catch(() => null);
+  if (options.allowErrorStatus && payload !== null) {
+    return payload;
+  }
+  if (!response.ok) {
+    const message = payload && typeof payload === "object" && "error" in payload ? String(payload.error) : `Polymarket API request failed with ${response.status}`;
+    throw new Error(message);
+  }
+  return payload;
+}
+async function emit(callback, text, data) {
+  if (callback) {
+    await callback({
+      text,
+      actions: [POLYMARKET_ACTION_NAME],
+      data: toCallbackData(data)
+    });
+  }
+  return {
+    success: true,
+    text,
+    data: { actionName: POLYMARKET_ACTION_NAME, ...data }
+  };
+}
+async function emitFailure(callback, text, error, data) {
+  if (callback) {
+    await callback({
+      text,
+      actions: [POLYMARKET_ACTION_NAME],
+      data: toCallbackData(data)
+    });
+  }
+  return { success: false, text, error, data };
+}
+function marketLine(market) {
+  const price = market.bestBid || market.bestAsk ? ` bid ${market.bestBid ?? "n/a"} ask ${market.bestAsk ?? "n/a"}` : "";
+  const volume = market.volume24hr ? ` volume24h ${market.volume24hr}` : "";
+  return `- ${market.question ?? market.slug ?? market.id}${price}${volume}`;
+}
+function formatMarkets(markets) {
+  if (markets.length === 0) return "No active Polymarket markets found.";
+  return `Polymarket markets:
+${markets.slice(0, 12).map(marketLine).join("\n")}`;
+}
+function formatMarket(response) {
+  const market = response.market;
+  if (!market) return "No matching Polymarket market found.";
+  const tokens = market.clobTokenIds.length ? `
+Token IDs: ${market.clobTokenIds.join(", ")}` : "";
+  const outcomes = market.outcomes.length ? `
+Outcomes: ${market.outcomes.map((outcome) => `${outcome.name} ${outcome.price ?? "n/a"}`).join(", ")}` : "";
+  return `${market.question ?? market.slug ?? market.id}
+Status: ${market.active ? "active" : "inactive"}, ${market.closed ? "closed" : "open"}
+Best bid: ${market.bestBid ?? "n/a"}
+Best ask: ${market.bestAsk ?? "n/a"}${outcomes}${tokens}`;
+}
+function formatOrderbook(orderbook) {
+  return [
+    `Polymarket orderbook for ${orderbook.tokenId}:`,
+    `Best bid: ${orderbook.bestBid ?? "n/a"} (${orderbook.bestBidSize ?? "n/a"})`,
+    `Best ask: ${orderbook.bestAsk ?? "n/a"} (${orderbook.bestAskSize ?? "n/a"})`,
+    `Spread: ${orderbook.spread ?? "n/a"}`,
+    `Midpoint: ${orderbook.midpoint ?? "n/a"}`,
+    `Depth: ${orderbook.bidLevels} bids, ${orderbook.askLevels} asks`
+  ].join("\n");
+}
+async function handleStatus(callback) {
+  const status = await fetchPolymarketJson(
+    "/api/polymarket/status"
+  );
+  const text = `Polymarket public reads: ${status.publicReads.ready ? "ready" : "not ready"}
+Trading: ${status.trading.ready ? "ready" : "disabled"}
+Credentials: ${status.trading.credentialsReady ? "present" : "missing"}${status.trading.reason ? `
+Reason: ${status.trading.reason}` : ""}`;
+  return emit(callback, text, {
+    op: "read",
+    compatActionName: POLYMARKET_READ_COMPAT_NAME,
+    kind: "status",
+    status
+  });
+}
+async function handleMarkets(options, callback) {
+  const limit = Math.min(
+    100,
+    Math.max(1, readNumberParam(options, "limit", 20))
+  );
+  const offset = Math.max(0, readNumberParam(options, "offset", 0));
+  const response = await fetchPolymarketJson(
+    `/api/polymarket/markets?limit=${limit}&offset=${offset}`
+  );
+  return emit(callback, formatMarkets(response.markets), {
+    op: "read",
+    compatActionName: POLYMARKET_READ_COMPAT_NAME,
+    kind: "markets",
+    markets: response.markets,
+    source: response.source
+  });
+}
+async function handleMarket(options, callback) {
+  const id = readStringParam(options, "id");
+  const slug = readStringParam(options, "slug");
+  if (!id && !slug) {
+    const text = "Provide a Polymarket market id or slug.";
+    return emitFailure(callback, text, "missing_market_identifier", {
+      actionName: POLYMARKET_ACTION_NAME,
+      op: "read",
+      compatActionName: POLYMARKET_READ_COMPAT_NAME,
+      kind: "market"
+    });
+  }
+  const query = new URLSearchParams();
+  if (id) query.set("id", id);
+  if (slug && !id) query.set("slug", slug);
+  const response = await fetchPolymarketJson(
+    `/api/polymarket/market?${query.toString()}`
+  );
+  return emit(callback, formatMarket(response), {
+    op: "read",
+    compatActionName: POLYMARKET_READ_COMPAT_NAME,
+    kind: "market",
+    market: response.market,
+    source: response.source
+  });
+}
+async function handleOrderbook(options, callback) {
+  const tokenId = readStringParam(options, "tokenId") ?? readStringParam(options, "token_id");
+  if (!tokenId) {
+    const text = "Provide a Polymarket CLOB token id.";
+    return emitFailure(callback, text, "missing_token_id", {
+      actionName: POLYMARKET_ACTION_NAME,
+      op: "read",
+      compatActionName: POLYMARKET_READ_COMPAT_NAME,
+      kind: "orderbook"
+    });
+  }
+  const response = await fetchPolymarketJson(
+    `/api/polymarket/orderbook?token_id=${encodeURIComponent(tokenId)}`
+  );
+  return emit(callback, formatOrderbook(response), {
+    op: "read",
+    compatActionName: POLYMARKET_READ_COMPAT_NAME,
+    kind: "orderbook",
+    orderbook: response
+  });
+}
+async function handlePositions(options, callback) {
+  const user = readStringParam(options, "user");
+  if (!user) {
+    const text2 = "Provide a wallet address for Polymarket positions.";
+    return emitFailure(callback, text2, "missing_wallet_address", {
+      actionName: POLYMARKET_ACTION_NAME,
+      op: "read",
+      compatActionName: POLYMARKET_READ_COMPAT_NAME,
+      kind: "positions"
+    });
+  }
+  const response = await fetchPolymarketJson(
+    `/api/polymarket/positions?user=${encodeURIComponent(user)}`
+  );
+  const text = response.positions.length === 0 ? "No Polymarket positions found for that wallet." : `Polymarket positions:
+${response.positions.slice(0, 12).map(
+    (position) => `- ${position.question ?? position.conditionId ?? "Market"}: ${position.outcome ?? "outcome"} size ${position.size ?? "n/a"} value ${position.currentValue ?? "n/a"}`
+  ).join("\n")}`;
+  return emit(callback, text, {
+    op: "read",
+    compatActionName: POLYMARKET_READ_COMPAT_NAME,
+    kind: "positions",
+    positions: response.positions,
+    source: response.source
+  });
+}
+async function handleReadOperation(options, callback) {
+  const kind = readKind(options);
+  if (!kind) {
+    const text = "Provide kind: status | markets | market | orderbook | positions.";
+    return emitFailure(callback, text, "missing_or_invalid_kind", {
+      actionName: POLYMARKET_ACTION_NAME,
+      op: "read",
+      compatActionName: POLYMARKET_READ_COMPAT_NAME,
+      availableKinds: [...READ_KINDS]
+    });
+  }
+  try {
+    switch (kind) {
+      case "status":
+        return await handleStatus(callback);
+      case "markets":
+        return await handleMarkets(options, callback);
+      case "market":
+        return await handleMarket(options, callback);
+      case "orderbook":
+        return await handleOrderbook(options, callback);
+      case "positions":
+        return await handlePositions(options, callback);
+    }
+  } catch (error) {
+    const text = error instanceof Error ? error.message : String(error);
+    return emitFailure(callback, text, text, {
+      actionName: POLYMARKET_ACTION_NAME,
+      op: "read",
+      compatActionName: POLYMARKET_READ_COMPAT_NAME,
+      kind
+    });
+  }
+}
+async function handlePlaceOrderOperation(callback) {
+  const response = await fetchPolymarketJson(
+    "/api/polymarket/orders",
+    { allowErrorStatus: true }
+  ).catch((error) => ({
+    enabled: false,
+    reason: error instanceof Error ? error.message : String(error),
+    requiredForTrading: []
+  }));
+  const text = `Polymarket order placement is disabled.
+Reason: ${response.reason}${response.requiredForTrading.length ? `
+Required env vars: ${response.requiredForTrading.join(", ")}` : ""}`;
+  return {
+    ...await emit(callback, text, {
+      op: "place_order",
+      compatActionName: POLYMARKET_PLACE_ORDER_COMPAT_NAME,
+      trading: response
+    }),
+    success: false,
+    error: response.reason
+  };
+}
+function normalizeProviderKey(value) {
+  return value.trim().toLowerCase().replace(/[\s_-]+/g, "");
+}
+function readTarget(options) {
+  return readStringParam(options, "target") ?? readStringParam(options, "provider") ?? "polymarket";
+}
+function createPolymarketProvider() {
+  return {
+    name: "polymarket",
+    aliases: ["poly-market", "clob"],
+    supportedSubactions: ["read", "place_order"],
+    description: "Polymarket public market reads, orderbook data, positions, and trading readiness.",
+    execute: async ({ options, op, callback }) => {
+      switch (op) {
+        case "read":
+          return await handleReadOperation(options, callback);
+        case "place_order":
+          return await handlePlaceOrderOperation(callback);
+      }
+    }
+  };
+}
+class PredictionMarketService extends Service {
+  static serviceType = PREDICTION_MARKET_SERVICE_TYPE;
+  capabilityDescription = "Prediction market provider registry; currently registers Polymarket";
+  providers = /* @__PURE__ */ new Map();
+  aliases = /* @__PURE__ */ new Map();
+  static async start(runtime) {
+    const service = new PredictionMarketService(runtime);
+    service.registerProvider(createPolymarketProvider());
+    return service;
+  }
+  registerProvider(provider) {
+    const key = normalizeProviderKey(provider.name);
+    this.providers.set(key, provider);
+    for (const alias of [provider.name, ...provider.aliases]) {
+      this.aliases.set(normalizeProviderKey(alias), key);
+    }
+  }
+  listProviders() {
+    return [...this.providers.values()].map((provider) => ({
+      name: provider.name,
+      aliases: [...provider.aliases],
+      supportedSubactions: [...provider.supportedSubactions],
+      description: provider.description
+    }));
+  }
+  async route(args) {
+    const target = args.target ?? "polymarket";
+    const key = this.aliases.get(normalizeProviderKey(target));
+    const provider = key ? this.providers.get(key) : void 0;
+    if (!provider) {
+      const text = `Unsupported prediction market provider "${target}".`;
+      const data = {
+        actionName: POLYMARKET_ACTION_NAME,
+        error: "UNSUPPORTED_PROVIDER",
+        providers: this.listProviders()
+      };
+      await args.callback?.({
+        text,
+        actions: [POLYMARKET_ACTION_NAME],
+        data: toCallbackData(data)
+      });
+      return {
+        success: false,
+        text,
+        error: "UNSUPPORTED_PROVIDER",
+        data
+      };
+    }
+    if (!provider.supportedSubactions.includes(args.op)) {
+      const text = `${provider.name} does not support ${args.op}.`;
+      await args.callback?.({
+        text,
+        actions: [POLYMARKET_ACTION_NAME],
+        data: {
+          actionName: POLYMARKET_ACTION_NAME,
+          error: "UNSUPPORTED_SUBACTION",
+          provider: provider.name
+        }
+      });
+      return {
+        success: false,
+        text,
+        error: "UNSUPPORTED_SUBACTION",
+        data: {
+          actionName: POLYMARKET_ACTION_NAME,
+          provider: provider.name
+        }
+      };
+    }
+    const result = await provider.execute(args);
+    return {
+      ...result,
+      data: {
+        ...result.data ?? {},
+        actionName: POLYMARKET_ACTION_NAME,
+        target: provider.name,
+        supportedProviders: this.listProviders()
+      }
+    };
+  }
+  async stop() {
+    this.providers.clear();
+    this.aliases.clear();
+  }
+}
+const polymarketAction = {
+  name: POLYMARKET_ACTION_NAME,
+  contexts: [...POLYMARKET_ACTION_CONTEXTS],
+  contextGate: { anyOf: [...POLYMARKET_ACTION_CONTEXTS] },
+  roleGate: { minRole: "USER" },
+  similes: [
+    ...POLYMARKET_READ_COMPAT_SIMILES,
+    ...POLYMARKET_PLACE_ORDER_COMPAT_SIMILES
+  ],
+  description: "Use registered prediction market providers. target selects the provider; Polymarket is registered today. action=read reads public state with kind: status, markets, market, orderbook, or positions. action=place_order reports trading readiness; signed order placement is disabled in this app integration.",
+  descriptionCompressed: "Prediction market router: target polymarket; action read or place_order.",
+  parameters: [
+    {
+      name: "target",
+      description: "Prediction market provider.",
+      required: false,
+      schema: { type: "string", enum: ["polymarket"], default: "polymarket" }
+    },
+    {
+      name: "action",
+      description: "Prediction market operation: read or place_order.",
+      required: false,
+      schema: { type: "string", enum: [...POLYMARKET_OPS] }
+    },
+    {
+      name: "subaction",
+      description: "Legacy alias for action. Accepts place-order as place_order.",
+      required: false,
+      schema: { type: "string", enum: [...POLYMARKET_OPS, "place-order"] }
+    },
+    {
+      name: "kind",
+      description: "read only: status | markets | market | orderbook | positions.",
+      required: false,
+      schema: { type: "string", enum: [...READ_KINDS] }
+    },
+    {
+      name: "limit",
+      description: "markets only: max markets (1-100).",
+      required: false,
+      schema: { type: "number", default: 20 }
+    },
+    {
+      name: "offset",
+      description: "markets only: result offset.",
+      required: false,
+      schema: { type: "number", default: 0 }
+    },
+    {
+      name: "id",
+      description: "market only: Polymarket Gamma market id.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "slug",
+      description: "market only: Polymarket market slug.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "tokenId",
+      description: "orderbook only: Polymarket CLOB token id.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "user",
+      description: "positions only: wallet address.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "side",
+      description: "place_order only: intended side, buy or sell.",
+      required: false,
+      schema: { type: "string", enum: ["buy", "sell"] }
+    },
+    {
+      name: "marketId",
+      description: "place_order only: Polymarket market id or condition id.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "amount",
+      description: "place_order only: intended order amount.",
+      required: false,
+      schema: { type: "number" }
+    }
+  ],
+  validate: async (_runtime, message, state) => hasSelectedContext(state) || hasKeywordIntent(message, state, POLYMARKET_READ_KEYWORDS) || hasKeywordIntent(message, state, POLYMARKET_TRADE_KEYWORDS),
+  handler: async (runtime, _message, _state, options, callback) => {
+    const op = readOp(options);
+    if (!op) {
+      const text = "Provide action: read | place_order. For read, also provide kind: status | markets | market | orderbook | positions.";
+      return emitFailure(callback, text, "missing_or_invalid_op", {
+        actionName: POLYMARKET_ACTION_NAME,
+        availableActions: [...POLYMARKET_OPS]
+      });
+    }
+    const service = runtime.getService(
+      PREDICTION_MARKET_SERVICE_TYPE
+    );
+    if (!service || typeof service.route !== "function") {
+      const text = "Prediction market service is not available.";
+      return emitFailure(callback, text, "service_unavailable", {
+        actionName: POLYMARKET_ACTION_NAME
+      });
+    }
+    return service.route({
+      target: readTarget(options),
+      op,
+      options,
+      callback
+    });
+  }
+};
+const predictionMarketAction = polymarketAction;
+const polymarketActions = [predictionMarketAction];
+export {
+  PREDICTION_MARKET_SERVICE_TYPE,
+  PredictionMarketService,
+  polymarketAction,
+  polymarketActions,
+  predictionMarketAction
+};
+//# sourceMappingURL=actions.js.map