@coinrithm/mcp-trading 0.7.12 → 0.7.13

package/dist/agent/act.js

@@ -1,8 +1,37 @@
 // Act phase: fetch the quote evidence for an open (the runner does this, never
 // the model) and execute a validated action (futures / spot / PM) with an
 // idempotency key.
-import { asObj, asNum } from "./extract.js";
+import { asObj, asNum, asStr } from "./extract.js";
 import { freshnessOf } from "./pmContext.js";
+function fundingQuoteEvidence(value) {
+    if (value === null)
+        return null;
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const f = asObj(value);
+    const estimatedPerIntervalMusd = Object.prototype.hasOwnProperty.call(f, "estimatedPerIntervalMusd")
+        ? (asNum(f.estimatedPerIntervalMusd) ??
+            (f.estimatedPerIntervalMusd === null ? null : undefined))
+        : undefined;
+    return {
+        ...(asStr(f.venue) !== undefined ? { venue: asStr(f.venue) } : {}),
+        ...(asStr(f.symbol) !== undefined ? { symbol: asStr(f.symbol) } : {}),
+        ...(asNum(f.rate) !== undefined ? { rate: asNum(f.rate) } : {}),
+        ...(asNum(f.intervalHours) !== undefined
+            ? { intervalHours: asNum(f.intervalHours) }
+            : {}),
+        ...(asStr(f.nextFundingTime) !== undefined
+            ? { nextFundingTime: asStr(f.nextFundingTime) }
+            : {}),
+        ...(asStr(f.asOf) !== undefined ? { asOf: asStr(f.asOf) } : {}),
+        ...(estimatedPerIntervalMusd !== undefined
+            ? { estimatedPerIntervalMusd }
+            : {}),
+        ...(asNum(f.annualizedRate) !== undefined
+            ? { annualizedRate: asNum(f.annualizedRate) }
+            : {}),
+    };
+}
 function coinIdFor(observation, symbol) {
     return (observation.watch.find((w) => w.symbol.toUpperCase() === symbol.toUpperCase())?.coinId ?? undefined);
 }
@@ -32,6 +61,9 @@ export async function fetchQuote(client, action, observation, trace) {
             slug: action.slug,
             outcomeExternalMarketId: action.outcomeExternalMarketId,
             stakeMusd: action.stakeMusd,
+            ...(action.forecastProbability != null
+                ? { forecastProbability: action.forecastProbability }
+                : {}),
         }, trace);
     }
     else {
@@ -62,6 +94,9 @@ export async function fetchQuote(client, action, observation, trace) {
                 futuresFeeBps: asNum(asObj(d.executionModel).feeBps),
                 estimatedEntryFeeMusd: asNum(asObj(d.executionModel).estimatedEntryFeeMusd),
                 cashRequiredMusd: asNum(d.cashRequiredMusd),
+                ...(Object.prototype.hasOwnProperty.call(d, "funding")
+                    ? { funding: fundingQuoteEvidence(d.funding) }
+                    : {}),
             }
             : {}),
         // Freshness lives in the response's `observation` block (anti-look-ahead).
