horizon-code 0.1.0

package/src/research/tools.ts

@@ -0,0 +1,205 @@
+// Research tools — registered as AI SDK tools for the LLM to call
+import { tool } from "ai";
+import { z } from "zod";
+import {
+  gammaEvents, gammaEventDetail, clobPriceHistory, clobOrderBook,
+  polymarketTrades, kalshiEvents, exaSearch, exaSentiment,
+  calaSearch, evCalculator, probabilityCalc,
+} from "./apis.ts";
+
+const t = tool as any;
+
+export const researchTools: Record<string, any> = {
+  polymarketEvents: t({
+    description: "Browse and discover prediction markets on Polymarket. Use when user asks about markets, trending topics, or wants to explore.",
+    parameters: z.object({
+      query: z.string().optional().describe("Search tag: crypto, politics, sports, finance, etc."),
+      limit: z.number().optional().describe("Number of results (1-20, default 10)"),
+    }),
+    execute: async (args: any) => gammaEvents(args),
+  }),
+
+  polymarketEventDetail: t({
+    description: "Get detailed info on a specific Polymarket event including price history. Requires a slug from polymarketEvents.",
+    parameters: z.object({
+      slug: z.string().describe("Event slug from prior polymarketEvents results"),
+    }),
+    execute: async (args: any) => gammaEventDetail(args.slug),
+  }),
+
+  polymarketPriceHistory: t({
+    description: "Get price history for a market with specific time range. Good for trend analysis.",
+    parameters: z.object({
+      slug: z.string().describe("Event slug"),
+      interval: z.string().optional().describe("Time range: 1h, 6h, 1d, 1w, 1m, max (default 1w)"),
+      fidelity: z.number().optional().describe("Resolution in minutes: 1, 5, 15, 60 (default 60)"),
+    }),
+    execute: async (args: any) => clobPriceHistory(args.slug, args.interval, args.fidelity),
+  }),
+
+  polymarketOrderBook: t({
+    description: "Get order book depth, bid/ask levels, and spread analysis for a market.",
+    parameters: z.object({
+      slug: z.string().describe("Event slug"),
+      marketIndex: z.number().optional().describe("Sub-market index (default 0)"),
+      outcomeIndex: z.number().optional().describe("0=Yes, 1=No (default 0)"),
+    }),
+    execute: async (args: any) => clobOrderBook(args.slug, args.marketIndex, args.outcomeIndex),
+  }),
+
+  whaleTracker: t({
+    description: "Track large trades and top holders for a market. Shows smart money flows.",
+    parameters: z.object({
+      slug: z.string().describe("Event slug"),
+    }),
+    execute: async (args: any) => polymarketTrades(args.slug),
+  }),
+
+  newsSentiment: t({
+    description: "Analyze news sentiment for a market topic. Returns bullish/bearish score and relevant articles.",
+    parameters: z.object({
+      slug: z.string().describe("Event slug"),
+    }),
+    execute: async (args: any) => exaSentiment(args.slug),
+  }),
+
+  webSearch: t({
+    description: "Search the internet for current events, breaking news, or facts. Use for general questions not specific to prediction markets.",
+    parameters: z.object({
+      query: z.string().describe("Search query"),
+    }),
+    execute: async (args: any) => exaSearch(args.query),
+  }),
+
+  kalshiEvents: t({
+    description: "Fetch active prediction markets from Kalshi. Good for cross-platform comparison.",
+    parameters: z.object({
+      query: z.string().optional().describe("Series ticker filter (e.g. KXBTC, KXFED)"),
+      limit: z.number().optional().describe("Number of results (1-20, default 10)"),
+    }),
+    execute: async (args: any) => kalshiEvents(args),
+  }),
+
+  evCalculator: t({
+    description: "Calculate expected value (EV) and Kelly criterion position sizing for a market.",
+    parameters: z.object({
+      slug: z.string().describe("Event slug"),
+      side: z.enum(["yes", "no"]).describe("Which side to analyze"),
+      estimatedEdge: z.number().describe("Your estimated edge (0.01-0.50, e.g. 0.05 = 5%)"),
+      bankroll: z.number().optional().describe("Your bankroll in dollars (default 1000)"),
+    }),
+    execute: async (args: any) => {
+      const event = await gammaEventDetail(args.slug);
+      const market = event.markets?.[0];
+      if (!market) return { error: "Market not found" };
+      const price = args.side === "yes" ? parseFloat(market.yesPrice ?? "0.5") : parseFloat(market.noPrice ?? "0.5");
+      return {
+        ...evCalculator({ marketPrice: price, side: args.side, estimatedEdge: args.estimatedEdge, bankroll: args.bankroll ?? 1000 }),
+        title: event.title, slug: args.slug, url: event.url,
+      };
+    },
+  }),
+
+  probabilityCalculator: t({
+    description: "Calculate conditional probabilities P(A|B), joint probability between two markets.",
+    parameters: z.object({
+      slugA: z.string().describe("Slug of market A"),
+      slugB: z.string().describe("Slug of market B"),
+    }),
+    execute: async (args: any) => {
+      const [a, b] = await Promise.all([gammaEventDetail(args.slugA), gammaEventDetail(args.slugB)]);
+      const pA = parseFloat(a.markets?.[0]?.yesPrice ?? "0.5");
+      const pB = parseFloat(b.markets?.[0]?.yesPrice ?? "0.5");
+      return {
+        marketA: { title: a.title, slug: a.slug, probability: pA, url: a.url },
+        marketB: { title: b.title, slug: b.slug, probability: pB, url: b.url },
+        ...probabilityCalc(pA, pB),
+      };
+    },
+  }),
+
+  calaKnowledge: t({
+    description: "Search verified knowledge about companies, people, products, industries. Use for background research, NOT breaking news.",
+    parameters: z.object({
+      query: z.string().describe("Knowledge query about an entity, company, or topic"),
+    }),
+    execute: async (args: any) => calaSearch(args.query),
+  }),
+
+  historicalVolatility: t({
+    description: "Calculate realized volatility, Bollinger bands, and volatility regime for a market.",
+    parameters: z.object({
+      slug: z.string().describe("Event slug"),
+      interval: z.string().optional().describe("Time range: 1d, 1w, 1m, max (default 1w)"),
+    }),
+    execute: async (args: any) => {
+      const data = await clobPriceHistory(args.slug, args.interval ?? "1w", 60);
+      const prices = data.priceHistory.map((p: any) => p.p);
+      if (prices.length < 3) return { ...data, realizedVolatility: 0, regime: "insufficient data" };
+
+      // Log returns
+      const returns: number[] = [];
+      for (let i = 1; i < prices.length; i++) {
+        if (prices[i - 1] > 0) returns.push(Math.log(prices[i] / prices[i - 1]));
+      }
+
+      const mean = returns.reduce((a, b) => a + b, 0) / returns.length;
+      const variance = returns.reduce((a, b) => a + (b - mean) ** 2, 0) / returns.length;
+      const stdDev = Math.sqrt(variance);
+      const annualized = +(stdDev * Math.sqrt(365 * 24)).toFixed(4);
+
+      // Regime
+      const recentReturns = returns.slice(-20);
+      const recentVar = recentReturns.reduce((a, b) => a + (b - mean) ** 2, 0) / recentReturns.length;
+      const recentVol = Math.sqrt(recentVar);
+      const regime = recentVol > stdDev * 1.5 ? "high" : recentVol < stdDev * 0.5 ? "low" : "normal";
+
+      return {
+        ...data,
+        realizedVolatility: annualized,
+        dailyStdDev: +stdDev.toFixed(6),
+        volatilityRegime: regime,
+      };
+    },
+  }),
+
+  compareMarkets: t({
+    description: "Compare pricing between Polymarket and Kalshi for arbitrage or cross-platform analysis.",
+    parameters: z.object({
+      topic: z.string().describe("Topic to compare across platforms (e.g. bitcoin, election, fed)"),
+    }),
+    execute: async (args: any) => {
+      const [poly, kal] = await Promise.all([
+        gammaEvents({ query: args.topic, limit: 10 }),
+        kalshiEvents({ query: args.topic, limit: 10 }),
+      ]);
+
+      // Simple word-overlap matching
+      const comparisons: any[] = [];
+      for (const p of poly) {
+        const pWords = new Set(p.title.toLowerCase().split(/\s+/).filter((w: string) => w.length > 3));
+        for (const k of kal) {
+          const kWords = k.title.toLowerCase().split(/\s+/).filter((w: string) => w.length > 3);
+          const overlap = kWords.filter((w: string) => pWords.has(w)).length;
+          const score = overlap / Math.max(pWords.size, kWords.length);
+          if (score > 0.3) {
+            const polyPrice = parseFloat(p.markets?.[0]?.yesPrice ?? "0");
+            const kalPrice = k.markets?.[0]?.yesBid ?? 0;
+            comparisons.push({
+              polymarket: { title: p.title, url: p.url, yesPrice: polyPrice },
+              kalshi: { title: k.title, url: k.url, yesPrice: kalPrice },
+              priceDiff: polyPrice && kalPrice ? +(polyPrice - kalPrice / 100).toFixed(4) : null,
+            });
+          }
+        }
+      }
+
+      return {
+        polymarketEvents: poly.slice(0, 5).map((p: any) => ({ title: p.title, slug: p.slug, url: p.url, yesPrice: p.markets?.[0]?.yesPrice, volume: p.volume })),
+        kalshiEvents: kal.slice(0, 5).map((k: any) => ({ title: k.title, ticker: k.ticker, url: k.url, yesBid: k.markets?.[0]?.yesBid, volume: k.markets?.[0]?.volume })),
+        comparisons: comparisons.slice(0, 5),
+        topic: args.topic,
+      };
+    },
+  }),
+};