@coinrithm/mcp-trading 0.7.2 → 0.7.4

package/dist/agent/state.js

@@ -42,7 +42,9 @@ export function loadState(file, runId) {
             ...base,
             ...parsed,
             seen: Array.isArray(parsed.seen) ? parsed.seen : [],
-            intentSeq: parsed.intentSeq && typeof parsed.intentSeq === "object" && !Array.isArray(parsed.intentSeq)
+            intentSeq: parsed.intentSeq &&
+                typeof parsed.intentSeq === "object" &&
+                !Array.isArray(parsed.intentSeq)
                 ? parsed.intentSeq
                 : {},
         });
@@ -91,13 +93,16 @@ export function checkKillSwitch(spec, state) {
             return `consecutive model failures ${state.consecutiveModelFailures} >= ${threshold}`;
         }
     }
-    if (ks.maxConsecutiveRejects > 0 && state.consecutiveRejectCycles >= ks.maxConsecutiveRejects) {
+    if (ks.maxConsecutiveRejects > 0 &&
+        state.consecutiveRejectCycles >= ks.maxConsecutiveRejects) {
         return `consecutive reject cycles ${state.consecutiveRejectCycles} >= ${ks.maxConsecutiveRejects}`;
     }
-    if (ks.maxDrawdownMusd > 0 && state.peakRealizedMusd - state.realizedPnlMusd >= ks.maxDrawdownMusd) {
+    if (ks.maxDrawdownMusd > 0 &&
+        state.peakRealizedMusd - state.realizedPnlMusd >= ks.maxDrawdownMusd) {
         return `drawdown ${(state.peakRealizedMusd - state.realizedPnlMusd).toFixed(2)} >= ${ks.maxDrawdownMusd}`;
     }
-    if (ks.onRateLimitPressure && state.rateLimitHits >= RATE_LIMIT_PRESSURE_THRESHOLD) {
+    if (ks.onRateLimitPressure &&
+        state.rateLimitHits >= RATE_LIMIT_PRESSURE_THRESHOLD) {
         return `rate-limit pressure: ${state.rateLimitHits} 429s this session`;
     }
     return null;

package/dist/agent/types.d.ts

@@ -4,7 +4,7 @@ export type Venue = "spot" | "futures" | "pm";
 export declare const VENUES: readonly Venue[];
 export declare const ACTION_TYPES: readonly ["futures_open", "futures_close", "futures_set_sltp", "spot_order", "spot_cancel", "pm_open"];
 export type ActionType = (typeof ACTION_TYPES)[number];
-export type ProviderName = "anthropic" | "openai" | "groq" | "nvidia" | "gemini" | "openai-compatible";
+export type ProviderName = "anthropic" | "openai" | "groq" | "nvidia" | "gemini" | "openai-compatible" | "mechanical";
 export declare const PROVIDERS: readonly ProviderName[];
 export interface ModelConfig {
     provider: ProviderName;
@@ -159,6 +159,7 @@ export interface PmMarket {
     probability?: number;
     title?: string;
     freshness?: Freshness;
+    volumeUsd?: number;
 }
 export interface SetupSignal {
     symbol: string;
@@ -240,10 +241,11 @@ export type ProposedAction = {
     stakeMusd: number;
     confidence?: number;
     rationaleSummary?: string;
+    forecastProbability?: number;
 };
 export type ActionVenue = Venue;
 export declare function actionVenue(a: ProposedAction): ActionVenue;
-export declare function isWriteAction(a: ProposedAction): boolean;
+export declare function isWriteAction(_a: ProposedAction): boolean;
 export declare function isOpenAction(a: ProposedAction): a is Extract<ProposedAction, {
     type: "futures_open" | "spot_order" | "pm_open";
 }>;
@@ -265,6 +267,8 @@ export interface QuoteEvidence {
     executionPrice?: number;
     estimatedCostMusd?: number;
     freshness?: Freshness;
+    openBlocked?: boolean;
+    openBlockReasons?: unknown;
 }
 export interface RunState {
     runId: string;
@@ -334,6 +338,17 @@ export interface CycleResult {
     decisionType?: "act" | "skip" | "gate_skip" | "model_error";
     writeAttempted?: number;
     writeAccepted?: number;
+    opportunity?: PostedOpportunity;
+}
+export interface PostedOpportunity {
+    kind: "abstained" | "forecast_only" | "quote_expired";
+    source?: string;
+    slug?: string;
+    outcomeExternalMarketId?: string;
+    universeSize?: number;
+    forecastProbability?: number;
+    marketProbability?: number;
+    reasonCode?: string;
 }
 export interface ResolveIssue {
     code: string;

package/dist/agent/types.js

@@ -27,6 +27,7 @@ export const PROVIDERS = [
     "nvidia",
     "gemini",
     "openai-compatible",
+    "mechanical",
 ];
 export const DEFAULT_TRIGGER_POLICY = {
     mode: "event_driven",
@@ -67,7 +68,7 @@ export function actionVenue(a) {
         return "spot";
     return "pm";
 }
-export function isWriteAction(a) {
+export function isWriteAction(_a) {
     // Every proposed action mutates state (set-sltp/cancel included). The model
     // never proposes a read; reads are the runner's job during observe.
     return true;

package/dist/agent/util.js

@@ -1,6 +1,6 @@
 // Small dependency-free helpers shared across the runner.
 import { createHash } from "node:crypto";
-import { resolve as resolvePath, relative as relativePath, isAbsolute } from "node:path";
+import { resolve as resolvePath, relative as relativePath, isAbsolute, } from "node:path";
 export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 // Parse a cadence string ("30s", "15m", "1h", "4h", "1d") to milliseconds.
 // Returns null for anything unparseable so the skill validator can reject it.
@@ -14,7 +14,13 @@ export function parseCadenceMs(cadence) {
     if (!Number.isFinite(n) || n <= 0)
         return null;
     const unit = m[2].toLowerCase();
-    const mult = unit === "s" ? 1000 : unit === "m" ? 60_000 : unit === "h" ? 3_600_000 : 86_400_000;
+    const mult = unit === "s"
+        ? 1000
+        : unit === "m"
+            ? 60_000
+            : unit === "h"
+                ? 3_600_000
+                : 86_400_000;
     return n * mult;
 }
 // A UTC day key (YYYY-MM-DD) for resetting per-day counters.
@@ -65,14 +71,15 @@ export function shortId() {
 // so a Windows checkout and a Linux checkout of the same file hash identically.
 export function normalizeContent(text) {
     return text
-        .replace(/^/, "") // strip UTF-8 BOM (Windows editors add it)
+        .replace(/^\uFEFF/, "") // strip UTF-8 BOM (Windows editors add it)
         .replace(/\r\n/g, "\n")
         .replace(/\r/g, "\n")
         .replace(/\s+$/, "");
 }
 // SHA-256 of normalized content — the manifest lock's per-file contentHash.
 export function sha256(text) {
-    return ("sha256:" + createHash("sha256").update(normalizeContent(text), "utf8").digest("hex"));
+    return ("sha256:" +
+        createHash("sha256").update(normalizeContent(text), "utf8").digest("hex"));
 }
 // Canonical POSIX path (forward slashes) so the lock is byte-identical on
 // Windows and Linux.

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.5.0";
+    readonly openapiVersion: "1.6.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.5.0",
+    openapiVersion: "1.6.0",
     mcpPackage: "@coinrithm/mcp-trading",
     mcpVersion: PACKAGE_VERSION,
 };

package/dist/client.d.ts

@@ -24,6 +24,21 @@ export interface ApiResult {
 type TraceableBody<T extends Record<string, unknown>> = T & {
     agentTrace?: AgentTrace;
 };
+export type ProvenanceReport = {
+    runtimeKind?: "hosted_scheduler" | "self_host_runner" | "byo_api" | "mcp_tool";
+    packageVersion?: string;
+    bundleId?: string;
+    bundleVersion?: string;
+    skillVersions?: Record<string, string>;
+    promptHash?: string;
+    configHash?: string;
+    modelProvider?: string;
+    modelName?: string;
+    evidenceRef?: {
+        snapshotIds?: string[];
+        sourceCapturedAt?: string;
+    };
+};
 export declare class CoinRithmClient {
     private readonly defaultApiKey?;
     private readonly baseUrl;
@@ -46,6 +61,24 @@ export declare class CoinRithmClient {
         fiat?: string;
     }): Promise<ApiResult>;
     getPublicPmWhales(): Promise<ApiResult>;
+    getPublicPmMatches(query?: {
+        limit?: number;
+        offset?: number;
+        sort?: string;
+        minDivergence?: number;
+        sourceKind?: string;
+        status?: string;
+        maxSnapshotAgeMinutes?: number;
+        requirePriced?: boolean;
+        fiat?: string;
+    }): Promise<ApiResult>;
+    getPublicPmCalibration(): Promise<ApiResult>;
+    getPublicPmCanonicalList(query?: {
+        limit?: number;
+        cursor?: number;
+    }): Promise<ApiResult>;
+    getPublicPmCanonicalDetail(key: string): Promise<ApiResult>;
+    getPublicPmVolumeHistory(): Promise<ApiResult>;
     whoami(apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
     getPortfolio(query?: {
         fiat?: string;
@@ -176,6 +209,24 @@ export declare class CoinRithmClient {
         side?: "yes" | "no";
         stakeMusd: number;
         idempotencyKey: string;
+        forecastProbability?: number;
+        provenance?: ProvenanceReport;
+    }>, apiKey?: string): Promise<ApiResult>;
+    reportPmOpportunity(body: TraceableBody<{
+        kind: "abstained" | "forecast_only" | "quote_expired";
+        source?: string;
+        slug?: string;
+        outcomeExternalMarketId?: string;
+        forecastProbability?: number;
+        marketProbability?: number;
+        reasonCode?: string;
+        cohort?: {
+            universeSize?: number;
+            horizon?: string;
+        };
+        decisionId?: string;
+        runId?: string;
+        provenance?: ProvenanceReport;
     }>, apiKey?: string): Promise<ApiResult>;
 }
 export {};

package/dist/client.js

@@ -20,7 +20,6 @@
 export const DEFAULT_BASE_URL = "https://api.coinrithm.com";
 export function log(...args) {
     // stderr only — stdout is reserved for the MCP protocol.
-    // eslint-disable-next-line no-console
     console.error("[coinrithm-mcp]", ...args);
 }
 function resolveBaseUrl() {
@@ -69,7 +68,7 @@ const applyAgentTraceHeaders = (headers, trace) => {
     }
 };
 const traceFromBody = (body) => body && typeof body === "object" && "agentTrace" in body
-    ? (body.agentTrace)
+    ? body.agentTrace
     : undefined;
 export class CoinRithmClient {
     // Default key for the stdio (single-user) path. Undefined in the multi-user
@@ -213,6 +212,24 @@ export class CoinRithmClient {
     getPublicPmWhales() {
         return this.publicRequest("/api/prediction-markets/whales");
     }
+    // Cross-venue disagreement clusters (approved event matches, graph-clustered).
+    getPublicPmMatches(query) {
+        return this.publicRequest("/api/prediction-markets/matches/public", query);
+    }
+    // Per-venue forecast-accuracy calibration (ECE + reliability curve). No query params.
+    getPublicPmCalibration() {
+        return this.publicRequest("/api/prediction-markets/calibration");
+    }
+    getPublicPmCanonicalList(query) {
+        return this.publicRequest("/api/prediction-markets/canonical", query);
+    }
+    getPublicPmCanonicalDetail(key) {
+        return this.publicRequest(`/api/prediction-markets/canonical/${encodeURIComponent(key)}`);
+    }
+    // Global daily volume trend (real-money venues only). No query params.
+    getPublicPmVolumeHistory() {
+        return this.publicRequest("/api/prediction-markets/volume-history");
+    }
     // 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) ----
@@ -293,7 +310,9 @@ export class CoinRithmClient {
         return this.request("GET", "/api/arena", { query, apiKey });
     }
     getArenaAgent(handle, apiKey) {
-        return this.request("GET", `/api/arena/${encodeURIComponent(handle)}`, { apiKey });
+        return this.request("GET", `/api/arena/${encodeURIComponent(handle)}`, {
+            apiKey,
+        });
     }
     listOpenOrders(query, apiKey, agentTrace) {
         return this.request("GET", "/api/agent/orders/open", {
@@ -347,4 +366,12 @@ export class CoinRithmClient {
     openPmPosition(body, apiKey) {
         return this.request("POST", "/api/agent/pm/open", { body, apiKey });
     }
+    // Report a NON-opened opportunity (scope: read — it is EVIDENCE, not a trade, so
+    // it never moves a wallet or a position). Captures the model ABSTAINING while
+    // markets were listed, forecasting WITHOUT trading (forecast_only), or a validated
+    // open whose quote EXPIRED at act time (quote_expired), so the public evaluation
+    // is not selection-biased toward opened trades. Idempotent by (key, decisionId).
+    reportPmOpportunity(body, apiKey) {
+        return this.request("POST", "/api/agent/pm/opportunity", { body, apiKey });
+    }
 }

package/dist/executionPolicy.d.ts

@@ -0,0 +1,2 @@
+export declare const PAPER_EXECUTION_VERSION = "paper_execution_v1";
+export declare const EXECUTION_POLICY_SUMMARY: string;

package/dist/executionPolicy.js

@@ -0,0 +1,21 @@
+// Mirror of the backend paper-execution policy. This package is published
+// standalone and cannot import the backend, so the versioned policy name is
+// mirrored here as the SINGLE place any package text that mentions execution
+// cost refers to. That is what stops a served/tool description from drifting
+// back into a "costless" claim while the backend charges real modeled costs.
+//
+// It deliberately does NOT restate the fee/spread/slippage bps — those live in
+// the backend SSOT and are disclosed per fill in the response `executionModel`
+// and in the OpenAPI cost-model description. Text points THERE instead of
+// duplicating numbers that could silently diverge.
+//
+// Drift-tested in executionPolicy.test.ts: the summary names the versioned
+// policy and never matches the costless regex.
+export const PAPER_EXECUTION_VERSION = "paper_execution_v1";
+export const EXECUTION_POLICY_SUMMARY = "Paper execution is not costless: every fill runs under the versioned " +
+    `${PAPER_EXECUTION_VERSION} policy — a disclosed taker fee (plus, on spot ` +
+    "market orders and PM entries, an adverse spread and size-based slippage; " +
+    "futures charge the taker fee and do not model funding) folded into realized " +
+    "PnL, so reported PnL is net of modeled costs. The exact per-fill amounts are " +
+    "disclosed in each quote/trade `executionModel`; see the OpenAPI cost-model " +
+    "description for the bps. A rehearsal cost model, not an exchange-fill guarantee.";

package/dist/http.js

@@ -46,8 +46,14 @@ async function main() {
     const app = express();
     app.use(express.json());
     // Lightweight, unauthenticated liveness probe (handy for Coolify/uptime checks).
-    app.get("/healthz", (_req, res) => {
-        res.json({ ok: true, service: "coinrithm-mcp", transport: "streamable-http" });
+    // Keep `/healthz` as the deployment contract and expose `/health` as a
+    // compatibility alias for agents and generic uptime monitors.
+    app.get(["/health", "/healthz"], (_req, res) => {
+        res.json({
+            ok: true,
+            service: "coinrithm-mcp",
+            transport: "streamable-http",
+        });
     });
     // Self-describing landing for humans and validate-before-recommend agents.
     // GET / and GET /mcp used to 404, which reads as a dead service to anyone
@@ -58,7 +64,11 @@ async function main() {
             service: "CoinRithm MCP",
             version: SERVER_VERSION,
             description: "Model Context Protocol server for CoinRithm: keyless public prediction-market data tools (pm_data_*) plus paper-trading tools (spot, futures, prediction markets) with a crk_live_ API key. Paper only — never real money.",
-            endpoint: { url: "https://mcp.coinrithm.com/mcp", method: "POST", transport: "streamable-http" },
+            endpoint: {
+                url: "https://mcp.coinrithm.com/mcp",
+                method: "POST",
+                transport: "streamable-http",
+            },
             connect: "Point any MCP client at the endpoint above. Data tools need no key; trading tools take Authorization: Bearer crk_live_… (mint one at coinrithm.com → Settings → API Keys).",
             localAlternative: "npx -y @coinrithm/mcp-trading",
             docs: {

package/dist/tools.d.ts

@@ -1,3 +1,26 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { CoinRithmClient } from "./client.js";
+export declare const PAPER_NOTE: string;
+/**
+ * Keep keyless discovery calls small enough for an agent context window.
+ * Full event evidence remains available from pm_data_event.
+ */
+export declare function compactPublicPmOverview(data: unknown): unknown;
+export declare function compactPublicPmEvents(data: unknown): unknown;
+/**
+ * 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 declare function compactPublicPmEvent(data: unknown): unknown;
+export declare function compactPublicPmWhales(data: unknown, limit: number): unknown;
+/**
+ * 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 declare function compactPublicPmDisagreements(data: unknown): unknown;
 export declare function registerTools(server: McpServer, client: CoinRithmClient): void;