@@ -146,6 +181,7 @@ provenance) {
             ...(action.forecastProbability != null
                 ? { forecastProbability: action.forecastProbability }
                 : {}),
+            ...(action.thesis?.summary ? { thesis: action.thesis.summary } : {}),
             // Attach runner provenance only when present (byte-identical to before when absent).
             ...(provenance ? { provenance } : {}),
             agentTrace: trace,

package/dist/agent/client.d.ts

@@ -91,6 +91,9 @@ export declare class CoinRithmClient {
         slug: string;
         outcomeExternalMarketId: string;
         stakeMusd: number;
+        side?: "yes" | "no";
+        forecastProbability?: number;
+        bankrollMusd?: number;
     }, trace?: AgentTrace): Promise<ApiResult>;
     openFutures(body: {
         coinId: string;
@@ -133,6 +136,7 @@ export declare class CoinRithmClient {
         stakeMusd: number;
         idempotencyKey: string;
         forecastProbability?: number;
+        thesis?: string;
         provenance?: ProvenanceReport;
         agentTrace?: AgentTrace;
     }): Promise<ApiResult>;

package/dist/agent/decision.d.ts

@@ -19,9 +19,9 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     marginMusd?: any;
     stopLossPrice?: any;
     takeProfitPrice?: any;
+    thesis?: import("./types.js").Thesis | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
-    thesis?: import("./types.js").Thesis | undefined;
 }, {
     symbol: string;
     side: "long" | "short";
@@ -30,9 +30,9 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     marginMusd?: unknown;
     stopLossPrice?: unknown;
     takeProfitPrice?: unknown;
+    thesis?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
-    thesis?: any;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"futures_close">;
     positionId: z.ZodEffects<z.ZodTypeAny, any, unknown>;
@@ -44,16 +44,16 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     type: "futures_close";
     positionId?: any;
     fraction?: any;
+    thesis?: import("./types.js").Thesis | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
-    thesis?: import("./types.js").Thesis | undefined;
 }, {
     type: "futures_close";
     positionId?: unknown;
     fraction?: unknown;
+    thesis?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
-    thesis?: any;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"futures_set_sltp">;
     positionId: z.ZodEffects<z.ZodTypeAny, any, unknown>;
@@ -67,17 +67,17 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     stopLossPrice?: any;
     takeProfitPrice?: any;
     positionId?: any;
+    thesis?: import("./types.js").Thesis | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
-    thesis?: import("./types.js").Thesis | undefined;
 }, {
     type: "futures_set_sltp";
     stopLossPrice?: unknown;
     takeProfitPrice?: unknown;
     positionId?: unknown;
+    thesis?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
-    thesis?: any;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"spot_order">;
     symbol: z.ZodString;
@@ -97,9 +97,9 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     quantity?: any;
     limitPrice?: any;
     stopPrice?: any;
+    thesis?: import("./types.js").Thesis | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
-    thesis?: import("./types.js").Thesis | undefined;
 }, {
     symbol: string;
     side: "buy" | "sell";
@@ -108,9 +108,9 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     quantity?: unknown;
     limitPrice?: unknown;
     stopPrice?: unknown;
+    thesis?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
-    thesis?: any;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"spot_cancel">;
     orderId: z.ZodEffects<z.ZodTypeAny, any, unknown>;
@@ -119,16 +119,16 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     thesis: z.ZodOptional<z.ZodEffects<z.ZodAny, import("./types.js").Thesis | undefined, any>>;
 }, "strict", z.ZodTypeAny, {
     type: "spot_cancel";
+    thesis?: import("./types.js").Thesis | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
     orderId?: any;
-    thesis?: import("./types.js").Thesis | undefined;
 }, {
     type: "spot_cancel";
+    thesis?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
     orderId?: unknown;
-    thesis?: any;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"pm_open">;
     ref: z.ZodOptional<z.ZodString>;
@@ -147,9 +147,9 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     outcomeExternalMarketId?: string | undefined;
     stakeMusd?: any;
     forecastProbability?: number | undefined;
+    thesis?: import("./types.js").Thesis | undefined;
     confidence?: any;
     rationaleSummary?: string | undefined;
-    thesis?: import("./types.js").Thesis | undefined;
     ref?: string | undefined;
 }, {
     type: "pm_open";
@@ -158,9 +158,9 @@ export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<
     outcomeExternalMarketId?: string | undefined;
     stakeMusd?: unknown;
     forecastProbability?: any;
+    thesis?: any;
     confidence?: unknown;
     rationaleSummary?: string | undefined;
-    thesis?: any;
     ref?: string | undefined;
 }>]>;
 export declare const DECISION_JSON_SCHEMA: {

package/dist/agent/engine.d.ts

@@ -1,6 +1,6 @@
 export { runCycle, type RunnerDeps } from "./runner.js";
 export { DECISION_INPUT_MAX_BYTES, sanitizeDecisionInputRecord, type DecisionInputRecord, } from "./decisionReceipt.js";
-export { selectProvider, providerForRoute, type ProviderEnv, type Provider, type DecideInput, type DecideResult, type DecideRouteAttempt, type DecideRouteMeta, } from "./providers.js";
+export { selectProvider, providerForRoute, classifyProviderFailure, type ProviderEnv, type Provider, type DecideInput, type DecideResult, type DecideRouteAttempt, type DecideRouteMeta, } from "./providers.js";
 export { parseDecision } from "./decision.js";
 export { chatShapeFor, buildChatBody, type ChatShape, } from "./providerCapabilities.js";
 export { probeDecisionContract, type ProbeRoute, type ProbeDecisionResult, } from "./decisionProbe.js";

package/dist/agent/engine.js

@@ -7,7 +7,7 @@
 // stable engine pieces, never the CLI.
 export { runCycle } from "./runner.js";
 export { DECISION_INPUT_MAX_BYTES, sanitizeDecisionInputRecord, } from "./decisionReceipt.js";
-export { selectProvider, providerForRoute, } from "./providers.js";
+export { selectProvider, providerForRoute, classifyProviderFailure, } from "./providers.js";
 export { parseDecision } from "./decision.js";
 // Reliability slice A: the declarative request-capability table and the
 // representative decision probe (route eligibility = a REAL parsed decision,

package/dist/agent/observe.js

@@ -90,8 +90,10 @@ async function fetchCandleContext(client, coinId, trace) {
     }
     if (!cr.ok)
         return { indicators: null };
-    // Endpoint shape: { candles: [{ t, o, h, l, c, v }] } ascending (oldest first).
+    // Endpoint shape: { candles: [{ t, o, h, l, c, v, vm }] } ascending (oldest first).
     const candles = [];
+    let latestVolume;
+    let latestVolumeMissingVenues;
     for (const raw of asArr(asObj(cr.data).candles)) {
         const c = asObj(raw);
         const open = asNum(c.o);
@@ -100,12 +102,22 @@ async function fetchCandleContext(client, coinId, trace) {
         const close = asNum(c.c);
         if (open == null || high == null || low == null || close == null)
             continue;
-        candles.push({ open, high, low, close, volume: asNum(c.v) ?? undefined });
+        const volume = asNum(c.v);
+        candles.push({ open, high, low, close, volume: volume ?? undefined });
+        latestVolume = volume != null && volume >= 0 ? volume : undefined;
+        const coverage = asNum(c.vm);
+        latestVolumeMissingVenues =
+            latestVolume != null &&
+                coverage != null &&
+                Number.isInteger(coverage) &&
+                coverage >= 0
+                ? coverage
+                : undefined;
     }
-    const lastVolume = candles.length > 0 ? candles[candles.length - 1].volume : undefined;
     return {
         indicators: computeIndicators(candles),
-        volume24hUsd: typeof lastVolume === "number" && lastVolume > 0 ? lastVolume : undefined,
+        volume24hUsd: latestVolume,
+        volumeMissingVenues: latestVolumeMissingVenues,
     };
 }
 // The fundamentals leg of a watch entry, read from the /market context the
@@ -141,6 +153,12 @@ async function enrichFromCandles(client, entry, coinId, trace) {
             volume24hUsd: cc.volume24hUsd,
         };
     }
