@coinrithm/mcp-trading 0.4.0 → 0.7.0

package/dist/agent/templates.js

@@ -62,8 +62,10 @@ money. Edit this prose freely (any language) — it is your agent's borders.
    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 at most one strongest candidate. If nothing is clean, skip — a skipped
-   cycle is cheaper than a forced trade.
+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
@@ -75,8 +77,10 @@ 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
 
-Patient and selective. Prefers to skip rather than force a marginal trade.
-States its reasoning plainly and never frames paper results as real-money advice.
+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

@@ -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" | "openai-compatible";
+export type ProviderName = "anthropic" | "openai" | "groq" | "nvidia" | "gemini" | "openai-compatible";
 export declare const PROVIDERS: readonly ProviderName[];
 export interface ModelConfig {
     provider: ProviderName;
@@ -15,6 +15,15 @@ export interface TriggerConfig {
     cadence: string;
     timezone?: string;
 }
+export interface TriggerPolicy {
+    mode: "event_driven" | "always";
+    skipLlmWhenNoTrigger: boolean;
+    alwaysManageOpenPositions: boolean;
+    maxLlmCallsPerHour: number;
+    debounceMinutes: number;
+    pmEvalCooldownMinutes: number;
+}
+export declare const DEFAULT_TRIGGER_POLICY: TriggerPolicy;
 export interface RiskConfig {
     maxLeverage: number;
     perTradeMarginMusd: number;
@@ -52,7 +61,7 @@ export interface ObjectiveConfig {
     secondary: string[];
     horizon?: string;
 }
-export declare const ALLOWED_CAPABILITIES: readonly ["websearch", "indicators"];
+export declare const ALLOWED_CAPABILITIES: readonly ["websearch", "indicators", "news"];
 export type Capability = (typeof ALLOWED_CAPABILITIES)[number];
 export interface AgentSpec {
     name: string;
@@ -68,6 +77,7 @@ export interface AgentSpec {
     killSwitch: KillSwitchConfig;
     objective?: ObjectiveConfig;
     capabilities: Capability[];
+    triggerPolicy?: TriggerPolicy;
 }
 export interface ParsedSkill {
     spec: AgentSpec;
@@ -93,6 +103,7 @@ export interface WatchEntry {
     change1h?: number;
     change24h?: number;
     change7d?: number;
+    sentimentBullishPct?: number;
     freshness?: Freshness;
     indicators?: IndicatorSet;
 }
@@ -103,8 +114,14 @@ export interface OpenPosition {
     symbol?: string;
     side?: string;
     status?: string;
+    leverage?: number;
     marginMusd?: number;
     unrealizedPnlMusd?: number;
+    entryPrice?: number;
+    markPrice?: number;
+    liquidationPrice?: number;
+    stopLossPrice?: number;
+    takeProfitPrice?: number;
 }
 export interface SpotOrder {
     id: number;
@@ -121,15 +138,44 @@ export interface PmPosition {
     slug?: string;
     outcomeExternalMarketId?: string;
     stakeMusd?: number;
+    unrealizedPnlMusd?: number;
+    status?: string;
+}
+export interface PmResolution {
+    id: number;
+    eventTitle?: string;
+    slug?: string;
+    side?: string;
     status?: string;
+    pnlMusd?: number;
+    stakeMusd?: number;
 }
 export interface PmMarket {
+    ref?: string;
     source: string;
     slug: string;
     outcomeExternalMarketId: string;
+    outcomeName?: string;
+    probability?: number;
     title?: string;
     freshness?: Freshness;
 }
+export interface SetupSignal {
+    symbol: string;
+    kind: "breakout" | "breakdown" | "uptrend" | "downtrend" | "stretched";
+    bias: "long" | "short" | "fade-long" | "fade-short";
+    strength: number;
+    note: string;
+    held?: "long" | "short";
+}
+export interface NewsItem {
+    title: string;
+    source?: string;
+    sentiment?: string;
+    importance?: number;
+    ageHours?: number;
+    coins?: string[];
+}
 export interface Observation {
     asOf: string;
     scopes: string[];
@@ -138,11 +184,18 @@ export interface Observation {
     openPositions: OpenPosition[];
     openOrders: SpotOrder[];
     pmPositions: PmPosition[];
+    pmResolutions: PmResolution[];
     pmMarkets: PmMarket[];
     watch: WatchEntry[];
+    setups: SetupSignal[];
+    marketMood?: {
+        fearGreed: number;
+        label: string;
+    };
     syncCursor: string | null;
     newClosedTrades: Array<Record<string, unknown>>;
     polledBeforeWrite: boolean;
+    news?: NewsItem[];
 }
 export type ProposedAction = {
     type: "futures_open";
@@ -180,6 +233,7 @@ export type ProposedAction = {
     orderId: number;
 } | {
     type: "pm_open";
+    ref?: string;
     source: string;
     slug: string;
     outcomeExternalMarketId: string;
@@ -199,6 +253,7 @@ export declare function spotBuyCost(action: Extract<ProposedAction, {
 export interface Decision {
     decision: "skip" | "act";
     reason?: string;
+    rationale?: string;
     confidence?: number;
     actions: ProposedAction[];
 }
@@ -228,6 +283,13 @@ export interface RunState {
     realizedPnlTodayMusd: number;
     consecutiveExecFailures: number;
     intentSeq: Record<string, number>;
+    llmCallTimestamps?: number[];
+    lastLlmCallAt?: number;
+    lastTriggerFingerprint?: string;
+    journal?: Array<{
+        at: string;
+        did: string;
+    }>;
 }
 export interface AgentTrace {
     runId?: string;
@@ -256,11 +318,22 @@ export interface PlannedAction {
 export interface CycleResult {
     decision: "skip" | "act";
     skipReason?: string;
+    rationale?: string;
+    confidence?: number;
+    rawModelOutput?: string;
     planned: PlannedAction[];
     modelFailed?: boolean;
     disabled?: boolean;
     disabledReason?: string;
     live: boolean;
+    triggerCodes?: string[];
+    llmCallMade?: boolean;
+    tokensIn?: number;
+    tokensOut?: number;
+    estimatedCostUsd?: number;
+    decisionType?: "act" | "skip" | "gate_skip" | "model_error";
+    writeAttempted?: number;
+    writeAccepted?: number;
 }
 export interface ResolveIssue {
     code: string;

package/dist/agent/types.js

@@ -25,8 +25,17 @@ export const PROVIDERS = [
     "openai",
     "groq",
     "nvidia",
+    "gemini",
     "openai-compatible",
 ];
+export const DEFAULT_TRIGGER_POLICY = {
+    mode: "event_driven",
+    skipLlmWhenNoTrigger: true,
+    alwaysManageOpenPositions: true,
+    maxLlmCallsPerHour: 0,
+    debounceMinutes: 0,
+    pmEvalCooldownMinutes: 10,
+};
 // What the agent declares it is optimizing for — so two similar-looking agents
 // are distinguishable and the scorecard/Arena can read intent.
 export const OBJECTIVE_PRIMARIES = [
@@ -40,7 +49,11 @@ 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.
-export const ALLOWED_CAPABILITIES = ["websearch", "indicators"];
+export const ALLOWED_CAPABILITIES = [
+    "websearch",
+    "indicators",
+    "news",
+];
 export const ok = () => ({ valid: true });
 export const fail = (code, reason) => ({
     valid: false,

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.4.0";
+    readonly openapiVersion: "1.5.0";
     readonly mcpPackage: "@coinrithm/mcp-trading";
-    readonly mcpVersion: "0.3.0";
+    readonly mcpVersion: string;
 };

package/dist/agent/version.js

@@ -1,8 +1,16 @@
 // Versions stamped into manifest.lock.json so a resolved agent is reproducible
 // only against the exact compile that produced it.
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
 export const RUNNER_VERSION = "0.1.0";
 export const RESOLVER_VERSION = "1";
 export const MANIFEST_SCHEMA = "coinrithm.manifest.v1";
+// The published package version, read from package.json at runtime (same
+// createRequire pattern as src/version.ts) so the API pin's mcpVersion can never
+// drift from the real published version again. package.json lives outside
+// rootDir=src; at runtime dist/agent/version.js resolves ../../package.json to
+// the package root in both the repo and the published tarball.
+const PACKAGE_VERSION = require("../../package.json").version;
 // The CoinRithm execution surface a generated agent talks to. Written into
 // functionality/coinrithm.yaml as a version PIN; the CLI warns when an agent's
 // pin lags this, but never blocks self-host use.
@@ -10,7 +18,9 @@ export const COINRITHM_API = {
     kind: "coinrithm-agent-api",
     baseUrl: "https://api.coinrithm.com",
     mcpUrl: "https://mcp.coinrithm.com/mcp",
-    openapiVersion: "1.4.0",
+    // 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",
     mcpPackage: "@coinrithm/mcp-trading",
-    mcpVersion: "0.3.0",
+    mcpVersion: PACKAGE_VERSION,
 };

package/dist/client.d.ts

@@ -29,6 +29,23 @@ export declare class CoinRithmClient {
     private readonly baseUrl;
     constructor(config: ClientConfig);
     private request;
+    private publicRequest;
+    getPublicPmOverview(query?: {
+        fiat?: string;
+    }): Promise<ApiResult>;
+    listPublicPmEvents(query?: {
+        q?: string;
+        source?: string;
+        status?: string;
+        sort?: string;
+        limit?: number;
+        offset?: number;
+        fiat?: string;
+    }): Promise<ApiResult>;
+    getPublicPmEvent(source: string, slug: string, query?: {
+        fiat?: string;
+    }): Promise<ApiResult>;
+    getPublicPmWhales(): Promise<ApiResult>;
     whoami(apiKey?: string, agentTrace?: AgentTrace): Promise<ApiResult>;
     getPortfolio(query?: {
         fiat?: string;
@@ -111,6 +128,7 @@ export declare class CoinRithmClient {
         source: string;
         slug: string;
         outcomeExternalMarketId: string;
+        side?: "yes" | "no";
         stakeMusd: number;
     } & {
         agentTrace?: AgentTrace;
@@ -155,6 +173,7 @@ export declare class CoinRithmClient {
         source: string;
         slug: string;
         outcomeExternalMarketId: string;
+        side?: "yes" | "no";
         stakeMusd: number;
         idempotencyKey: string;
     }>, apiKey?: string): Promise<ApiResult>;

package/dist/client.js

@@ -157,6 +157,62 @@ export class CoinRithmClient {
             data,
         };
     }
+    // Public, keyless GET against the free cross-venue data API
+    // (/api/prediction-markets/*). No Authorization header is ever attached:
+    // these endpoints require no key, and the caller's trading key must not
+    // leak into them. No ledger headers exist on this surface either.
+    async publicRequest(path, query) {
+        const url = new URL(this.baseUrl + path);
+        if (query) {
+            for (const [k, v] of Object.entries(query)) {
+                if (v !== undefined && v !== null && v !== "") {
+                    url.searchParams.set(k, String(v));
+                }
+            }
+        }
+        let res;
+        try {
+            res = await fetch(url.toString(), {
+                method: "GET",
+                headers: { Accept: "application/json" },
+            });
+        }
+        catch (err) {
+            log(`network error calling GET ${path}:`, err);
+            return {
+                ok: false,
+                status: 0,
+                data: {
+                    error: "network_error",
+                    message: err instanceof Error ? err.message : String(err),
+                },
+            };
+        }
+        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 };
+    }
+    // ---- public PM data (no key required) ----
+    getPublicPmOverview(query) {
+        return this.publicRequest("/api/prediction-markets/overview", query);
+    }
+    listPublicPmEvents(query) {
+        return this.publicRequest("/api/prediction-markets/events", query);
+    }
+    getPublicPmEvent(source, slug, query) {
+        return this.publicRequest(`/api/prediction-markets/events/${encodeURIComponent(source)}/${encodeURIComponent(slug)}`, query);
+    }
+    getPublicPmWhales() {
+        return this.publicRequest("/api/prediction-markets/whales");
+    }
     // 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.js

@@ -6,7 +6,13 @@
 // isError results rather than thrown so the model can react.
 import { z } from "zod";
 import { bearerFromHeader } from "./client.js";
-const PAPER_NOTE = "Paper trading only — virtual funds (50,000 mUSD). Not financial advice.";
+const PAPER_NOTE = "Paper trading only — virtual funds (50,000 mUSD). Not financial advice. " +
+    "Paper fills apply a disclosed execution cost folded into realized PnL: " +
+    "spot/futures pay a taker fee (spot market orders also pay half-spread + " +
+    "slippage); PM fills at the ask with size-based slippage and a Polymarket-" +
+    "shaped taker fee, with entryProbability kept at the mid for calibration. " +
+    "See the executionModel in quote/trade results — a rehearsal cost, not an " +
+    "exchange fill guarantee.";
 const API_RESULT_OUTPUT_SCHEMA = {
     httpStatus: z
         .number()
@@ -569,7 +575,9 @@ export function registerTools(server, client) {
             "estimate, max payout, eligibility, freshness, and decisionSupport " +
             "(market quality/liquidity/volume/spread tiers + flags) so you can " +
             "quote and gauge tradability in one call. Never mutates state. " +
-            "stakeMusd must be > 0 (min to open is 10). " +
+            "stakeMusd must be > 0 (min to open is 10). Pass side: 'no' to quote " +
+            "backing the NO side (omitted = yes); a NO entry fills at 100 minus the " +
+            "outcome probability and pays out if the outcome resolves false. " +
             PAPER_NOTE,
         inputSchema: {
             source: z.string().describe("Source slug (e.g. kalshi, polymarket)."),
@@ -577,12 +585,18 @@ export function registerTools(server, client) {
             outcomeExternalMarketId: z
                 .string()
                 .describe("Case-sensitive outcome / market id."),
+            side: z
+                .enum(["yes", "no"])
+                .optional()
+                .describe("Which side of the binary outcome to back. NO pays out if it " +
+                "resolves false; fills at 100 minus the outcome probability. " +
+                "Omitted = yes."),
             stakeMusd: z.number().positive().describe("mUSD to stake (> 0)."),
             agentTrace: AGENT_TRACE_SCHEMA,
         },
         outputSchema: API_RESULT_OUTPUT_SCHEMA,
         annotations: readOnlyAnnotations("Prediction-market quote"),
-    }, async ({ source, slug, outcomeExternalMarketId, stakeMusd, agentTrace }, extra) => present(await client.pmQuote({ source, slug, outcomeExternalMarketId, stakeMusd, agentTrace }, requestKey(extra))));
+    }, async ({ source, slug, outcomeExternalMarketId, side, stakeMusd, agentTrace }, extra) => present(await client.pmQuote({ source, slug, outcomeExternalMarketId, side, stakeMusd, agentTrace }, requestKey(extra))));
     server.registerTool("spot_quote", {
         title: "Spot quote",
         description: "Read-only spot MARKET quote: live execution price, estimated cost " +
@@ -800,7 +814,9 @@ export function registerTools(server, client) {
         description: "Open a mock prediction-market position (binary outcomes only). Requires " +
             "the trade:pm scope. Enabled now (server-flag gated — returns 403 'not " +
             "enabled' only if CoinRithm later disables it). idempotencyKey is " +
-            "REQUIRED. stakeMusd >= 10. Quote first and CONFIRM with the user. " +
+            "REQUIRED. stakeMusd >= 10. Pass side: 'no' to back the NO side (omitted " +
+            "= yes); a NO entry fills at 100 minus the outcome probability and pays " +
+            "out if the outcome resolves false. Quote first and CONFIRM with the user. " +
             PAPER_NOTE,
         inputSchema: {
             source: z
@@ -810,6 +826,12 @@ export function registerTools(server, client) {
             outcomeExternalMarketId: z
                 .string()
                 .describe("Case-sensitive outcome or market id returned by discovery."),
+            side: z
+                .enum(["yes", "no"])
+                .optional()
+                .describe("Which side of the binary outcome to back. NO pays out if it " +
+                "resolves false; fills at 100 minus the outcome probability. " +
+                "Omitted = yes."),
             stakeMusd: z.number().min(10).describe("mUSD stake (>= 10)."),
             idempotencyKey: z
                 .string()
@@ -821,12 +843,124 @@ export function registerTools(server, client) {
         annotations: mutatingAnnotations("Open prediction-market position", {
             idempotent: true,
         }),
-    }, async ({ source, slug, outcomeExternalMarketId, stakeMusd, idempotencyKey, agentTrace, }, extra) => present(await client.openPmPosition({
+    }, async ({ source, slug, outcomeExternalMarketId, side, stakeMusd, idempotencyKey, agentTrace, }, extra) => present(await client.openPmPosition({
         source,
         slug,
         outcomeExternalMarketId,
+        side,
         stakeMusd,
         idempotencyKey,
         agentTrace,
     }, requestKey(extra))));
+    // ---- Public cross-venue PM data (no API key required) ----
+    // These wrap the free /api/prediction-markets/* endpoints — CoinRithm's
+    // citable cross-venue dataset. They never attach the caller's key.
+    server.registerTool("pm_data_overview", {
+        title: "Cross-venue prediction-market statistics",
+        description: "Free public cross-venue prediction-market statistics: total/open/" +
+            "closed market counts, total volume, 24h volume, and liquidity " +
+            "aggregated across Polymarket, Kalshi, Metaculus, PredictIt, " +
+            "Limitless, Manifold, and Smarkets, plus market highlights. Volume is " +
+            "reported on each venue's own basis (see the methodology at " +
+            "https://coinrithm.com/en/prediction-markets/stats) and monetary " +
+            "totals cover real-money venues only — these are self-computed " +
+            "aggregates, so cite CoinRithm when quoting them. No API key required.",
+        inputSchema: {
+            fiat: z
+                .string()
+                .optional()
+                .describe("Fiat currency code for monetary figures (default usd)."),
+        },
+        outputSchema: API_RESULT_OUTPUT_SCHEMA,
+        annotations: readOnlyAnnotations("Cross-venue prediction-market statistics"),
+    }, async ({ fiat }) => present(await client.getPublicPmOverview({ fiat })));
+    server.registerTool("pm_data_events", {
+        title: "Search prediction markets across all venues",
+        description: "Free public search over prediction-market events across ALL seven " +
+            "venues (Polymarket, Kalshi, Metaculus, PredictIt, Limitless, " +
+            "Manifold, Smarkets) — broader than discover_pm_markets, which is " +
+            "scoped to the paper-tradeable venues. Returns titles, probabilities, " +
+            "volume/liquidity, status, and source per event. Research/data only: " +
+            "to trade, use discover_pm_markets + pm_quote instead. No API key " +
+            "required.",
+        inputSchema: {
+            q: z.string().optional().describe("Optional search text."),
+            source: z
+                .string()
+                .optional()
+                .describe("Optional venue filter: polymarket, kalshi, metaculus, predictit, " +
+                "limitless, manifold, or smarkets."),
+            status: z
+                .string()
+                .optional()
+                .describe("Optional status filter (e.g. open or closed)."),
+            sort: z.string().optional().describe("Optional sort key."),
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(50)
+                .optional()
+                .describe("Max rows (1-50, default 20)."),
+            offset: z
+                .number()
+                .int()
+                .min(0)
+                .optional()
+                .describe("Pagination offset (default 0)."),
+            fiat: z
+                .string()
+                .optional()
+                .describe("Fiat currency code for monetary figures (default usd)."),
+        },
+        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({
+        q,
+        source,
+        status,
+        sort,
+        limit,
+        offset,
+        fiat,
+    })));
+    server.registerTool("pm_data_event", {
+        title: "Get full 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 " +
+            "venues — read probability divergence directly from it), " +
+            "referenceProbability when present (CoinRithm's canonical cross-venue " +
+            "number: the liquidity-weighted median Yes probability across matched " +
+            "real-money venues, with venueCount and spreadPoints — quote all " +
+            "three together, venues disagree and the spread says by how much), " +
+            "recent whale trades on the event, related events, and related news. " +
+            "This is the cross-venue research view; for tradability use pm_quote. " +
+            "No API key required.",
+        inputSchema: {
+            source: z
+                .string()
+                .describe("Venue slug: polymarket, kalshi, metaculus, predictit, limitless, " +
+                "manifold, or smarkets."),
+            slug: z.string().describe("Event slug on that venue."),
+            fiat: z
+                .string()
+                .optional()
+                .describe("Fiat currency code for monetary figures (default usd)."),
+        },
+        outputSchema: API_RESULT_OUTPUT_SCHEMA,
+        annotations: readOnlyAnnotations("Get full prediction-market event detail"),
+    }, async ({ source, slug, fiat }) => present(await client.getPublicPmEvent(source, slug, { fiat })));
+    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, " +
+            "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: {},
+        outputSchema: API_RESULT_OUTPUT_SCHEMA,
+        annotations: readOnlyAnnotations("Get latest prediction-market whale trades"),
+    }, async () => present(await client.getPublicPmWhales()));
 }