@coinrithm/mcp-trading 0.7.3 → 0.7.4

package/dist/tools.js

@@ -172,6 +172,391 @@ function present(result) {
         isError: !result.ok,
     };
 }
+function isJsonRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pick(record, keys) {
+    return Object.fromEntries(keys
+        .filter((key) => record[key] !== undefined)
+        .map((key) => [key, record[key]]));
+}
+function probability(value) {
+    if (typeof value !== "number" && typeof value !== "string")
+        return null;
+    if (typeof value === "string" && value.trim() === "")
+        return null;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+const EVENT_SUMMARY_FIELDS = [
+    "id",
+    "slug",
+    "title",
+    "status",
+    "startDate",
+    "endDate",
+    "resolvedAt",
+    "freshness",
+    "volume",
+    "volume24h",
+    "liquidity",
+    "priceChange24h",
+    "priceChange7d",
+    "bestBid",
+    "bestAsk",
+    "spread",
+    "marketsCount",
+    "referenceProbability",
+    "crossPlatform",
+    "decisionSupport",
+    "quality",
+];
+const OUTCOME_SUMMARY_FIELDS = [
+    "externalMarketId",
+    "name",
+    "probability",
+    "priceChange24h",
+];
+const WHALE_TRADE_FIELDS = [
+    "source",
+    "sourceName",
+    "eventSlug",
+    "eventTitle",
+    "wallet",
+    "traderName",
+    "side",
+    "outcome",
+    "marketQuestion",
+    "usdValue",
+    "price",
+    "sourceMarketRef",
+    "nativeValue",
+    "nativeCurrency",
+    "valueBasis",
+    "evidenceType",
+    "evidenceRef",
+    "evidenceUrl",
+    "availability",
+    "observedAt",
+    "latencySeconds",
+    "tradedAt",
+];
+function boundedText(value, maxLength) {
+    if (typeof value !== "string" || value.length <= maxLength)
+        return value;
+    return `${value.slice(0, maxLength - 1)}…`;
+}
+function compactWhaleTrade(value) {
+    return isJsonRecord(value) ? pick(value, WHALE_TRADE_FIELDS) : value;
+}
+function eventSummary(value) {
+    if (!isJsonRecord(value))
+        return value;
+    const source = isJsonRecord(value.source)
+        ? pick(value.source, ["id", "name", "kind", "supportsTrading"])
+        : value.source;
+    const outcomes = Array.isArray(value.outcomes)
+        ? value.outcomes
+            .map((outcome, index) => ({ outcome, index }))
+            .sort((left, right) => {
+            const a = isJsonRecord(left.outcome)
+                ? probability(left.outcome.probability)
+                : null;
+            const b = isJsonRecord(right.outcome)
+                ? probability(right.outcome.probability)
+                : null;
+            const aValid = a !== null;
+            const bValid = b !== null;
+            if (aValid !== bValid)
+                return aValid ? -1 : 1;
+            return aValid && bValid && a !== b
+                ? b - a
+                : left.index - right.index;
+        })
+            .slice(0, 5)
+            .map(({ outcome }) => isJsonRecord(outcome)
+            ? pick(outcome, OUTCOME_SUMMARY_FIELDS)
+            : outcome)
+        : [];
+    return {
+        ...pick(value, EVENT_SUMMARY_FIELDS),
+        source,
+        outcomeCount: Array.isArray(value.outcomes) ? value.outcomes.length : 0,
+        outcomes,
+    };
+}
+/**
+ * Keep keyless discovery calls small enough for an agent context window.
+ * Full event evidence remains available from pm_data_event.
+ */
+export function compactPublicPmOverview(data) {
+    if (!isJsonRecord(data))
+        return data;
+    const highlights = isJsonRecord(data.highlights)
+        ? Object.fromEntries(Object.entries(data.highlights).map(([key, value]) => [
+            key,
+            Array.isArray(value) ? value.map(eventSummary) : value,
+        ]))
+        : data.highlights;
+    return {
+        ...pick(data, [
+            "stats",
+            "categories",
+            "bySource",
+            "byCategory",
+            "updatedAt",
+        ]),
+        highlights,
+    };
+}
+export function compactPublicPmEvents(data) {
+    if (!isJsonRecord(data))
+        return data;
+    return {
+        ...data,
+        data: Array.isArray(data.data) ? data.data.map(eventSummary) : data.data,
+    };
+}
+function compactSnapshot(value) {
+    if (!isJsonRecord(value))
+        return value;
+    return {
+        ...pick(value, [
+            "id",
+            "capturedAt",
+            "observedAt",
+            "timestamp",
+            "asOf",
+            "probability",
+            "volume",
+            "volume24h",
+            "liquidity",
+            "bestBid",
+            "bestAsk",
+            "spread",
+            "outcome",
+            "externalMarketId",
+        ]),
+        ...(Array.isArray(value.outcomes)
+            ? {
+                outcomeCount: value.outcomes.length,
+                outcomes: value.outcomes
+                    .slice(0, 10)
+                    .map((outcome) => isJsonRecord(outcome)
+                    ? pick(outcome, OUTCOME_SUMMARY_FIELDS)
+                    : outcome),
+            }
+            : {}),
+    };
+}
+function compactComparison(value) {
+    if (!isJsonRecord(value))
+        return value;
+    const outcomes = Array.isArray(value.outcomes) ? value.outcomes : [];
+    const shared = outcomes.filter((outcome) => isJsonRecord(outcome) &&
+        (outcome.isShared === true ||
+            (outcome.presentInA === true && outcome.presentInB === true)));
+    const candidates = shared.length > 0 ? shared : outcomes;
+    const ranked = candidates
+        .map((outcome, index) => ({ outcome, index }))
+        .sort((left, right) => {
+        const a = isJsonRecord(left.outcome)
+            ? Math.abs(probability(left.outcome.deltaPoints) ?? -1)
+            : -1;
+        const b = isJsonRecord(right.outcome)
+            ? Math.abs(probability(right.outcome.deltaPoints) ?? -1)
+            : -1;
+        return a !== b ? b - a : left.index - right.index;
+    })
+        .slice(0, 5)
+        .map(({ outcome }) => isJsonRecord(outcome)
+        ? pick(outcome, [
+            "key",
+            "label",
+            "eventAProbability",
+            "eventBProbability",
+            "deltaPoints",
+            "presentInA",
+            "presentInB",
+            "isShared",
+        ])
+        : outcome);
+    return {
+        summary: value.summary,
+        outcomeCount: outcomes.length,
+        outcomes: ranked,
+    };
+}
+function compactCrossSourceMatch(value) {
+    if (!isJsonRecord(value))
+        return value;
+    return {
+        ...pick(value, [
+            "matchId",
+            "confidence",
+            "matchMethod",
+            "recommendedSourceId",
+            "divergence",
+        ]),
+        comparison: compactComparison(value.comparison),
+        event: eventSummary(value.event),
+    };
+}
+/**
+ * Default event detail for agents: enough provenance and comparison evidence
+ * to reason safely without recursively spending an entire context window.
+ * Callers can explicitly request detail=full for the untouched API record.
+ */
+export function compactPublicPmEvent(data) {
+    if (!isJsonRecord(data))
+        return data;
+    const rawEvent = isJsonRecord(data.event) ? data.event : null;
+    const summary = rawEvent ? eventSummary(rawEvent) : data.event;
+    const event = isJsonRecord(summary)
+        ? {
+            ...summary,
+            ...(rawEvent
+                ? {
+                    image: rawEvent.image,
+                    externalUrl: rawEvent.externalUrl,
+                    description: boundedText(rawEvent.description, 1_200),
+                    resolutionCriteria: boundedText(rawEvent.resolutionCriteria, 2_000),
+                    forecasting: rawEvent.forecasting,
+                    topics: Array.isArray(rawEvent.topics)
+                        ? rawEvent.topics.slice(0, 20)
+                        : rawEvent.topics,
+                    directRelatedCoins: Array.isArray(rawEvent.directRelatedCoins)
+                        ? rawEvent.directRelatedCoins.slice(0, 20)
+                        : rawEvent.directRelatedCoins,
+                    indirectRelatedCoins: Array.isArray(rawEvent.indirectRelatedCoins)
+                        ? rawEvent.indirectRelatedCoins.slice(0, 20)
+                        : rawEvent.indirectRelatedCoins,
+                }
+                : {}),
+        }
+        : summary;
+    const relatedEvents = Array.isArray(data.relatedEvents)
+        ? data.relatedEvents.slice(0, 5).map(eventSummary)
+        : data.relatedEvents;
+    const crossSourceMatches = Array.isArray(data.crossSourceMatches)
+        ? data.crossSourceMatches
+            .map((match, index) => ({ match, index }))
+            .sort((left, right) => {
+            const a = isJsonRecord(left.match)
+                ? probability(left.match.confidence)
+                : null;
+            const b = isJsonRecord(right.match)
+                ? probability(right.match.confidence)
+                : null;
+            return a !== b && a !== null && b !== null
+                ? b - a
+                : left.index - right.index;
+        })
+            .slice(0, 5)
+            .map(({ match }) => compactCrossSourceMatch(match))
+        : data.crossSourceMatches;
+    return {
+        ...pick(data, ["resolution", "agentsTradingMarket"]),
+        event,
+        snapshotCount: Array.isArray(data.snapshots) ? data.snapshots.length : 0,
+        snapshots: Array.isArray(data.snapshots)
+            ? data.snapshots.slice(-20).map(compactSnapshot)
+            : data.snapshots,
+        relatedEventCount: Array.isArray(data.relatedEvents)
+            ? data.relatedEvents.length
+            : 0,
+        relatedEvents,
+        crossSourceMatchCount: Array.isArray(data.crossSourceMatches)
+            ? data.crossSourceMatches.length
+            : 0,
+        crossSourceMatches,
+        volumeHistory: Array.isArray(data.volumeHistory)
+            ? data.volumeHistory.slice(-90)
+            : data.volumeHistory,
+        relatedNews: Array.isArray(data.relatedNews)
+            ? data.relatedNews.slice(0, 5)
+            : data.relatedNews,
+        topicRelatedCoins: Array.isArray(data.topicRelatedCoins)
+            ? data.topicRelatedCoins.slice(0, 20)
+            : data.topicRelatedCoins,
+        recentWhaleTrades: Array.isArray(data.recentWhaleTrades)
+            ? data.recentWhaleTrades.slice(0, 5).map(compactWhaleTrade)
+            : data.recentWhaleTrades,
+    };
+}
+export function compactPublicPmWhales(data, limit) {
+    if (!isJsonRecord(data))
+        return data;
+    const trades = Array.isArray(data.trades)
+        ? data.trades.slice(0, limit).map(compactWhaleTrade)
+        : data.trades;
+    return { ...data, trades };
+}
+const MATCH_PAIR_FIELDS = [
+    "matchId",
+    "confidence",
+    "matchMethod",
+    "recommendedSourceId",
+    "divergence",
+];
+function compactMatchPair(value) {
+    if (!isJsonRecord(value))
+        return value;
+    return {
+        ...pick(value, MATCH_PAIR_FIELDS),
+        comparison: compactComparison(value.comparison),
+    };
+}
+function compactMatchCluster(value) {
+    if (!isJsonRecord(value))
+        return value;
+    const events = Array.isArray(value.events)
+        ? value.events.map(eventSummary)
+        : value.events;
+    const comparisons = Array.isArray(value.comparisons)
+        ? value.comparisons.map((comparison) => isJsonRecord(comparison)
+            ? {
+                eventId: comparison.eventId,
+                pair: compactMatchPair(comparison.pair),
+            }
+            : comparison)
+        : value.comparisons;
+    return {
+        ...pick(value, [
+            "clusterId",
+            "primaryEventId",
+            "title",
+            "referenceProbability",
+            "maxOverallGap",
+            "maxOutcomeGap",
+            "maxConfidence",
+        ]),
+        eventCount: Array.isArray(value.events) ? value.events.length : 0,
+        events,
+        comparisons,
+    };
+}
+/**
+ * Keep cross-venue disagreement clusters small enough for an agent context
+ * window: each event is reduced to eventSummary (drops descriptions, images,
+ * sparklines) and each pairwise comparison keeps only its top-5 highest-delta
+ * shared outcomes (compactComparison) — the same bounding pm_data_event
+ * applies to crossSourceMatches. Verified live: a 5-cluster page drops from
+ * ~466KB to ~48KB.
+ */
+export function compactPublicPmDisagreements(data) {
+    if (!isJsonRecord(data))
+        return data;
+    return {
+        ...pick(data, ["total", "hasMore", "pagination", "meta"]),
+        data: Array.isArray(data.data)
+            ? data.data.map(compactMatchCluster)
+            : data.data,
+    };
+}
+function mapSuccessfulBody(result, transform) {
+    return result.ok ? { ...result, data: transform(result.data) } : result;
+}
 export function registerTools(server, client) {
     // ---------------- identity ----------------
     server.registerTool("whoami", {
@@ -1043,7 +1428,8 @@ export function registerTools(server, client) {
             "closed market counts, total volume, 24h volume, and liquidity " +
             "aggregated across all 11 venues (Polymarket, Kalshi, Rothera, " +
             "Limitless, Smarkets, Manifold, Metaculus, PredictIt, Futuur, Myriad, ForecastEx), plus market " +
-            "highlights. Freshness is SOURCE-AWARE — each venue ingests " +
+            "highlights in a compact discovery shape. Use pm_data_event for full " +
+            "event evidence. Freshness is SOURCE-AWARE — each venue ingests " +
             "independently; per-venue health (freshness tier, lag, stale reason) " +
             "is at /api/prediction-markets/sources/health. Volume is " +
             "reported on each venue's own basis (see the methodology at " +
@@ -1058,7 +1444,7 @@ export function registerTools(server, client) {
         },
         outputSchema: API_RESULT_OUTPUT_SCHEMA,
         annotations: readOnlyAnnotations("Cross-venue prediction-market statistics"),
-    }, async ({ fiat }) => present(await client.getPublicPmOverview({ fiat })));
+    }, async ({ fiat }) => present(mapSuccessfulBody(await client.getPublicPmOverview({ fiat }), compactPublicPmOverview)));
     server.registerTool("pm_data_events", {
         title: "Search prediction markets across all venues",
         description: "Free public search over prediction-market events across ALL 11 " +
@@ -1066,6 +1452,8 @@ export function registerTools(server, client) {
             "Manifold, Metaculus, PredictIt, Futuur, Myriad, ForecastEx) — broader than discover_pm_markets, which is " +
             "scoped to the paper-tradeable venues. Returns titles, probabilities, " +
             "volume/liquidity, status, and source per event, plus " +
+            "the five highest-probability outcomes and the full outcome count. " +
+            "Use pm_data_event for all outcomes and full evidence. Also returns " +
             "referenceProbability when present (CoinRithm's canonical cross-venue " +
             "number for open events matched across venues — probability, " +
             "venueCount, spreadPoints, and outcomeName for multi-outcome " +
@@ -1106,7 +1494,7 @@ export function registerTools(server, client) {
         },
         outputSchema: API_RESULT_OUTPUT_SCHEMA,
         annotations: readOnlyAnnotations("Search prediction markets across all venues"),
-    }, async ({ q, source, status, sort, limit, offset, fiat }) => present(await client.listPublicPmEvents({
+    }, async ({ q, source, status, sort, limit, offset, fiat }) => present(mapSuccessfulBody(await client.listPublicPmEvents({
         q,
         source,
         status,
@@ -1114,9 +1502,9 @@ export function registerTools(server, client) {
         limit,
         offset,
         fiat,
-    })));
+    }), compactPublicPmEvents)));
     server.registerTool("pm_data_event", {
-        title: "Get full prediction-market event detail",
+        title: "Get prediction-market event detail",
         description: "Free public detail for one prediction-market event by venue + slug: " +
             "outcomes with probabilities, price snapshots, resolution evidence, " +
             "crossSourceMatches (the SAME real-world question priced on other " +
@@ -1128,6 +1516,9 @@ export function registerTools(server, client) {
             "recent whale trades on the event, related events, related news, and " +
             "volumeHistory when present (daily volume points captured since " +
             "2026-07-02 — read the event's volume trend directly from it). " +
+            "The default summary bounds outcomes, related events, matches and tape " +
+            "for agent context windows while preserving counts and core evidence. " +
+            "Set detail=full only when the untouched provider-rich record is needed. " +
             "This is the cross-venue research view; for tradability use pm_quote. " +
             "No API key required.",
         inputSchema: {
@@ -1140,20 +1531,201 @@ export function registerTools(server, client) {
                 .string()
                 .optional()
                 .describe("Fiat currency code for monetary figures (default usd)."),
+            detail: z
+                .enum(["summary", "full"])
+                .optional()
+                .describe("Response detail: bounded summary (default) or untouched full record."),
         },
         outputSchema: API_RESULT_OUTPUT_SCHEMA,
-        annotations: readOnlyAnnotations("Get full prediction-market event detail"),
-    }, async ({ source, slug, fiat }) => present(await client.getPublicPmEvent(source, slug, { fiat })));
+        annotations: readOnlyAnnotations("Get prediction-market event detail"),
+    }, async ({ source, slug, fiat, detail }) => {
+        const result = await client.getPublicPmEvent(source, slug, { fiat });
+        return present(detail === "full"
+            ? result
+            : mapSuccessfulBody(result, compactPublicPmEvent));
+    });
     server.registerTool("pm_data_whales", {
         title: "Get latest prediction-market whale trades",
         description: "Free public tape of the latest large prediction-market trades " +
-            "(roughly $1k+ notional) across venues, newest first (top 50): side, " +
+            "(roughly $1k+ notional) across venues, newest first: side, " +
             "outcome, USD value, price, market question, and the event it printed " +
             "on. Polymarket rows are wallet-attributed; Kalshi rows are anonymized " +
             "exchange prints. A large print is information, not a recommendation. " +
             "No API key required.",
-        inputSchema: {},
+        inputSchema: {
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(50)
+                .optional()
+                .describe("Max rows (1-50, default 10)."),
+        },
         outputSchema: API_RESULT_OUTPUT_SCHEMA,
         annotations: readOnlyAnnotations("Get latest prediction-market whale trades"),
-    }, async () => present(await client.getPublicPmWhales()));
+    }, async ({ limit }) => present(mapSuccessfulBody(await client.getPublicPmWhales(), (data) => compactPublicPmWhales(data, limit ?? 10))));
+    server.registerTool("pm_data_disagreements", {
+        title: "Cross-venue disagreement clusters",
+        description: "Free public cross-venue disagreement clusters: prediction-market " +
+            "events CoinRithm has matched as the SAME real-world question across " +
+            "2+ venues (approved cross-source matches), graph-clustered so one row " +
+            "covers every venue tracking that question. Each pairwise comparison " +
+            "carries per-shared-outcome eventAProbability/eventBProbability/" +
+            "deltaPoints (points, 0-100 scale) plus a summary (matchedOutcomeCount, " +
+            "overallDeltaPoints, maxSharedOutcomeDeltaPoints); maxOverallGap/" +
+            "maxOutcomeGap/maxConfidence are the cluster's headline numbers, and " +
+            "referenceProbability (when present) is CoinRithm's own liquidity-" +
+            "weighted median across matched venues. Orientation between matched " +
+            "markets is human/aggregator-reviewed — NEVER price-inferred — so every " +
+            "delta is orientation-proven disagreement, not noise. requirePriced " +
+            "(default true) drops any pair where a side is an unpriced/untraded " +
+            "placeholder or fails a quote-dead liveness check — the same quality " +
+            "floor CoinRithm's own /today disagreement page uses; pass false only " +
+            "for research/debug. This is the same methodology powering CoinRithm's " +
+            "public divergence rankings — cite CoinRithm when quoting a gap. " +
+            "Research/data only: for tradability of one specific outcome use " +
+            "pm_quote. No API key required.",
+        inputSchema: {
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(25)
+                .optional()
+                .describe("Max clusters (1-25, default 10)."),
+            offset: z
+                .number()
+                .int()
+                .min(0)
+                .optional()
+                .describe("Pagination offset (default 0)."),
+            sort: z
+                .enum([
+                "confidence_desc",
+                "divergence_desc",
+                "max_outcome_delta_desc",
+            ])
+                .optional()
+                .describe("Ranking: confidence_desc (default) = strongest match first; " +
+                "divergence_desc = total cross-outcome gap; " +
+                "max_outcome_delta_desc = single largest shared-outcome gap " +
+                "(avoids multi-leg basket noise)."),
+            minDivergence: z
+                .number()
+                .min(0)
+                .optional()
+                .describe("Floor (points, 0-100) on whichever metric the active sort ranks by."),
+            sourceKind: z
+                .enum(["market"])
+                .optional()
+                .describe("Pass 'market' to restrict both sides of every pair to real-money " +
+                "market venues (excludes forecast/play-money venues like " +
+                "Metaculus/Manifold)."),
+            status: z
+                .enum(["open"])
+                .optional()
+                .describe("Pass 'open' to require BOTH matched events be currently open."),
+            maxSnapshotAgeMinutes: z
+                .number()
+                .min(0)
+                .optional()
+                .describe("Require both matched events' probability come from a price " +
+                "snapshot captured within this many minutes."),
+            requirePriced: z
+                .boolean()
+                .optional()
+                .describe("Default true: drops any pair where a side is an unpriced/untraded " +
+                "placeholder or fails a quote-dead liveness check. Set false only " +
+                "for research/debug."),
+            fiat: z
+                .string()
+                .optional()
+                .describe("Fiat currency code for monetary figures (default usd)."),
+        },
+        outputSchema: API_RESULT_OUTPUT_SCHEMA,
+        annotations: readOnlyAnnotations("Cross-venue disagreement clusters"),
+    }, async ({ limit, offset, sort, minDivergence, sourceKind, status, maxSnapshotAgeMinutes, requirePriced, fiat, }) => present(mapSuccessfulBody(await client.getPublicPmMatches({
+        limit,
+        offset,
+        sort,
+        minDivergence,
+        sourceKind,
+        status,
+        maxSnapshotAgeMinutes,
+        requirePriced,
+        fiat,
+    }), compactPublicPmDisagreements)));
+    server.registerTool("pm_data_calibration", {
+        title: "Per-venue forecast-accuracy calibration",
+        description: "Free public per-venue forecast-accuracy scorecard: for each venue, " +
+            "calibrationError (Expected Calibration Error, 0-1, lower is better — " +
+            "the fair cross-venue headline), sampleSize, meanWinnerConfidence, and " +
+            "a 10-bucket reliability curve (predictedMean vs realizedRate per " +
+            "probability bucket) computed from that venue's OWN probability ~24h " +
+            "before resolution against the outcome that actually happened, over " +
+            "resolved markets with >=24h of pre-resolution history. Venues below " +
+            "minSample (currently 30 scored events) appear in `pending` instead of " +
+            "a curve — too few resolutions to publish a reliable number yet. Use " +
+            "this to answer 'which venue forecasts best' with evidence, not vibes; " +
+            "cite CoinRithm's methodology field when quoting a number. No API key " +
+            "required.",
+        inputSchema: {},
+        outputSchema: API_RESULT_OUTPUT_SCHEMA,
+        annotations: readOnlyAnnotations("Per-venue forecast-accuracy calibration"),
+    }, async () => present(await client.getPublicPmCalibration()));
+    server.registerTool("pm_data_canonical", {
+        title: "Canonical cross-venue event identity",
+        description: "Free public canonical-event identity: CoinRithm's stable cross-venue " +
+            "identity for one real-world question, independent of any single " +
+            "venue's slug. Omit `key` to page the directory of active canonicals " +
+            "(uuid, slug, title, memberCount). Pass `key` (a canonical's uuid OR " +
+            "slug) for one canonical's full record: its venue members (each with " +
+            "orientation — same/inverted/unknown, NEVER price-inferred — plus " +
+            "confidence and provenance basis) and an append-only judgment lineage " +
+            "(created/member_added/member_removed/merged, newest first). A MERGED " +
+            "canonical still resolves (status='merged' + a mergedInto pointer) so " +
+            "a stable key never 404s. Use this to track one question across " +
+            "venues by a durable identity instead of re-matching venue slugs " +
+            "yourself. No API key required.",
+        inputSchema: {
+            key: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("UUID or slug of one canonical event. Omit to list active canonicals."),
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(200)
+                .optional()
+                .describe("List mode only: max rows (1-200, default 50)."),
+            cursor: z
+                .number()
+                .int()
+                .positive()
+                .optional()
+                .describe("List mode only: pagination cursor — pass the previous " +
+                "response's pagination.nextCursor."),
+        },
+        outputSchema: API_RESULT_OUTPUT_SCHEMA,
+        annotations: readOnlyAnnotations("Canonical cross-venue event identity"),
+    }, async ({ key, limit, cursor }) => present(key
+        ? await client.getPublicPmCanonicalDetail(key)
+        : await client.getPublicPmCanonicalList({ limit, cursor })));
+    server.registerTool("pm_data_volume_history", {
+        title: "Global prediction-market volume trend",
+        description: "Free public global daily prediction-market volume trend: one point " +
+            "per UTC calendar day (day-over-day delta of each event's cumulative " +
+            "volume, summed across REAL-MONEY venues only — play-money/forecast " +
+            "venues like Manifold and Metaculus are excluded), with a per-venue " +
+            "breakdown (bySource) each day. Captured forward since 2026-07-02, " +
+            "bounded to a rolling ~90-day window; a day or venue with no known " +
+            "value is a gap (null), never a zero bar — do not read a gap as zero " +
+            "activity. Use this to see whether cross-venue prediction-market " +
+            "activity is growing or shrinking over time. No API key required.",
+        inputSchema: {},
+        outputSchema: API_RESULT_OUTPUT_SCHEMA,
+        annotations: readOnlyAnnotations("Global prediction-market volume trend"),
+    }, async () => present(await client.getPublicPmVolumeHistory()));
 }