+    if (cc.volumeMissingVenues != null) {
+        entry.fundamentals = {
+            ...(entry.fundamentals ?? {}),
+            volumeMissingVenues: cc.volumeMissingVenues,
+        };
+    }
 }
 const HEADLINES_PER_COIN = 3;
 const HEADLINE_TITLE_CHARS = 110;
@@ -316,6 +334,14 @@ export async function observe(client, spec, state, trace) {
         // and could not tell a winner from a small loser before a manual close.
         // Tolerant fallbacks keep older/mocked shapes working.
         const coin = asObj(p.coin);
+        const fundingPaidMusd = Object.prototype.hasOwnProperty.call(p, "fundingPaidMusd")
+            ? (asNum(p.fundingPaidMusd) ??
+                (p.fundingPaidMusd === null ? null : undefined))
+            : undefined;
+        const fundingAppliedThrough = Object.prototype.hasOwnProperty.call(p, "fundingAppliedThrough")
+            ? (asStr(p.fundingAppliedThrough) ??
+                (p.fundingAppliedThrough === null ? null : undefined))
+            : undefined;
         return {
             venue: "futures",
             id: Number(asNum(p.id) ?? p.id),
@@ -327,6 +353,10 @@ export async function observe(client, spec, state, trace) {
             leverage: asNum(p.leverage),
             marginMusd: asNum(p.marginMusd),
             unrealizedPnlMusd: asNum(p.unrealizedPnlMusd),
+            ...(fundingPaidMusd !== undefined ? { fundingPaidMusd } : {}),
+            ...(fundingAppliedThrough !== undefined
+                ? { fundingAppliedThrough }
+                : {}),
             entryPrice: asNum(p.entryPrice),
             markPrice: asNum(p.markPrice),
             liquidationPrice: asNum(p.liquidationPrice),

package/dist/agent/prompt.js

@@ -338,6 +338,10 @@ export function buildUserPrompt(obs, journal, opts = {}) {
     if (brokenTheses.length > 0) {
         lines.push("", "## Positions whose thesis is INVALIDATED this cycle", ...brokenTheses.map((b) => `- ${b}`));
     }
+    if (obs.openPositions.some((p) => p.fundingPaidMusd !== undefined ||
+        p.fundingAppliedThrough !== undefined)) {
+        lines.push("Futures funding shown in the position is already reflected in margin and balances; do not deduct it again when judging available capital or PnL.");
+    }
     // Settlement-feedback loop: surface the agent's recently-RESOLVED PM bets so the
     // model can reflect and adapt. Reflective context only — never a new action.
     if (hasPm)

package/dist/agent/providers.d.ts

@@ -52,6 +52,10 @@ export interface ProviderEnv {
     GEMINI_API_KEY?: string;
     MODEL_API_KEY?: string;
 }
+/** Keep direct and routed cycle evidence consistent about NVIDIA backpressure. */
+export declare function classifyProviderFailure(result: Extract<DecideResult, {
+    ok: false;
+}>): "capacity" | "permanent" | "transient";
 export declare function selectProvider(spec: AgentSpec, env: ProviderEnv, fetchFn?: typeof fetch): Provider;
 export declare function providerForRoute(route: {
     provider: ProviderName;

package/dist/agent/providers.js

@@ -29,6 +29,16 @@ const GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai
 // MUST stay below the scheduler's RUN_LOCK_SECONDS and HEARTBEAT_STALE_MS.
 const DEFAULT_TIMEOUT_MS = 300_000;
 const RETRYABLE_SERVER_STATUSES = new Set([500, 502, 503, 504]);
+/** Keep direct and routed cycle evidence consistent about NVIDIA backpressure. */
+export function classifyProviderFailure(result) {
+    if (result.status === 429 ||
+        (result.status === 503 &&
+            /resourceexhausted|worker local total request limit/i.test(result.error ?? "")))
+        return "capacity";
+    if (result.status === 404 || result.status === 410)
+        return "permanent";
+    return "transient";
+}
 // Per-route request quirks (reasoning toggles, token param, temperature) live
 // in the capability table — providerCapabilities.ts is the single source; this
 // module only assembles and sends.
@@ -332,15 +342,11 @@ class SameModelRetryProvider {
                     error: res.error,
                     status: res.status,
                     retryAfterMs: res.retryAfterMs,
-                    ...(res.status !== undefined
-                        ? {
-                            failureClass: res.status === 429
-                                ? "capacity"
-                                : res.status >= 500
-                                    ? "transient"
-                                    : "permanent",
-                        }
-                        : {}),
+                    failureClass: classifyProviderFailure(res) === "capacity"
+                        ? "capacity"
+                        : res.status !== undefined && res.status < 500
+                            ? "permanent"
+                            : "transient",
                 }
                 : {}),
         });
@@ -350,7 +356,7 @@ class SameModelRetryProvider {
             // or a certificate that returned text passed the trading-decision parser.
             ...result,
             route: {
-                policyVersion: "coinrithm.configured-same-model-retry.v1",
+                policyVersion: "coinrithm.configured-same-model-retry.v2",
                 profile: "configured",
                 effectiveProvider: this.provider,
                 effectiveModel: this.model,

package/dist/agent/runner.js

@@ -2,6 +2,7 @@
 // spot, futures, and prediction markets. Dry-run never writes. Live uses
 // idempotency keys + agentTrace and exports run evidence. The client + provider
 // are injected so the loop is fully unit-testable with no network/model calls.
+import { classifyProviderFailure } from "./providers.js";
 import { COINRITHM_API } from "./version.js";
 import { spotBuyCost, DEFAULT_TRIGGER_POLICY, } from "./types.js";
 import { usesCapitalSizing, prepareCapitalAction, validateCapitalAction, capitalCashCost, } from "./capitalSizing.js";
@@ -727,7 +728,7 @@ async function runCycleCore(deps, capture) {
             // only capacity failures. Treat that exactly like a local capacity defer:
             // no action, no fallback invented here, and no model-failure streak that
             // could stop an otherwise healthy agent after repeated quota pressure.
-            const capacityOnlyFailure = (!route && res.status === 429) ||
+            const capacityOnlyFailure = (!route && classifyProviderFailure(res) === "capacity") ||
                 (!!route?.attempts?.length &&
                     route.attempts.every((attempt) => attempt.failureClass === "capacity"));
             if (res.deferred || !actualCallMade || capacityOnlyFailure) {

package/dist/agent/templates.js

@@ -50,37 +50,37 @@ const PRESETS = {
         modelFail: 5,
     },
 };
-const THESIS_BODY = `# Momentum Futures — strategy
-
-You operate a CoinRithm **paper-trading** futures account (50,000 virtual mUSD).
-Everything here is simulated; it is not financial advice and never touches real
-money. Edit this prose freely (any language) — it is your agent's borders.
-
-## Each cycle
-
-1. Ground yourself: read your portfolio and open positions first. Never assume
-   balances or what is already open.
-2. Scan the watchlist. A candidate is a coin whose short and medium momentum
-   agree (both up, or both down) and is not already an open position.
-3. Pick the strongest candidate and commit when the read is clear — even a
-   moderate-confidence one — sized small with a stop. Skip only when the signals
-   contradict or the data is stale; a quiet tape where your edge is still real
-   is an act, not a skip.
-4. Quote before you open. Read the liquidation price and confirm it is sane. If
-   the quote is not eligible, relay the reason and stop.
-5. Open small and protected: enter in the trend direction and set a stop-loss at
-   open. Place the take-profit a touch wider than the stop.
-6. Stay in sync: poll your trades for any stop / take-profit / liquidation that
-   fired while you were not looking, and react to what actually happened.
-
-The hard caps (leverage, margin, watchlist) live in the config blocks above and
+const THESIS_BODY = `# Momentum Futures — strategy
+
+You operate a CoinRithm **paper-trading** futures account (50,000 virtual mUSD).
+Everything here is simulated; it is not financial advice and never touches real
+money. Edit this prose freely (any language) — it is your agent's borders.
+
+## Each cycle
+
+1. Ground yourself: read your portfolio and open positions first. Never assume
+   balances or what is already open.
+2. Scan the watchlist. A candidate is a coin whose short and medium momentum
+   agree (both up, or both down) and is not already an open position.
+3. Pick the strongest candidate and commit when the read is clear — even a
+   moderate-confidence one — sized small with a stop. Skip only when the signals
+   contradict or the data is stale; a quiet tape where your edge is still real
+   is an act, not a skip.
+4. Quote before you open. Read the liquidation price and confirm it is sane. If
+   the quote is not eligible, relay the reason and stop.
+5. Open small and protected: enter in the trend direction and set a stop-loss at
+   open. Place the take-profit a touch wider than the stop.
+6. Stay in sync: poll your trades for any stop / take-profit / liquidation that
+   fired while you were not looking, and react to what actually happened.
+
+The hard caps (leverage, margin, watchlist) live in the config blocks above and
 are enforced by the runner — change them there, not in this prose.`;
-const PERSONA_STUB = `# Persona
-
-Decisive and in character. Acts on a clear read — even a moderate-confidence one
-— sized small and protected with a stop, and skips only when the read is
-contradictory or the data is stale. States its reasoning plainly in its own
-voice, and never frames paper results as real-money advice.
+const PERSONA_STUB = `# Persona
+
+Decisive and in character. Acts on a clear read — even a moderate-confidence one
+— sized small and protected with a stop, and skips only when the read is
+contradictory or the data is stale. States its reasoning plainly in its own
+voice, and never frames paper results as real-money advice.
 `;
 export function buildAgentObject(name, preset) {
     const p = PRESETS[preset];

package/dist/agent/types.d.ts

@@ -153,6 +153,7 @@ export interface CoinFundamentals {
     marketCapRank?: number;
     marketCapUsd?: number;
     volume24hUsd?: number;
+    volumeMissingVenues?: number;
     headlines?: Array<{
         title: string;
         at?: string;
@@ -171,6 +172,8 @@ export interface OpenPosition {
     leverage?: number;
     marginMusd?: number;
     unrealizedPnlMusd?: number;
+    fundingPaidMusd?: number | null;
+    fundingAppliedThrough?: string | null;
     entryPrice?: number;
     markPrice?: number;
     liquidationPrice?: number;
@@ -397,10 +400,21 @@ export interface QuoteEvidence {
     futuresFeeBps?: number;
     estimatedEntryFeeMusd?: number;
     cashRequiredMusd?: number;
+    funding?: FuturesFundingQuoteEvidence | null;
     freshness?: Freshness;
     openBlocked?: boolean;
     openBlockReasons?: unknown;
 }
+export interface FuturesFundingQuoteEvidence {
+    venue?: string;
+    symbol?: string;
+    rate?: number;
+    intervalHours?: number;
+    nextFundingTime?: string;
+    asOf?: string;
+    estimatedPerIntervalMusd?: number | null;
+    annualizedRate?: number;
+}
 export interface RunState {
     runId: string;
     cyclesRun: number;

package/dist/client.d.ts

@@ -64,7 +64,11 @@ export declare class CoinRithmClient {
     getPublicPmEvent(source: string, slug: string, query?: {
         fiat?: string;
     }): Promise<ApiResult>;
+    /** Best-effort anonymous interest marker for an explicitly viewed open event. */
+    markPublicPmEventViewed(source: string, slug: string): Promise<ApiResult>;
     getPublicPmWhales(): Promise<ApiResult>;
+    getPublicPmWhaleWallets(window?: "7d" | "30d", source?: "polymarket" | "limitless" | "myriad"): Promise<ApiResult>;
+    getPublicPmWhaleWallet(source: string, wallet: string): Promise<ApiResult>;
     getPublicPmMatches(query?: {
         limit?: number;
         offset?: number;
@@ -168,6 +172,8 @@ export declare class CoinRithmClient {
         outcomeExternalMarketId: string;
         side?: "yes" | "no";
         stakeMusd: number;
+        forecastProbability?: number;
+        bankrollMusd?: number;
     } & {
         agentTrace?: AgentTrace;
     }, apiKey?: string): Promise<ApiResult>;
@@ -215,6 +221,7 @@ export declare class CoinRithmClient {
         stakeMusd: number;
         idempotencyKey: string;
         forecastProbability?: number;
+        thesis?: string;
         provenance?: ProvenanceReport;
     }>, apiKey?: string): Promise<ApiResult>;
     reportPmOpportunity(body: TraceableBody<{

package/dist/client.js

@@ -216,9 +216,52 @@ export class CoinRithmClient {
     getPublicPmEvent(source, slug, query) {
         return this.publicRequest(`/api/prediction-markets/events/${encodeURIComponent(source)}/${encodeURIComponent(slug)}`, query);
     }
+    /** Best-effort anonymous interest marker for an explicitly viewed open event. */
+    markPublicPmEventViewed(source, slug) {
+        const path = `/api/prediction-markets/events/${encodeURIComponent(source)}/${encodeURIComponent(slug)}/view`;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 1000);
+        return fetch(this.baseUrl + path, {
+            method: "POST",
+            headers: { Accept: "application/json" },
+            signal: controller.signal,
+        })
+            .then(async (res) => {
+            const text = await res.text();
+            let data = text;
+            if (text) {
+                try {
+                    data = JSON.parse(text);
+                }
+                catch {
+                    // leave as text
+                }
+            }
+            return { ok: res.ok, status: res.status, data };
+        })
+            .catch((err) => ({
+            ok: false,
+            status: 0,
+            data: {
+                error: err instanceof DOMException && err.name === "AbortError"
+                    ? "timeout"
+                    : "network_error",
+            },
+        }))
+            .finally(() => clearTimeout(timer));
+    }
     getPublicPmWhales() {
         return this.publicRequest("/api/prediction-markets/whales");
     }
+    getPublicPmWhaleWallets(window, source) {
+        return this.publicRequest("/api/prediction-markets/whales/wallets", {
+            ...(window ? { window } : {}),
+            ...(source ? { source } : {}),
+        });
+    }
+    getPublicPmWhaleWallet(source, wallet) {
+        return this.publicRequest(`/api/prediction-markets/whales/wallets/${encodeURIComponent(source)}/${encodeURIComponent(wallet)}`);
+    }
     // Cross-venue disagreement clusters (approved event matches, graph-clustered).
     getPublicPmMatches(query) {
         return this.publicRequest("/api/prediction-markets/matches/public", query);

package/dist/httpCompletion.d.ts

@@ -1,6 +1,6 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-export declare const COMPLETION_TOOL_NAMES: readonly ["whoami", "get_portfolio", "get_wallet", "list_open_orders", "get_positions", "resolve_symbol", "get_equity_curve", "get_my_trades", "get_market_context", "get_candles", "discover_pm_markets", "get_performance", "get_agent_ledger", "export_agent_ledger", "export_run_evidence", "get_arena_leaderboard", "get_arena_agent", "futures_quote", "pm_quote", "spot_quote", "place_spot_order", "cancel_spot_order", "open_futures_position", "set_futures_sl_tp", "close_futures_position", "open_pm_position", "report_pm_opportunity", "pm_data_overview", "pm_data_sources", "pm_data_sources_health", "pm_data_events", "pm_data_event", "pm_data_whales", "pm_data_disagreements", "pm_data_calibration", "pm_data_canonical", "pm_data_volume_history", "get_crypto_movers"];
+export declare const COMPLETION_TOOL_NAMES: readonly ["whoami", "get_portfolio", "get_wallet", "list_open_orders", "get_positions", "resolve_symbol", "get_equity_curve", "get_my_trades", "get_market_context", "get_candles", "discover_pm_markets", "get_performance", "get_agent_ledger", "export_agent_ledger", "export_run_evidence", "get_arena_leaderboard", "get_arena_agent", "futures_quote", "pm_quote", "spot_quote", "place_spot_order", "cancel_spot_order", "open_futures_position", "set_futures_sl_tp", "close_futures_position", "open_pm_position", "report_pm_opportunity", "pm_data_overview", "pm_data_sources", "pm_data_sources_health", "pm_data_events", "pm_data_event", "pm_data_whales", "pm_data_whale_wallets", "pm_data_whale_wallet", "pm_data_disagreements", "pm_data_calibration", "pm_data_canonical", "pm_data_volume_history", "get_crypto_movers"];
 type Operation = "initialize" | "tools_list" | "tools_call" | "notification" | "other" | "invalid";
 type Outcome = "result" | "tool_error" | "protocol_error" | "no_response" | "not_applicable";
 type ToolName = (typeof COMPLETION_TOOL_NAMES)[number] | "unknown" | null;

package/dist/httpCompletion.js

@@ -36,6 +36,8 @@ export const COMPLETION_TOOL_NAMES = [
     "pm_data_events",
     "pm_data_event",
     "pm_data_whales",
+    "pm_data_whale_wallets",
+    "pm_data_whale_wallet",
     "pm_data_disagreements",
     "pm_data_calibration",
     "pm_data_canonical",

package/dist/tools.d.ts

@@ -14,6 +14,8 @@ export declare function compactPublicPmEvents(data: unknown): unknown;
  */
 export declare function compactPublicPmEvent(data: unknown): unknown;
 export declare function compactPublicPmWhales(data: unknown, limit: number): unknown;
+export declare function compactPublicPmWhaleWallets(data: unknown, limit: number, requestedSource?: string): unknown;
+export declare function compactPublicPmWhaleWalletDetail(data: unknown): unknown;
 export declare function compactPublicCryptoMovers(data: unknown): unknown;
 /**
  * Keep cross-venue disagreement clusters small enough for an agent context