@coinrithm/mcp-trading 0.7.15 → 0.7.16

package/dist/agent/decisionValidator.js

@@ -4,6 +4,46 @@
 // market text cannot widen a limit or force a trade. Covers futures + spot + PM.
 import { ok, fail, actionVenue, spotBuyCost, } from "./types.js";
 import { checkEntryPredicates } from "./entryPredicates.js";
+import { universeEntryBlock } from "./universe.js";
+/**
+ * Edge (points) risk.pmMinEdgeGapPct requires at a fee-inclusive entry cost:
+ * pct% of the room left to 100. Cost at or above 100 leaves no room, so any
+ * positive gap rule makes the requirement unreachable rather than zero.
+ */
+export function requiredGapEdgePoints(entryPct, gapPct) {
+    const room = 100 - entryPct;
+    if (room <= 0)
+        return gapPct > 0 ? Number.POSITIVE_INFINITY : 0;
+    return (gapPct / 100) * room;
+}
+/** Ends within this of each other share a coin horizon (venue date splits). */
+export const PM_COIN_HORIZON_WINDOW_MS = 24 * 60 * 60 * 1000;
+/** An end beyond this is a venue sentinel, never a real horizon. */
+export const PM_PLAUSIBLE_END_MAX_MS = 5 * 365 * 24 * 60 * 60 * 1000;
+/** The later of observation.asOf and the validation clock, when known. */
+export function pmReferenceMs(asOf, nowMs) {
+    return Math.max(...[Date.parse(asOf), nowMs ?? NaN].filter((t) => Number.isFinite(t)));
+}
+/**
+ * The coin horizon of a market or held position, or null when it cannot be
+ * grouped: no linked coin, or an end that is missing, unparseable, not after
+ * the reference time, or more than 5 years after it (venue sentinels).
+ */
+export function pmCoinHorizonOf(item, refMs) {
+    const coins = item.coins ?? [];
+    if (coins.length === 0 || !item.endDate || !Number.isFinite(refMs))
+        return null;
+    const endMs = Date.parse(item.endDate);
+    if (!Number.isFinite(endMs) ||
+        endMs <= refMs ||
+        endMs - refMs > PM_PLAUSIBLE_END_MAX_MS)
+        return null;
+    return { coins, endMs };
+}
+/** Event key shared by pm_open actions, held positions and markets. */
+export function pmEventKey(source, slug) {
+    return `${source.toLowerCase()}/${slug.toLowerCase()}`;
+}
 const SERVER_MAX_LEVERAGE = 20;
 // Minimum edge, in probability POINTS, between the model's own forecast for
 // the outcome it is backing and what that outcome currently costs. Live
