@coinrithm/mcp-trading 0.7.13 → 0.7.15

package/dist/agent/types.d.ts

@@ -1,3 +1,4 @@
+import type { FuturesEntryEligibility } from "./futuresEligibility.js";
 import { IndicatorSet } from "./indicators.js";
 import type { DecisionInputRecord } from "./decisionReceipt.js";
 export declare const SPEC_VERSION = "coinrithm.agent.v1";
@@ -34,6 +35,7 @@ export interface RiskConfig {
     watchlist: string[];
     blocklist?: string[];
     direction?: "long_only" | "short_only";
+    pmMinEntryProbabilityPct?: number;
 }
 export interface LimitsConfig {
     maxTradesPerDay: number;
@@ -96,7 +98,7 @@ export interface ObjectiveConfig {
     secondary: string[];
     horizon?: string;
 }
-export declare const ALLOWED_CAPABILITIES: readonly ["websearch", "indicators", "news", "universe_scan"];
+export declare const ALLOWED_CAPABILITIES: readonly ["websearch", "indicators", "news", "universe_scan", "whale_context"];
 export type Capability = (typeof ALLOWED_CAPABILITIES)[number];
 export interface AgentSpec {
     name: string;
@@ -133,6 +135,21 @@ export interface Freshness {
     asOf?: string;
     basis?: string;
 }
+export interface IndicatorContext {
+    range: "1D";
+    nominalIntervalSeconds: 300;
+    barCount: number;
+    timestampedBarCount: number;
+    checkedIntervalCount: number;
+    irregularIntervalCount: number;
+    intervalStatus: "regular" | "irregular" | "unknown";
+    maxGapSeconds?: number;
+    asOf?: string;
+    recent15: {
+        barCount: number;
+        intervalStatus: "regular" | "irregular" | "unknown";
+    };
+}
 export interface WatchEntry {
     symbol: string;
     coinId: string | null;
@@ -142,11 +159,16 @@ export interface WatchEntry {
     change24h?: number;
     change7d?: number;
     sentimentBullishPct?: number;
+    sentimentTotalVotes?: number;
+    sentimentDayUtc?: string;
+    sentimentUpdatedAt?: string;
     freshness?: Freshness;
     indicators?: IndicatorSet;
+    indicatorContext?: IndicatorContext;
     discovered?: boolean;
     slug?: string;
     fundamentals?: CoinFundamentals;
+    futuresEntryEligibility?: FuturesEntryEligibility;
 }
 export interface CoinFundamentals {
     categories?: string[];
@@ -230,6 +252,42 @@ export interface PmMarket {
     liquidityUsd?: number;
     quality?: PmQuality;
     decisionSupport?: PmDecisionSupport;
+    consensus?: PmConsensus | null;
+    rules?: PmSettlementRule | null;
+    outcomeRule?: PmOutcomeRule;
+}
+export interface PmCalibration {
+    settled: number;
+    brierAgent: number | null;
+    brierMarket: number | null;
+    meanForecastPct: number | null;
+    winRatePct: number | null;
+    bands: Array<{
+        fromPct: number;
+        toPct: number;
+        n: number;
+        meanForecastPct: number;
+        winRatePct: number;
+    }>;
+}
+export interface PmSettlementRule {
+    published: boolean;
+    text?: string;
+    sources?: string[];
+    scope?: "per_outcome";
+}
+export type PmOutcomeRule = {
+    primary: string;
+    secondary?: string;
+} | {
+    unknown: "source_rules_unavailable" | "market_not_found" | "rule_missing" | "conflicting_duplicates" | "unreadable";
+};
+export interface PmConsensus {
+    prob: number;
+    venues: number;
+    spreadPts: number;
+    kind: "binary" | "leader";
+    outcome: string | null;
 }
 export interface PmQuality {
     decisionEligible?: boolean;
@@ -265,6 +323,78 @@ export interface NewsItem {
     publishedAt?: string;
     coins?: string[];
 }
+export type WhaleContextStatus = "available" | "partial" | "unavailable";
+export type WhaleContextFailure = "timeout" | "network_error" | "http_error" | "invalid_payload";
+export interface WhaleTradeContext {
+    source: string;
+    eventSlug: string;
+    eventTitle?: string;
+    marketQuestion?: string;
+    side: string;
+    outcome?: string;
+    usdValue?: number;
+    price?: number;
+    sourceMarketRef?: string;
+    valueBasis?: string;
+    evidenceType?: string;
+    evidenceRef?: string;
+    nativeValue?: number;
+    nativeCurrency?: string;
+    availability?: "live" | "delayed" | "unavailable";
+    tradedAt?: string;
+    observedAt?: string;
+    latencySeconds?: number;
+    walletAddress?: string;
+}
+export interface WhaleWalletFillContext {
+    eventSlug?: string;
+    eventTitle?: string;
+    marketQuestion?: string;
+    side?: string;
+    outcome?: string;
+    usdValue?: number;
+    price?: number;
+    evidenceType?: string;
+    tradedAt?: string;
+    sourceMarketRef?: string;
+}
+export interface WhaleWalletContext {
+    source: string;
+    address: string;
+    asOf?: string;
+    summary30d?: {
+        basis?: string;
+        windowStart?: string;
+        tradeCount?: number;
+        notionalUsd?: number;
+        buyNotionalUsd?: number;
+        sellNotionalUsd?: number;
+    };
+    rollup?: {
+        available?: boolean;
+        coveredDays?: number;
+        from?: string;
+        to?: string;
+        computedAt?: string;
+    };
+    daily: Array<{
+        day?: string;
+        tradeCount?: number;
+        buyCount?: number;
+        sellCount?: number;
+        notionalUsd?: number;
+    }>;
+    recentFills: WhaleWalletFillContext[];
+}
+export interface WhaleContext {
+    status: WhaleContextStatus;
+    fetchedAt: string;
+    coverage: "relevant_events" | "no_relevant_events";
+    trades: WhaleTradeContext[];
+    wallets: WhaleWalletContext[];
+    omitted: number;
+    reason?: WhaleContextFailure;
+}
 export interface Observation {
     asOf: string;
     scopes: string[];
@@ -276,16 +406,19 @@ export interface Observation {
     pmPositions: PmPosition[];
     pmResolutions: PmResolution[];
     pmMarkets: PmMarket[];
+    pmCalibration?: PmCalibration;
     watch: WatchEntry[];
     setups: SetupSignal[];
     marketMood?: {
         fearGreed: number;
         label: string;
+        fetchedAt?: string;
     };
     syncCursor: string | null;
     newClosedTrades: Array<Record<string, unknown>>;
     polledBeforeWrite: boolean;
     news?: NewsItem[];
+    whaleContext?: WhaleContext;
     universeMovers?: Array<{
         symbol: string;
         name?: string;
@@ -437,6 +570,10 @@ export interface RunState {
     lastLlmCallAt?: number;
     lastTriggerFingerprint?: string;
     consecutivePermanentModelErrors?: number;
+    permanentModelErrorRoute?: {
+        provider: string;
+        model: string;
+    };
     consecutiveAuthFailures?: number;
     journal?: Array<{
         at: string;

package/dist/agent/types.js

@@ -50,6 +50,9 @@ export const OBJECTIVE_PRIMARIES = [
 // slice. `websearch` = external lookups (an injection surface + a cost — it can
 // inform reasoning but NEVER widen a cap, since caps live in the runner);
 // `indicators` = runner-computed RSI/MACD/etc. fed into the observation.
+// `whale_context` reads bounded public prediction-market whale context only
+// after the deterministic gate fires, and only when PM is in the venue scope.
+// It never widens the candidate set or acts as a trading signal by itself.
 // `universe_scan` (2026-08-18, direct user request): each cycle the runner
 // pulls the top 24h movers across CoinRithm's tracked coin universe, resolves
 // the top few into FULL watch entries (price, sentiment, indicators when that
@@ -64,6 +67,7 @@ export const ALLOWED_CAPABILITIES = [
     "indicators",
     "news",
     "universe_scan",
+    "whale_context",
 ];
 export const ok = () => ({ valid: true });
 export const fail = (code, reason) => ({

package/dist/client.d.ts

@@ -39,6 +39,7 @@ export type ProvenanceReport = {
         sourceCapturedAt?: string;
     };
 };
+export declare const API_KEY_MINT_URL = "https://www.coinrithm.com/en/settings/api-keys";
 export declare class CoinRithmClient {
     private readonly defaultApiKey?;
     private readonly baseUrl;
@@ -113,6 +114,12 @@ export declare class CoinRithmClient {
         range?: "1H" | "1D" | "1W" | "1M" | "3M";
         fiat?: string;
     }, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
+    getNews(query: {
+        coins: string;
+        limit?: number;
+        hours?: number;
+        minImportance?: number;
+    }, apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
     discoverPmMarkets(query?: {
         q?: string;
         source?: "all" | "kalshi" | "polymarket";
@@ -145,8 +152,8 @@ export declare class CoinRithmClient {
         page?: number;
         pageSize?: number;
         window?: "7d" | "30d" | "all";
-    }, apiKey?: string): Promise<ApiResult>;
-    getArenaAgent(handle: string, apiKey?: string): Promise<ApiResult>;
+    }): Promise<ApiResult>;
+    getArenaAgent(handle: string): Promise<ApiResult>;
     listOpenOrders(query?: {
         coinId?: string;
         limit?: number;
@@ -174,6 +181,7 @@ export declare class CoinRithmClient {
         stakeMusd: number;
         forecastProbability?: number;
         bankrollMusd?: number;
+        minEntryProbabilityPct?: number;
     } & {
         agentTrace?: AgentTrace;
     }, apiKey?: string): Promise<ApiResult>;
@@ -221,6 +229,7 @@ export declare class CoinRithmClient {
         stakeMusd: number;
         idempotencyKey: string;
         forecastProbability?: number;
+        minEntryProbabilityPct?: number;
         thesis?: string;
         provenance?: ProvenanceReport;
     }>, apiKey?: string): Promise<ApiResult>;

package/dist/client.js

@@ -71,6 +71,9 @@ const applyAgentTraceHeaders = (headers, trace) => {
 const traceFromBody = (body) => body && typeof body === "object" && "agentTrace" in body
     ? body.agentTrace
     : undefined;
+// Where a user mints an API key (Settings -> API Keys). Named in every
+// missing-key error so an assistant can tell its user where to go.
+export const API_KEY_MINT_URL = "https://www.coinrithm.com/en/settings/api-keys";
 export class CoinRithmClient {
     // Default key for the stdio (single-user) path. Undefined in the multi-user
     // HTTP path, where every call must pass a per-request `apiKey` override.
@@ -88,8 +91,10 @@ export class CoinRithmClient {
                 status: 401,
                 data: {
                     error: "missing_api_key",
-                    message: "No API key for this request. On the hosted MCP, send " +
-                        "`Authorization: Bearer crk_live_…` with your own key.",
+                    message: "No API key for this request. Mint a free key at " +
+                        `${API_KEY_MINT_URL}, then on the hosted MCP send ` +
+                        "`Authorization: Bearer crk_live_…`. Public data tools " +
+                        "(pm_data_*, get_arena_*, get_crypto_movers) need no key.",
                 },
             };
         }
@@ -337,6 +342,13 @@ export class CoinRithmClient {
     getCandles(coinId, query, apiKey, agentTrace) {
         return this.request("GET", `/api/agent/market/${encodeURIComponent(coinId)}/candles`, { query, apiKey, agentTrace });
     }
+    getNews(query, apiKey, agentTrace) {
+        return this.request("GET", "/api/agent/news", {
+            query,
+            apiKey,
+            agentTrace,
+        });
+    }
     discoverPmMarkets(query, apiKey, agentTrace) {
         return this.request("GET", "/api/agent/pm/discover", {
             query,
@@ -364,15 +376,15 @@ export class CoinRithmClient {
             agentTrace,
         });
     }
-    // Agent Arena (public leaderboard). The key is sent but ignored by these
-    // endpoints — they expose only public agent names + realized performance.
-    getArenaLeaderboard(query, apiKey) {
-        return this.request("GET", "/api/arena", { query, apiKey });
+    // Agent Arena (public leaderboard): public agent names + realized
+    // performance only, served keyless by the API. These used to go through
+    // the keyed path, so a keyless MCP client got a 401 for public data
+    // (21 of 44 keyless tool calls failed in 14.6h, audit 2026-09-29).
+    getArenaLeaderboard(query) {
+        return this.publicRequest("/api/arena", query);
     }
-    getArenaAgent(handle, apiKey) {
-        return this.request("GET", `/api/arena/${encodeURIComponent(handle)}`, {
-            apiKey,
-        });
+    getArenaAgent(handle) {
+        return this.publicRequest(`/api/arena/${encodeURIComponent(handle)}`);
     }
     listOpenOrders(query, apiKey, agentTrace) {
         return this.request("GET", "/api/agent/orders/open", {

package/dist/http.d.ts

@@ -2,6 +2,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { CoinRithmClient } from "./client.js";
 import { type CompletionLogger } from "./httpCompletion.js";
+export declare const MALFORMED_MCP_LINK: RegExp;
 export declare function createHttpApp(client: CoinRithmClient, options?: {
     completionLogger?: CompletionLogger;
     createServer?: () => McpServer;

package/dist/http.js

@@ -34,6 +34,7 @@
 // Transport is stateless: a fresh McpServer + transport per request, which is
 // the correct isolation model for a multi-user, per-request-keyed surface — no
 // session state is shared between users.
+import { SERVER_INSTRUCTIONS } from "./instructions.js";
 import express from "express";
 import { pathToFileURL } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -42,6 +43,9 @@ import { CoinRithmClient, bearerFromHeader, loadHttpConfig, log, } from "./clien
 import { registerTools } from "./tools.js";
 import { SERVER_VERSION } from "./version.js";
 import { observeHttpCompletion, } from "./httpCompletion.js";
+// "/mcp" immediately followed by the markdown "](" of a pasted link, literal or
+// percent-encoded. Anything else under /mcp is not this family.
+export const MALFORMED_MCP_LINK = /^\/mcp(?:\]|%5d)(?:\(|%28)/i;
 // Factory permits isolated localhost SDK tests without opening a listener on import.
 export function createHttpApp(client, options = {}) {
     const app = express();
@@ -108,13 +112,24 @@ export function createHttpApp(client, options = {}) {
     app.get("/robots.txt", (_req, res) => {
         res.type("text/plain").send("User-agent: *\nDisallow: /\n");
     });
+    // Recover one observed malformed URL family. A markdown link to this
+    // endpoint circulates with its "](https://…)" suffix pasted into the path,
+    // e.g. GET /mcp](https:/mcp.coinrithm.com/mcp): 408 such requests on
+    // 2026-09-25, all Claude-User web fetches that received Express's default
+    // 404. GET/HEAD go to the service descriptor. POST is served as MCP below:
+    // on 2026-09-26, 127 Claude-User connector POSTs in 6 h hit the same path
+    // and got 404, so a user who pasted that URL into a connector could never
+    // initialize. Every other unknown path behaves as before.
+    app.get(MALFORMED_MCP_LINK, (_req, res) => {
+        res.redirect(302, "/");
+    });
     app.get("/mcp", (_req, res) => {
         res.status(405).json({
             error: "method_not_allowed",
             message: "This is a POST-only streamable-HTTP MCP endpoint. Connect with an MCP client, or GET / for service info.",
         });
     });
-    app.post("/mcp", async (req, res) => {
+    app.post(["/mcp", MALFORMED_MCP_LINK], async (req, res) => {
         // Per-request auth: read THIS caller's key from the Authorization header,
         // or from Smithery's non-reserved forwarding header.
         // It is optional at the transport layer so registries can initialize the
@@ -132,7 +147,7 @@ export function createHttpApp(client, options = {}) {
             new McpServer({
                 name: "coinrithm-trading",
                 version: SERVER_VERSION,
-            });
+            }, { instructions: SERVER_INSTRUCTIONS });
         if (!options.createServer)
             registerTools(server, client);
         const transport = new StreamableHTTPServerTransport({

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_whale_wallets", "pm_data_whale_wallet", "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", "get_news", "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

@@ -13,6 +13,7 @@ export const COMPLETION_TOOL_NAMES = [
     "get_my_trades",
     "get_market_context",
     "get_candles",
+    "get_news",
     "discover_pm_markets",
     "get_performance",
     "get_agent_ledger",

package/dist/index.js

@@ -10,6 +10,7 @@
 //   COINRITHM_API_URL  (optional)  base URL; defaults to https://api.coinrithm.com
 //
 // stdout is the JSON-RPC channel — we log ONLY to stderr.
+import { SERVER_INSTRUCTIONS } from "./instructions.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CoinRithmClient, loadConfig, log } from "./client.js";
@@ -21,7 +22,7 @@ async function main() {
     const server = new McpServer({
         name: "coinrithm-trading",
         version: SERVER_VERSION,
-    });
+    }, { instructions: SERVER_INSTRUCTIONS });
     registerTools(server, client);
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/instructions.d.ts

@@ -0,0 +1 @@
+export declare const SERVER_INSTRUCTIONS: string;

package/dist/instructions.js

@@ -0,0 +1,16 @@
+import { API_KEY_MINT_URL } from "./client.js";
+import { PAPER_NOTE } from "./tools.js";
+// Sent once in the MCP `initialize` result. Guidance that used to be repeated
+// on every tool description lives here, so the tool list stays small enough to
+// fit an assistant's context (tools/list was 114,668 bytes with the ~512-char
+// paper disclaimer on 25 tools, audit 2026-09-29).
+export const SERVER_INSTRUCTIONS = [
+    "CoinRithm MCP: crypto and prediction-market data from 12 venues, plus paper trading.",
+    "Start keyless: the pm_data_* tools, get_arena_leaderboard, get_arena_agent and get_crypto_movers need no API key.",
+    "pm_data_events returns open markets by default; pass status=closed or status=all for history.",
+    `Tools that read or act on an account need a key. The user mints one at ${API_KEY_MINT_URL}; start with a read-only key.`,
+    "Every tool returns { httpStatus, ok, ledgerEventId, ledgerStatus, body }: httpStatus is CoinRithm's HTTP status (0 = network error), ok means 2xx, body is the parsed response.",
+    "Always quote before a paper write (spot_quote, futures_quote or pm_quote), then open with that quote.",
+    "Prediction-market probabilities are venue prices, not CoinRithm forecasts. referenceProbability is a cross-venue consensus with a disagreement band (spreadPoints).",
+    PAPER_NOTE,
+].join("\n");

package/dist/tools.d.ts

@@ -1,6 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { CoinRithmClient } from "./client.js";
 export declare const PAPER_NOTE: string;
+export declare const PAPER_NOTE_SHORT: string;
 /**
  * Keep keyless discovery calls small enough for an agent context window.
  * Full event evidence remains available from pm_data_event.