@coinrithm/mcp-trading 0.7.5 → 0.7.6

package/dist/agent/types.js

@@ -50,10 +50,20 @@ 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.
+// `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
+// capability is also on) and appends them to the observation marked
+// `discovered: true`. Downstream is unchanged by design: a discovered entry
+// passes through the exact same risk gates as a watchlist symbol (blocklist
+// still wins, caps/SL rules unchanged) — the capability widens the CANDIDATE
+// SET for one cycle, never any cap. Off by default; without it the universe
+// is invisible and only manual watchlist pairs are analyzed.
 export const ALLOWED_CAPABILITIES = [
     "websearch",
     "indicators",
     "news",
+    "universe_scan",
 ];
 export const ok = () => ({ valid: true });
 export const fail = (code, reason) => ({

package/dist/agent/version.d.ts

@@ -5,7 +5,7 @@ export declare const COINRITHM_API: {
     readonly kind: "coinrithm-agent-api";
     readonly baseUrl: "https://api.coinrithm.com";
     readonly mcpUrl: "https://mcp.coinrithm.com/mcp";
-    readonly openapiVersion: "1.6.0";
+    readonly openapiVersion: "1.7.0";
     readonly mcpPackage: "@coinrithm/mcp-trading";
     readonly mcpVersion: string;
 };

package/dist/agent/version.js

@@ -20,7 +20,7 @@ export const COINRITHM_API = {
     mcpUrl: "https://mcp.coinrithm.com/mcp",
     // The API CONTRACT version (openapi.yaml info.version). Versioned independently
     // from the npm package below — hand-bump this when the OpenAPI contract changes.
-    openapiVersion: "1.6.0",
+    openapiVersion: "1.7.0",
     mcpPackage: "@coinrithm/mcp-trading",
     mcpVersion: PACKAGE_VERSION,
 };

package/dist/client.d.ts

@@ -83,6 +83,7 @@ export declare class CoinRithmClient {
     }): Promise<ApiResult>;
     getPublicPmCanonicalDetail(key: string): Promise<ApiResult>;
     getPublicPmVolumeHistory(): Promise<ApiResult>;
+    getPublicCryptoMovers(direction: "gainers" | "losers", limit?: number): Promise<ApiResult>;
     whoami(apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
     getPortfolio(query?: {
         fiat?: string;

package/dist/client.js

@@ -236,6 +236,16 @@ export class CoinRithmClient {
     getPublicPmVolumeHistory() {
         return this.publicRequest("/api/prediction-markets/volume-history");
     }
+    // ---- public crypto data (no key required) ----
+    // Top 24h movers across the tracked coin universe (user feature request,
+    // 2026-08-18: agents previously could only analyze manually-added pairs).
+    // Backend caps limit at 100; rows are {ucid, symbol, name, slug, change24h,
+    // currentPrice} ordered by 24h change.
+    getPublicCryptoMovers(direction, limit) {
+        return this.publicRequest(direction === "losers"
+            ? "/api/coins/top-losers"
+            : "/api/coins/top-gainers", { limit });
+    }
     // Every method takes an optional trailing `apiKey` (the per-request key for
     // the multi-user HTTP path). When omitted, the constructor key (stdio) is used.
     // ---- reads (scope: read) ----

package/dist/tools.d.ts

@@ -14,6 +14,7 @@ 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 compactPublicCryptoMovers(data: unknown): unknown;
 /**
  * Keep cross-venue disagreement clusters small enough for an agent context
  * window: each event is reduced to eventSummary (drops descriptions, images,

package/dist/tools.js

@@ -492,6 +492,34 @@ export function compactPublicPmWhales(data, limit) {
         : data.trades;
     return { ...data, trades };
 }
+// Crypto movers rows arrive as {ucid, symbol, name, slug, change24h,
+// currentPrice} with the numerics as STRINGS (backend SQL fn passthrough).
+// Coerce so a brain never string-compares "9.5" > "12"; drop the internal
+// ucid. A row that fails coercion passes through untouched — honesty over
+// polish, same rule as every other compactor here.
+export function compactPublicCryptoMovers(data) {
+    if (!Array.isArray(data))
+        return data;
+    return data.map((row) => {
+        if (!isJsonRecord(row))
+            return row;
+        const change = Number(row.change24h);
+        const price = Number(row.currentPrice);
+        return {
+            // coinId IS the ucid the rest of the tool surface takes (get_candles,
+            // get_market_context, the futures quote/open path). Carrying it through
+            // is not cosmetic: without it the caller has to re-derive the coin from
+            // the SYMBOL via resolve_symbol, and symbols collide across listings —
+            // the round-trip can land on a different coin than the one that moved.
+            coinId: row.ucid,
+            symbol: row.symbol,
+            name: row.name,
+            slug: row.slug,
+            change24hPct: Number.isFinite(change) ? change : row.change24h,
+            priceUsd: Number.isFinite(price) ? price : row.currentPrice,
+        };
+    });
+}
 const MATCH_PAIR_FIELDS = [
     "matchId",
     "confidence",
@@ -1757,4 +1785,32 @@ export function registerTools(server, client) {
         outputSchema: API_RESULT_OUTPUT_SCHEMA,
         annotations: readOnlyAnnotations("Global prediction-market volume trend"),
     }, async () => present(await client.getPublicPmVolumeHistory()));
+    server.registerTool("get_crypto_movers", {
+        title: "Top 24h crypto movers (universe scan)",
+        description: "Free public scan of CoinRithm's tracked crypto universe for the " +
+            "biggest 24h price moves — top gainers or top losers, ordered by " +
+            "24h change percent. Use this to DISCOVER candidates beyond your " +
+            "watchlist (abnormal rapid moves), then deep-analyze each candidate " +
+            "with get_candles (OHLC + indicators) and get_market_context " +
+            "(sentiment, news) before any trade decision. Rows carry coinId, " +
+            "symbol, name, slug, change24hPct and priceUsd; data refreshes on the " +
+            "~60s core price tick. Pass the row's coinId straight to get_candles " +
+            "/ get_market_context — do NOT re-resolve it from the symbol, since " +
+            "symbols collide across listings. No API key required.",
+        inputSchema: {
+            direction: z
+                .enum(["gainers", "losers"])
+                .optional()
+                .describe("Scan direction (default gainers)."),
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(100)
+                .optional()
+                .describe("Rows to return, 1-100 (default 20)."),
+        },
+        outputSchema: API_RESULT_OUTPUT_SCHEMA,
+        annotations: readOnlyAnnotations("Top 24h crypto movers"),
+    }, async ({ direction, limit }) => present(mapSuccessfulBody(await client.getPublicCryptoMovers(direction ?? "gainers", limit ?? 20), compactPublicCryptoMovers)));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinrithm/mcp-trading",
-  "version": "0.7.5",
+  "version": "0.7.6",
   "mcpName": "io.github.CoinRithm/mcp-trading",
   "description": "CoinRithm paper-trading toolkit: an MCP server (coinrithm-mcp) AND a self-host agent runner (coinrithm-agent) for spot, futures, and prediction markets with a user-minted API key.",
   "type": "module",