@@ -151,6 +191,9 @@ export function validateAction(action, ctx) {
             return fail("unknown_symbol", `${action.symbol} is not on the watchlist`);
         if (!entry.coinId)
             return fail("unresolved_symbol", `${action.symbol} did not resolve to a coin`);
+        const outsideUniverse = universeEntryBlock(spec, entry);
+        if (outsideUniverse)
+            return fail("outside_universe", `${action.symbol} is ${outsideUniverse}`);
         // A futures_open on a symbol you ALREADY hold is treated as an ADD by the
         // server, which REJECTS any SL/TP on an add (sl_tp_not_supported_on_add) and
         // fails the whole open — the single biggest rejection class (e.g. Sam 61/61).
@@ -267,6 +310,11 @@ export function validateAction(action, ctx) {
             return fail("unknown_symbol", `${action.symbol} is not on the watchlist`);
         if (!entry.coinId)
             return fail("unresolved_symbol", `${action.symbol} did not resolve to a coin`);
+        if (action.side === "buy") {
+            const outside = universeEntryBlock(spec, entry);
+            if (outside)
+                return fail("outside_universe", `${action.symbol} is ${outside}`);
+        }
         if (action.orderType === "limit" &&
             !(typeof action.limitPrice === "number" && action.limitPrice > 0)) {
             return fail("missing_limit_price", "a limit order needs a positive limitPrice");
@@ -333,6 +381,68 @@ export function validateAction(action, ctx) {
         if (!mkt) {
             return fail("pm_market_not_discovered", `${action.source}/${action.slug} is not in the discovered PM markets`);
         }
+        const perEventCap = spec.risk.pmMaxOpenPerEvent;
+        if (perEventCap !== undefined) {
+            if (typeof perEventCap !== "number" ||
+                !Number.isInteger(perEventCap) ||
+                perEventCap < 1) {
+                return fail("pm_event_cap_invalid", `risk.pmMaxOpenPerEvent ${JSON.stringify(perEventCap)} is not a whole number of at least 1`);
+            }
+            const key = pmEventKey(mkt.source, mkt.slug);
+            const held = observation.pmPositions.filter((p) => (p.status ?? "open") === "open" &&
+                p.source !== undefined &&
+                p.slug !== undefined &&
+                pmEventKey(p.source, p.slug) === key).length;
+            const thisCycle = (ctx.pmEventsOpenedThisCycle ?? []).filter((k) => k === key).length;
+            if (held + thisCycle >= perEventCap) {
+                return fail("pm_event_cap", `${held + thisCycle} open bet(s) on ${key} >= per-event cap ${perEventCap}`);
+            }
+        }
+        const coinHorizonCap = spec.risk.pmMaxOpenPerCoinHorizon;
+        if (coinHorizonCap !== undefined) {
+            if (typeof coinHorizonCap !== "number" ||
+                !Number.isInteger(coinHorizonCap) ||
+                coinHorizonCap < 1 ||
+                coinHorizonCap > 50) {
+                return fail("pm_coin_horizon_cap_invalid", `risk.pmMaxOpenPerCoinHorizon ${JSON.stringify(coinHorizonCap)} is not a whole number from 1 to 50`);
+            }
+            const refMs = pmReferenceMs(observation.asOf, ctx.nowMs);
+            const candidate = pmCoinHorizonOf(mkt, refMs);
+            // Unknown coin or end: never grouped, never blocked.
+            if (candidate) {
+                const near = (endMs) => Math.abs(endMs - candidate.endMs) <= PM_COIN_HORIZON_WINDOW_MS;
+                for (const coin of candidate.coins) {
+                    const held = observation.pmPositions.filter((p) => {
+                        if ((p.status ?? "open") !== "open")
+                            return false;
+                        const h = pmCoinHorizonOf(p, refMs);
+                        return !!h && h.coins.includes(coin) && near(h.endMs);
+                    }).length;
+                    const thisCycle = (ctx.pmCoinHorizonsOpenedThisCycle ?? []).filter((h) => h.coins.includes(coin) && near(h.endMs)).length;
+                    if (held + thisCycle >= coinHorizonCap) {
+                        return fail("pm_coin_horizon_cap", `${held + thisCycle} open bet(s) on ${coin} ending within 24 h of ${new Date(candidate.endMs).toISOString()} >= per-coin-horizon cap ${coinHorizonCap}`);
+                    }
+                }
+            }
+        }
+        const closeCutoff = spec.risk.pmMinMinutesToClose;
+        if (closeCutoff !== undefined) {
+            if (typeof closeCutoff !== "number" ||
+                !Number.isFinite(closeCutoff) ||
+                closeCutoff < 0) {
+                return fail("pm_close_cutoff_invalid", `risk.pmMinMinutesToClose ${JSON.stringify(closeCutoff)} is not a non-negative number`);
+            }
+            // Only a KNOWN close can trip the cutoff: venues publish null/sentinel
+            // end dates, and an unparseable one is unknown, never "closing now".
+            const endMs = mkt.endDate ? Date.parse(mkt.endDate) : NaN;
+            const refMs = Math.max(...[Date.parse(observation.asOf), ctx.nowMs ?? NaN].filter((t) => Number.isFinite(t)));
+            if (Number.isFinite(endMs) && Number.isFinite(refMs)) {
+                const minutesLeft = (endMs - refMs) / 60_000;
+                if (minutesLeft < closeCutoff) {
+                    return fail("pm_closes_too_soon", `market closes in ${minutesLeft.toFixed(1)} min, inside the ${closeCutoff} min cutoff`);
+                }
+            }
+        }
         if (action.stakeMusd < PM_MIN_STAKE_MUSD) {
             return fail("pm_stake_below_min", `stake ${action.stakeMusd} < $${PM_MIN_STAKE_MUSD} minimum`);
         }
@@ -393,11 +503,37 @@ export function validateAction(action, ctx) {
         // Forecast consistency. By prompt contract forecastProbability is the
         // model's own probability (1-99) that the outcome IT IS BACKING wins, so
         // buying that outcome only makes sense when the forecast clears what the
-        // market charges for it. An ABSENT forecast still never blocks a bet (the
-        // prompt promises that); a PRESENT one that contradicts the trade does.
+        // market charges for it. A forecast is optional unless a configured edge
+        // rule requires one; a present forecast must satisfy the enforced rules.
         // The API's entryProbability is the RAW mid, and executionModel's effective
         // probability excludes fee. Total stake / net shares is the fee-inclusive
         // break-even cost. Do not guess units or fall back to a discovery mid.
+        const maxEdge = spec.risk.pmMaxEdgePoints;
+        if (!ctx.mechanical && maxEdge !== undefined) {
+            if (typeof maxEdge !== "number" ||
+                !Number.isFinite(maxEdge) ||
+                maxEdge < 0 ||
+                maxEdge > 100) {
+                return fail("pm_max_edge_invalid", `risk.pmMaxEdgePoints ${JSON.stringify(maxEdge)} is not a number between 0 and 100`);
+            }
+            // An overconfidence cap cannot be checked against a missing number.
+            if (action.forecastProbability == null) {
+                return fail("pm_forecast_required", `risk.pmMaxEdgePoints ${maxEdge} needs forecastProbability on every pm_open`);
+            }
+        }
+        const edgeGapPct = spec.risk.pmMinEdgeGapPct;
+        if (!ctx.mechanical && edgeGapPct !== undefined) {
+            if (typeof edgeGapPct !== "number" ||
+                !Number.isFinite(edgeGapPct) ||
+                edgeGapPct < 0 ||
+                edgeGapPct > 100) {
+                return fail("pm_edge_gap_invalid", `risk.pmMinEdgeGapPct ${JSON.stringify(edgeGapPct)} is not a number between 0 and 100`);
+            }
+            // An edge rule cannot be checked against a missing number.
+            if (action.forecastProbability == null) {
+                return fail("pm_forecast_required", `risk.pmMinEdgeGapPct ${edgeGapPct} needs forecastProbability on every pm_open`);
+            }
+        }
         if (!ctx.mechanical && action.forecastProbability != null) {
             const stake = ctx.quote.stakeMusd;
             const shares = ctx.quote.sharesEstimate;
@@ -418,6 +554,15 @@ export function validateAction(action, ctx) {
             if (edge + 1e-9 < PM_MIN_FORECAST_EDGE_POINTS) {
                 return fail("forecast_no_positive_edge", `forecast ${action.forecastProbability} vs entry ${entryPct.toFixed(1)} = ${edge.toFixed(1)}pt edge, under the ${PM_MIN_FORECAST_EDGE_POINTS}pt minimum`);
             }
+            if (maxEdge !== undefined && edge > maxEdge + 1e-9) {
+                return fail("pm_edge_overconfident", `forecast ${action.forecastProbability} vs entry ${entryPct.toFixed(1)} = ${edge.toFixed(1)}pt edge, over the ${maxEdge}pt cap`);
+            }
+            if (edgeGapPct !== undefined) {
+                const required = requiredGapEdgePoints(entryPct, edgeGapPct);
+                if (edge + 1e-9 < required) {
+                    return fail("pm_edge_below_gap_rule", `forecast ${action.forecastProbability} vs entry ${entryPct.toFixed(1)} = ${edge.toFixed(1)}pt edge, under the ${required.toFixed(1)}pt required by ${edgeGapPct}% of the gap to 100`);
+                }
+            }
         }
         if (thesisContradictsOutcome(action.thesis?.summary, mkt.outcomeName)) {
             return fail("thesis_action_conflict", `thesis bets against ${mkt.outcomeName}, which this action buys`);

package/dist/agent/engine.d.ts

@@ -1,9 +1,9 @@
 export { runCycle, type RunnerDeps } from "./runner.js";
 export { buildAgentDefinitionSnapshot, type AgentDefinitionSnapshot, } from "./definitionSnapshot.js";
 export { DECISION_INPUT_MAX_BYTES, sanitizeDecisionInputRecord, type DecisionInputRecord, } from "./decisionReceipt.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 { selectProvider, providerForRoute, classifyProviderFailure, anthropicUsage, type ProviderUsage, type ProviderEnv, type ProviderRouteOptions, type Provider, type DecideInput, type DecideResult, type DecideRouteAttempt, type DecideRouteMeta, } from "./providers.js";
+export { parseDecision, ACTIONS_STRING_DIAGNOSTICS, type ActionsStringDiagnostic, } from "./decision.js";
+export { chatShapeFor, buildChatBody, canRetrySuperToolOutput, type ChatShape, } from "./providerCapabilities.js";
 export { probeDecisionContract, type ProbeRoute, type ProbeDecisionResult, } from "./decisionProbe.js";
 export { CoinRithmClient } from "./client.js";
 export { loadAgent, buildSpec, type LoadedAgent } from "./skill.js";

package/dist/agent/engine.js

@@ -8,12 +8,12 @@
 export { runCycle } from "./runner.js";
 export { buildAgentDefinitionSnapshot, } from "./definitionSnapshot.js";
 export { DECISION_INPUT_MAX_BYTES, sanitizeDecisionInputRecord, } from "./decisionReceipt.js";
-export { selectProvider, providerForRoute, classifyProviderFailure, } from "./providers.js";
-export { parseDecision } from "./decision.js";
+export { selectProvider, providerForRoute, classifyProviderFailure, anthropicUsage, } from "./providers.js";
+export { parseDecision, ACTIONS_STRING_DIAGNOSTICS, } from "./decision.js";
 // Reliability slice A: the declarative request-capability table and the
 // representative decision probe (route eligibility = a REAL parsed decision,
 // never a bare HTTP 200 — the 62f3a12 lesson).
-export { chatShapeFor, buildChatBody, } from "./providerCapabilities.js";
+export { chatShapeFor, buildChatBody, canRetrySuperToolOutput, } from "./providerCapabilities.js";
 export { probeDecisionContract, } from "./decisionProbe.js";
 export { CoinRithmClient } from "./client.js";
 export { loadAgent, buildSpec } from "./skill.js";

package/dist/agent/observe.d.ts

@@ -1,5 +1,5 @@
 import { CoinRithmClient } from "./client.js";
-import { AgentSpec, RunState, Observation, AgentTrace, PmCalibration, WhaleContext } from "./types.js";
+import { AgentSpec, RunState, Observation, OpenInterestContext, PositioningContext, LiquidationContext, MacroContext, ChainTvlContext, StablecoinSupplyContext, DepthContext, FundingByVenueContext, AgentTrace, PmCalibration, WhaleContext } from "./types.js";
 export interface ObserveOutput {
     observation: Observation;
     skip?: string;
@@ -16,4 +16,29 @@ export declare function isCalibrationChurnMarket(market: {
     slug?: string;
     title?: string;
 }): boolean;
-export declare function observe(client: CoinRithmClient, spec: AgentSpec, state: RunState, trace?: AgentTrace): Promise<ObserveOutput>;
+export declare function openInterestOf(m: Record<string, unknown>, nowMs?: number): OpenInterestContext | undefined;
+export declare function positioningOf(m: Record<string, unknown>, nowMs?: number): PositioningContext | undefined;
+export declare function liquidationsOf(m: Record<string, unknown>, nowMs?: number): LiquidationContext | undefined;
+/**
+ * `{ coins }` from an additive `relatedCoins` array (direct coin slugs), or
+ * nothing: non-arrays and non-string/blank entries are dropped, duplicates
+ * merged. Every valid slug is kept: the API never truncates the list, and
+ * dropping a linked coin could let a bet bypass that coin's cap. An empty
+ * result adds no field.
+ */
+export declare function coinsField(value: unknown): {
+    coins?: string[];
+};
+export declare function fundingByVenueOf(m: Record<string, unknown>, nowMs?: number): FundingByVenueContext | undefined;
+export declare function depthOf(m: Record<string, unknown>, nowMs?: number): DepthContext | undefined;
+export declare function chainTvlOf(m: Record<string, unknown>, nowMs?: number): ChainTvlContext | undefined;
+export declare function stablecoinSupplyOf(m: Record<string, unknown>, nowMs?: number): StablecoinSupplyContext | undefined;
+export declare function macroOf(m: Record<string, unknown>, nowMs?: number): MacroContext | undefined;
+/** Bench-only observation overrides; live callers pass none. */
+export interface ObserveOptions {
+    /** Read the curated PM board (depth 30, churn removed, calibration read)
+     *  even for a mechanical spec, so a bench baseline sees the recorded
+     *  agent opportunity set. Default: non-mechanical only. */
+    curatedPmBoard?: boolean;
+}
+export declare function observe(client: CoinRithmClient, spec: AgentSpec, state: RunState, trace?: AgentTrace, options?: ObserveOptions): Promise<ObserveOutput>;