@coinrithm/mcp-trading 0.7.14 → 0.7.16

package/dist/agent/decision.js

@@ -3,6 +3,7 @@
 // JSON, an unknown action type, a free-form endpoint/tool name, extra unknown
 // fields, or a missing required field — fails closed (the runner skips).
 import { z } from "zod";
+import JSON5 from "json5";
 import { coerceThesis } from "./thesis.js";
 // Small models (especially Llama 3.1 8B) frequently emit numbers as JSON strings
 // ("12345", "0.8", "62000"). Coerce a *clean* numeric string to a number before
@@ -363,15 +364,95 @@ function coerceJson(text) {
     }
     return JSON.parse(s); // throws on invalid JSON -> caller treats as fail-closed
 }
+// Fixed, non-content diagnostics only. Never retain model text, identifiers,
+// action values or reasoning to investigate a provider's encoding failures.
+export const ACTIONS_STRING_DIAGNOSTICS = [
+    "json_array_empty_valid_decision",
+    "json_array_nonempty_valid_decision",
+    "json_array_invalid_decision",
+    "json_nonarray",
+    "invalid_json",
+    "empty_string_valid_skip",
+    "empty_string_other_decision",
+    "non_json_array_text",
+    "json5_array_valid_decision",
+    "json5_array_invalid_decision",
+    "over_size_limit",
+];
+function diagnoseActionsString(obj) {
+    if (!obj || typeof obj !== "object" || Array.isArray(obj))
+        return undefined;
+    const record = obj;
+    if (typeof record.actions !== "string")
+        return undefined;
+    if (record.actions.length > 65_536)
+        return "over_size_limit";
+    const text = record.actions.trim();
+    if (text === "") {
+        return record.decision === "skip" &&
+            decisionSchema.safeParse({ ...record, actions: [] }).success
+            ? "empty_string_valid_skip"
+            : "empty_string_other_decision";
+    }
+    let actions;
+    try {
+        actions = JSON.parse(record.actions);
+    }
+    catch {
+        if (!text.startsWith("["))
+            return "invalid_json";
+        // Diagnostic only: identify alternate literal encodings without accepting
+        // them or retaining content. JSON5 never evaluates expressions. Requiring
+        // finite JSON values keeps Infinity/NaN from looking like usable actions.
+        try {
+            const candidate = JSON5.parse(text);
+            JSON.stringify(candidate, (key, value) => {
+                if (["__proto__", "constructor", "prototype"].includes(key) ||
+                    (typeof value === "number" && !Number.isFinite(value)))
+                    throw new Error("Unsafe diagnostic value");
+                return value;
+            });
+            return Array.isArray(candidate) &&
+                decisionSchema.safeParse({ ...record, actions: candidate }).success
+                ? "json5_array_valid_decision"
+                : "json5_array_invalid_decision";
+        }
+        catch {
+            return "non_json_array_text";
+        }
+    }
+    if (!Array.isArray(actions))
+        return "json_nonarray";
+    if (!decisionSchema.safeParse({ ...record, actions }).success)
+        return "json_array_invalid_decision";
+    return actions.length === 0
+        ? "json_array_empty_valid_decision"
+        : "json_array_nonempty_valid_decision";
+}
+function safeIssueMessage(issue) {
+    // These Zod messages echo model-supplied values or unknown field names.
+    // Other messages in this fixed schema describe types or contract limits.
+    switch (issue.code) {
+        case "invalid_enum_value":
+            return "Invalid enum value";
+        case "invalid_literal":
+            return "Invalid literal value";
+        case "unrecognized_keys":
+            return "Unrecognized field(s)";
+        default:
+            return issue.message;
+    }
+}
 export function parseDecision(text) {
     let obj;
     try {
         obj = normalizeDecisionVerb(coerceJson(text));
     }
-    catch (err) {
+    catch {
         return {
             ok: false,
-            error: `model output is not valid JSON: ${err instanceof Error ? err.message : String(err)}`,
+            // Node's JSON syntax errors can include excerpts of private model text.
+            error: "model output is not valid JSON",
         };
     }
     const res = decisionSchema.safeParse(obj);
@@ -379,8 +460,9 @@ export function parseDecision(text) {
         return {
             ok: false,
             error: res.error.issues
-                .map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`)
+                .map((i) => `${i.path.join(".") || "(root)"}: ${safeIssueMessage(i)}`)
                 .join("; "),
+            actionsStringDiagnostic: diagnoseActionsString(obj),
         };
     }
     const d = res.data;

package/dist/agent/decisionReceipt.d.ts

@@ -8,7 +8,7 @@ interface Row {
 }
 export interface DecisionInputRecord {
     version: "coinrithm.decision-input.v1";
-    projectionVersion?: "coinrithm.decision-input-projection.v2";
+    projectionVersion?: "coinrithm.decision-input-projection.v2" | "coinrithm.decision-input-projection.v3";
     visibility: "private";
     completeness: "partial";
     phase: DecisionInputPhase;
@@ -21,6 +21,10 @@ export interface DecisionInputRecord {
     dailyRiskBudget: DailyRiskBudget | null;
     guardState: Record<string, number | boolean | null>;
     account: Record<string, number | boolean | string | null> | null;
+    marketMood?: {
+        fearGreed: number | null;
+        fetchedAt: string | null;
+    } | null;
     lists: Record<string, Row[]>;
     counts: Record<string, {
         source: number;

package/dist/agent/decisionReceipt.js

@@ -22,6 +22,20 @@ const fingerprint = (value) => typeof value === "string" && /^sha256:[a-f0-9]{64
     ? value
     : null;
 const numeric = (raw, keys) => Object.fromEntries(keys.map((key) => [key, num(raw[key])]));
+const count = (value) => Number.isSafeInteger(value) && value >= 0
+    ? value
+    : null;
+const fearGreed = (value) => {
+    const v = num(value);
+    return v !== null && v >= 0 && v <= 100 ? v : null;
+};
+const PROJECTION_V3 = "coinrithm.decision-input-projection.v3";
+// Watch-row fields that exist only from projection v3 on.
+const SENTIMENT_V3_KEYS = [
+    "sentimentTotalVotes",
+    "sentimentDayUtc",
+    "sentimentUpdatedAt",
+];
 const freshness = (value) => {
     const raw = obj(parseFreshness({ freshness: value }));
     return {
@@ -49,7 +63,7 @@ export function buildDecisionInputRecord(input) {
     const budget = buildDailyRiskBudget(input.spec, input.state);
     const record = {
         version: "coinrithm.decision-input.v1",
-        projectionVersion: "coinrithm.decision-input-projection.v2",
+        projectionVersion: PROJECTION_V3,
         visibility: "private",
         completeness: "partial",
         phase: input.phase,
@@ -115,6 +129,12 @@ export function buildDecisionInputRecord(input) {
         equityMusd: num(obs.equityMusd),
         polledBeforeWrite: bool(obs.polledBeforeWrite),
     };
+    record.marketMood = obs.marketMood
+        ? {
+            fearGreed: fearGreed(obs.marketMood.fearGreed),
+            fetchedAt: sourceTimestamp(obs.marketMood.fetchedAt) ?? null,
+        }
+        : null;
     const add = (name, items, project) => {
         const all = arr(items);
         // Bound work/space independently of the upstream list limit. Preserve order,
@@ -137,6 +157,10 @@ export function buildDecisionInputRecord(input) {
             "change7d",
             "sentimentBullishPct",
         ]),
+        // The sample and its own clocks; null = unknown, never "fresh".
+        sentimentTotalVotes: count(r.sentimentTotalVotes),
+        sentimentDayUtc: sourceTimestamp(r.sentimentDayUtc) ?? null,
+        sentimentUpdatedAt: sourceTimestamp(r.sentimentUpdatedAt) ?? null,
         freshness: freshness(r.freshness),
         ...(r.indicatorContext
             ? {
@@ -357,6 +381,7 @@ const LIST_KEYS = {
         "change24h",
         "change7d",
         "sentimentBullishPct",
+        ...SENTIMENT_V3_KEYS,
         "freshness",
         "indicators",
         "indicatorContext",
@@ -467,8 +492,16 @@ function validRow(value, keys) {
             return true;
         if (NESTED_KEYS[key])
             return validRow(v, NESTED_KEYS[key]);
-        if (key === "asOf" || key === "assessedAt" || key === "openedAt")
+        if ([
+            "asOf",
+            "assessedAt",
+            "openedAt",
+            "sentimentDayUtc",
+            "sentimentUpdatedAt",
+        ].includes(key))
             return sourceTimestamp(v) === v;
+        if (key === "sentimentTotalVotes")
+            return count(v) !== null;
         if (key === "basis")
             return code(v, FRESHNESS_BASES) !== null;
         if (key === "range")
@@ -565,13 +598,29 @@ export function sanitizeDecisionInputRecord(value) {
             "dailyRiskBudget",
             "guardState",
             "account",
+            "marketMood",
             "lists",
             "counts",
             "omissions",
         ]))
             return undefined;
         if (r.projectionVersion !== undefined &&
-            r.projectionVersion !== "coinrithm.decision-input-projection.v2")
+            r.projectionVersion !== "coinrithm.decision-input-projection.v2" &&
+            r.projectionVersion !== PROJECTION_V3)
+            return undefined;
+        // An older record must never carry, or be mistaken for, v3 fields.
+        const v3 = r.projectionVersion === PROJECTION_V3;
+        if (!v3 &&
+            (r.marketMood !== undefined ||
+                arr(obj(r.lists).watch).some((row) => SENTIMENT_V3_KEYS.some((k) => k in obj(row)))))
+            return undefined;
+        if (r.marketMood !== undefined &&
+            r.marketMood !== null &&
+            (!keysOnly(r.marketMood, ["fearGreed", "fetchedAt"]) ||
+                (r.marketMood.fearGreed !== null &&
+                    fearGreed(r.marketMood.fearGreed) === null) ||
+                (r.marketMood.fetchedAt !== null &&
+                    sourceTimestamp(r.marketMood.fetchedAt) !== r.marketMood.fetchedAt)))
             return undefined;
         if (r.version !== "coinrithm.decision-input.v1" ||
             r.visibility !== "private" ||

package/dist/agent/decisionValidator.d.ts

@@ -20,7 +20,37 @@ export interface DecisionContext {
     realizedLossTodayMusd: number;
     targetedPositionIds: number[];
     targetedOrderIds: number[];
+    pmEventsOpenedThisCycle?: string[];
+    pmCoinHorizonsOpenedThisCycle?: PmCoinHorizon[];
+    nowMs?: number;
 }
+/**
+ * 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 declare function requiredGapEdgePoints(entryPct: number, gapPct: number): number;
+/** Ends within this of each other share a coin horizon (venue date splits). */
+export declare const PM_COIN_HORIZON_WINDOW_MS: number;
+/** An end beyond this is a venue sentinel, never a real horizon. */
+export declare const PM_PLAUSIBLE_END_MAX_MS: number;
+export interface PmCoinHorizon {
+    coins: string[];
+    endMs: number;
+}
+/** The later of observation.asOf and the validation clock, when known. */
+export declare function pmReferenceMs(asOf: string, nowMs?: number): number;
+/**
+ * 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 declare function pmCoinHorizonOf(item: {
+    coins?: string[];
+    endDate?: string;
+}, refMs: number): PmCoinHorizon | null;
+/** Event key shared by pm_open actions, held positions and markets. */
+export declare function pmEventKey(source: string, slug: string): string;
 /**
  * True when a thesis says, in so many words, that it is betting AGAINST the
  * outcome the action is buying. Deliberately narrow: it fires only when the

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/futuresEligibility.d.ts

@@ -0,0 +1,36 @@
+import type { Observation, ProposedAction } from "./types.js";
+export type FuturesEntryEligibilityStatus = "eligible" | "reference_stale" | "reference_unavailable";
+export interface FuturesEntryEligibility {
+    status: FuturesEntryEligibilityStatus;
+    /** Whether the server gate currently requires a reference for NEW opens. */
+    referenceRequired: boolean;
+    venue: string | null;
+    symbol: string | null;
+    referenceFetchedAt: string | null;
+    maxReferenceAgeHours: number;
+    evaluatedAt: string;
+}
+/**
+ * Strict parse of the market context field against its contract (backend-v2
+ * #106). Anything missing or malformed (an older API, a partial response, an
+ * unknown status, a non-boolean referenceRequired, a missing or invalid
+ * evaluatedAt, a non-positive or non-finite maxReferenceAgeHours, or a present
+ * but invalid referenceFetchedAt) is `undefined` = UNKNOWN. Unknown never
+ * blocks: the runner keeps today's behaviour and the server gate decides.
+ */
+export declare function futuresEntryEligibilityOf(marketContext: unknown): FuturesEntryEligibility | undefined;
+export interface FuturesEntryPreflightRejection {
+    code: "futures_reference_unavailable" | "futures_reference_stale";
+    reason: string;
+}
+/**
+ * Pre-quote check for a NEW futures open. Returns a rejection only when the
+ * observation EXPLICITLY reports that the server gate requires a reference and
+ * has none (or only a stale one) for this coin. Everything else passes:
+ * - non-futures_open actions (spot, PM, futures_close / futures_set_sltp);
+ * - any open futures position on the same coin (the open is an add or position
+ *   management, which the server never refuses for the reference);
+ * - unknown eligibility (field absent on an older API);
+ * - referenceRequired false.
+ */
+export declare function futuresEntryPreflight(action: ProposedAction, observation: Observation): FuturesEntryPreflightRejection | null;

package/dist/agent/futuresEligibility.js

@@ -0,0 +1,90 @@
+// Futures entry eligibility (API >= backend-v2 #106): GET /api/agent/market/{coinId}
+// carries `futuresEntryEligibility`, what the server entry gate's own
+// perpetual-reference rule says about a NEW futures open on the coin. Before it,
+// universe_scan surfaced coins with no supported perpetual reference (tokenized
+// ETFs such as SLVON/NAKA) and the runner spent a futures quote only to be
+// refused with perpetual_reference_unavailable (J-74). The server gate stays
+// authoritative: eligibility can change between observation and execution.
+import { asObj, asStr } from "./extract.js";
+import { baseSymbol } from "./setups.js";
+const STATUSES = [
+    "eligible",
+    "reference_stale",
+    "reference_unavailable",
+];
+// A zoned ISO 8601 date-time (the contract's `format: date-time`):
+// YYYY-MM-DDTHH:MM[:SS[.fraction]] with Z or a +/-HH:MM offset. Date-only,
+// zone-less and bare numbers ("0") are rejected even though Date.parse
+// accepts them.
+const ZONED_DATE_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:Z|[+-]\d{2}:\d{2})$/;
+const isIsoDate = (v) => typeof v === "string" &&
+    ZONED_DATE_TIME.test(v) &&
+    Number.isFinite(Date.parse(v));
+/**
+ * Strict parse of the market context field against its contract (backend-v2
+ * #106). Anything missing or malformed (an older API, a partial response, an
+ * unknown status, a non-boolean referenceRequired, a missing or invalid
+ * evaluatedAt, a non-positive or non-finite maxReferenceAgeHours, or a present
+ * but invalid referenceFetchedAt) is `undefined` = UNKNOWN. Unknown never
+ * blocks: the runner keeps today's behaviour and the server gate decides.
+ */
+export function futuresEntryEligibilityOf(marketContext) {
+    const raw = asObj(asObj(marketContext).futuresEntryEligibility);
+    const status = asStr(raw.status);
+    if (!status || !STATUSES.includes(status))
+        return undefined;
+    if (typeof raw.referenceRequired !== "boolean")
+        return undefined;
+    const hours = raw.maxReferenceAgeHours;
+    if (typeof hours !== "number" || !Number.isFinite(hours) || hours <= 0)
+        return undefined;
+    if (!isIsoDate(raw.evaluatedAt))
+        return undefined;
+    const fetchedAt = raw.referenceFetchedAt;
+    if (fetchedAt != null && !isIsoDate(fetchedAt))
+        return undefined;
+    return {
+        status,
+        referenceRequired: raw.referenceRequired,
+        venue: asStr(raw.venue) ?? null,
+        symbol: asStr(raw.symbol) ?? null,
+        referenceFetchedAt: fetchedAt ?? null,
+        maxReferenceAgeHours: hours,
+        evaluatedAt: raw.evaluatedAt,
+    };
+}
+/**
+ * Pre-quote check for a NEW futures open. Returns a rejection only when the
+ * observation EXPLICITLY reports that the server gate requires a reference and
+ * has none (or only a stale one) for this coin. Everything else passes:
+ * - non-futures_open actions (spot, PM, futures_close / futures_set_sltp);
+ * - any open futures position on the same coin (the open is an add or position
+ *   management, which the server never refuses for the reference);
+ * - unknown eligibility (field absent on an older API);
+ * - referenceRequired false.
+ */
+export function futuresEntryPreflight(action, observation) {
+    if (action.type !== "futures_open")
+        return null;
+    const base = baseSymbol(action.symbol);
+    const holdsCoin = (observation.openPositions ?? []).some((p) => p.venue === "futures" &&
+        (p.status ?? "open") === "open" &&
+        baseSymbol(p.symbol) === base);
+    if (holdsCoin)
+        return null;
+    const entry = observation.watch.find((w) => baseSymbol(w.symbol) === base);
+    const e = entry?.futuresEntryEligibility;
+    if (!e || !e.referenceRequired || e.status === "eligible")
+        return null;
+    const when = ` at ${e.evaluatedAt}`;
+    if (e.status === "reference_stale") {
+        return {
+            code: "futures_reference_stale",
+            reason: `${action.symbol}: the perpetual reference${e.venue ? ` (${e.venue})` : ""} is stale or unusable for a NEW futures open${when} (too old, or its refresh time is missing, invalid or in the future); the server would refuse it (perpetual_reference_stale). Trade another coin or wait for a fresh reference.`,
+        };
+    }
+    return {
+        code: "futures_reference_unavailable",
+        reason: `${action.symbol}: CoinRithm has no supported perpetual reference for this coin${when}, so the server refuses a NEW futures open (perpetual_reference_unavailable). Use spot for it, or another coin for futures.`,
+    };
+}