@coinrithm/mcp-trading 0.7.15 → 0.7.16

package/dist/agent/prompt.d.ts

@@ -1,4 +1,4 @@
-import { AgentSpec, Observation, PmResolution, RunState } from "./types.js";
+import { AgentSpec, Observation, PmResolution, RunState, type ObjectivePrimary } from "./types.js";
 import type { DecisionActionExclusion } from "./providerCapabilities.js";
 export interface DailyRiskBudget {
     version: "coinrithm.daily-risk-budget.v1";
@@ -19,6 +19,8 @@ export interface FuturesCapacity {
 }
 export declare function buildFuturesCapacity(spec: AgentSpec, obs: Pick<Observation, "openPositions">): FuturesCapacity;
 export declare function formatPmResolutions(resolutions: PmResolution[]): string[];
+export declare const OBJECTIVE_GUIDANCE: Record<ObjectivePrimary, string>;
+export declare function objectiveLine(spec: Pick<AgentSpec, "objective">): string | null;
 export declare function buildSystemPrompt(spec: AgentSpec, mergedProse: string, opts?: {
     includeForecast?: boolean;
     excludeActionTypes?: readonly DecisionActionExclusion[];
@@ -31,5 +33,6 @@ export declare function buildUserPrompt(obs: Observation, journal?: Array<{
     dailyRiskBudget?: DailyRiskBudget;
     capitalSizing?: AgentSpec["capitalSizing"];
     futuresCapacity?: FuturesCapacity;
+    compactTables?: boolean;
     excludeActionTypes?: readonly DecisionActionExclusion[];
 }): string;

package/dist/agent/prompt.js

@@ -4,8 +4,11 @@
 // prefix stable and avoiding balances or counts in the system prompt.
 // The model only PROPOSES — the runner re-checks every action against the caps,
 // so the prompt states the caps but never relies on the model to honor them.
+import { barLabel, indicatorRangeOf, signalThresholdsOf } from "./signals.js";
+import { describeUniverse, scansUniverse } from "./universe.js";
 import { pmQualityOf, pmDecisionSupportOf } from "./pmContext.js";
 import { usesCapitalSizing } from "./capitalSizing.js";
+import { serializePromptObservation } from "./promptTables.js";
 // The runner has already called rollDay. Use the same counter as validation,
 // including conservative legacy-state migration; never infer it from writes,
 // model calls, or the number of positions that remain open.
@@ -69,6 +72,23 @@ export function formatPmResolutions(resolutions) {
         `Resolved since last cycle: ${items.join("; ")}.`,
     ];
 }
+// The agent's declared objective (spec.objective.primary), stated to the
+// model as how to weigh trade-offs (Studio audit, root 56825: the Studio
+// promised the objective "shapes how it weighs risk vs return", but nothing
+// read it). Guidance only: the hard caps below still decide what executes.
+export const OBJECTIVE_GUIDANCE = {
+    realized_pnl: "realized PnL after fees. Prefer setups with clear reward over risk; closing winners and cutting losers counts as much as entries.",
+    risk_adjusted: "return per unit of risk. Prefer fewer, cleaner setups with a meaningful stop; when the risk is unclear, skip.",
+    drawdown_control: "preserving capital and keeping drawdowns small, within your declared strategy and the existing risk limits.",
+    calibration: "honest, evidence-based probabilities. Report what the evidence supports and keep your uncertainty visible; a forecast is valid without a trade, and a trade needs adequate edge, otherwise skip it.",
+};
+export function objectiveLine(spec) {
+    const primary = spec.objective?.primary;
+    return primary &&
+        Object.prototype.hasOwnProperty.call(OBJECTIVE_GUIDANCE, primary)
+        ? `Optimise for ${OBJECTIVE_GUIDANCE[primary]} This is how to weigh trade-offs within your strategy; it never overrides a hard cap.`
+        : null;
+}
 export function buildSystemPrompt(spec, mergedProse, 
 // includeForecast (default OFF here; the runner passes the house-agent flag):
 // when true, pm_open asks for a market-aware forecastProbability (1..99):
@@ -128,6 +148,9 @@ opts = {}) {
         "## Your strategy (your borders)",
         mergedProse.trim() || "(no strategy prose provided)",
         "",
+        ...(objectiveLine(spec)
+            ? ["## Your objective", objectiveLine(spec), ""]
+            : []),
         "## Hard caps the runner enforces (do not exceed; proposing over a cap wastes the cycle)",
         "- When supplied, the user prompt's dailyRiskBudget is the remaining UTC-day entry/add allowance. It outranks setup/entry pressure: exhaustion is a legitimate skip for new risk, never a reason to skip otherwise-valid closes or protection. All other caps still apply, even when this daily count is unlimited.",
         `- venues you may act in: ${v.join(", ")}`,
@@ -162,7 +185,7 @@ opts = {}) {
         // sections telling one story.
         ...(hasCoinVenue
             ? [
-                spec.capabilities.includes("universe_scan")
+                scansUniverse(spec)
                     ? `- tradable symbols (${coinVenueLabel}): your watchlist (${r.watchlist.join(", ")}) PLUS this cycle's watch entries marked \`discovered: true\` — nothing outside those`
                     : `- watchlist (${coinVenueLabel} use ONLY these): ${r.watchlist.join(", ")}`,
             ]
@@ -184,6 +207,31 @@ opts = {}) {
                 `- PM ENTRY FLOOR: pm_open on an outcome whose market probability is below ${r.pmMinEntryProbabilityPct} points is REJECTED by the runner (the chosen outcome's own price; fees are not counted). Do not propose cheaper longshots; look for edge on outcomes priced at or above the floor.`,
             ]
             : []),
+        ...(hasPm && typeof r.pmMinEdgeGapPct === "number"
+            ? [
+                `- PM EDGE RULE: every pm_open MUST carry forecastProbability, and it must beat the fee-inclusive cost by ${r.pmMinEdgeGapPct}% of the room left to 100 (cost 50 needs ${(50 + (r.pmMinEdgeGapPct / 100) * 50).toFixed(1)}, cost 70 needs ${(70 + (r.pmMinEdgeGapPct / 100) * 30).toFixed(1)}). The runner REJECTS an open without a forecast or under this bar.`,
+            ]
+            : []),
+        ...(hasPm && typeof r.pmMaxEdgePoints === "number"
+            ? [
+                `- PM OVERCONFIDENCE CAP: every pm_open MUST carry forecastProbability, and it may beat the fee-inclusive cost by at most ${r.pmMaxEdgePoints} points. Base the forecast on current evidence. Do not alter a forecast to pass this cap: skip the trade if your evidence-based forecast falls outside the permitted range. Opens over the cap are REJECTED.`,
+            ]
+            : []),
+        ...(hasPm && typeof r.pmMaxOpenPerEvent === "number"
+            ? [
+                `- PM PER-EVENT CAP: at most ${r.pmMaxOpenPerEvent} open bet(s) per event (same market slug, counting bets you already hold). Extra opens are REJECTED.`,
+            ]
+            : []),
+        ...(hasPm && typeof r.pmMaxOpenPerCoinHorizon === "number"
+            ? [
+                `- PM COIN-HORIZON CAP: at most ${r.pmMaxOpenPerCoinHorizon} open bet(s) on the same coin whose events end within 24 h of each other, across DIFFERENT events (counting bets you already hold; uses each market's linked coins and end date). Extra opens are REJECTED.`,
+            ]
+            : []),
+        ...(hasPm && typeof r.pmMinMinutesToClose === "number"
+            ? [
+                `- PM CLOSE CUTOFF: a market whose \`end\` is less than ${r.pmMinMinutesToClose} minutes away when the runner validates your action is REJECTED; the price already knows.`,
+            ]
+            : []),
         ...(includeForecast
             ? [
                 "- FORECAST RULE (pm_open forecastProbability): the current market probability is already included in this request, so this is a market-aware estimate, not a blinded forecast. Form your own evidence-based probability that the outcome you are backing actually WINS, using the question, its resolution criteria, deadline, and available evidence. Put that number (1-99, whole or one decimal) in `forecastProbability`. This is graded against reality as your PUBLIC calibration record, so it must reflect your judgement: do NOT mechanically copy or round observation.pmMarkets `prob` to produce a forecast. It is FINE if your honest forecast happens to land on the market's number — but reaching that by echoing the price defeats the point. If you genuinely cannot form an evidence-based view, OMIT the field rather than parroting the market (an absent forecast is better than a fake one, and it never blocks the bet). A forecast you DO give is enforced: if it is not above what the outcome currently costs, the open is rejected, because buying something you price below the market is a losing trade by your own numbers.",
@@ -192,20 +240,37 @@ opts = {}) {
         `- abstention.minConfidence ${spec.abstention.minConfidence}: opens below this are rejected, so act with genuine conviction — but routine caution is no reason to sit out a clear setup`,
         ...(hasCoinVenue
             ? [
+                "- Open interest (watch[].openInterest) is single-side perpetual exposure in USD across the named venues, not the entire market. Each contract has both a long and a short: OI with price alone cannot establish who opened, closed, or was liquidated. USD OI can also move as price changes without contract counts changing. Treat long/short-covering interpretations as hypotheses requiring other evidence, never as a standalone trade signal. Read each change WITH its change1hVenues/change24hVenues: only matching venue-contracts contribute, and that set may differ from the total's venues. Null changes are unknown; a reported zero total is valid. Ignore stale or missing readings and check asOf against the current observation clock.",
+                "- Positioning (watch[].positioning, Binance, top coins by open interest only) counts ACCOUNTS (longShortAccountRatio, longAccountPct) or top-trader POSITIONS (topTraderPositionRatio); takerBuySellRatio is taker buy over sell volume for the last CLOSED 15-minute period. Each value has its own asOf. They describe who is positioned, not where price goes: a crowded side is a hypothesis, never a standalone signal. Ignore stale values.",
+                "- Funding venues (watch[].fundingByVenue): rateFraction is a fraction per intervalHours, not a percent. hourlyEquivalentFraction = rateFraction / intervalHours is simple normalization, not realized performance, APR or forecast return; an unknown interval stays null. Venues are collected independently, not at the same time. Read each fetchedAt/ageSeconds/stale; sourceAt=null means provider observation time and delay are unknown. context_only does not replace the paper settlement reference or entry gate. Ignore stale or missing values and do not treat a funding difference alone as a trade signal.",
+                "- Depth: watch[].depth is ONE venue's visible order book (Hyperliquid, at most 20 price levels per side), NOT total market liquidity and NOT an executable fill. bid/ask each give usd (resting USD in the visible levels), reachPct (how far from the mid those levels reach, often well under 1%), levels and complete. complete=false means liquidity beyond reachPct was not returned and remains unknown, never zero; null is unknown. Resting orders can be cancelled at any time; treat a bid/ask imbalance as a weak hint, never a standalone signal. Ignore stale values.",
+                "- DeFi: watch[].chainTvl is the value locked on the chain associated with that asset by DefiLlama (an association, not proof it is the chain's native token), NOT the coin's market value; change1dPct/change7dPct compare the provider's dated daily points (dayAt). The current TVL has no observation time (sourceObservedAt null): publishedAt is when the provider published the response and fetchedAt is when we collected it; neither dates the TVL itself. observation.stablecoinSupply is total stablecoin supply market-wide with 1d/7d changes. Both are slow structural context, never a short-term trade trigger; a stale value or a null change is unknown.",
+                "- Macro (observation.macro): Hyperliquid xyz perpetuals that track the S&P 500, Nasdaq-100, Nikkei, KOSPI, gold, silver, oil, gas, copper, EUR/USD, GBP/USD, USD/JPY and TLT around the clock: PROXIES, not exchange quotes, each with its own asOf. Use them as risk-on/risk-off context only; a stale quote is unknown.",
+                "- Liquidations (watch[].liquidations, OKX USDT swaps only): long/short liquidated USDT notional over the last 1h / 24h, read WITH capturedPct, which is a LOWER BOUND of OUR capture uptime for the window (at least that share was captured), not exchange completeness. Low capturedPct means unknown, never 'no liquidations'. Other venues are not included.",
                 "- Community sentiment is a dated sample: read sentimentBullishPct WITH sentimentTotalVotes and sentimentDayUtc. A tiny or old cohort is weak evidence, not current market consensus. sentimentUpdatedAt is the cohort's write time. Missing counts/dates are unknown; price freshness does not date sentiment. marketMood.fetchedAt is Fear & Greed collection time, not its provider observation time. Compare each clock with observation.asOf; never invent currentness from a missing date.",
             ]
             : []),
         ...(spec.capabilities.includes("indicators")
             ? [
                 "",
-                "## Signals — each watch entry may carry `indicators` (nominal five-minute candles)",
-                "- `indicatorContext` reports accepted candle counts, source `asOf` and intervalStatus (regular/irregular/unknown); compare its asOf with observation.asOf for age. /market freshness is separate. nominalIntervalSeconds=300 does not prove fresh, continuous candles. Missing timestamps are unknown; stale, future-dated or irregular candles do not establish a current five-minute signal. `recent15` describes only recent spacing; Wilder atr14 also retains earlier history, so recent regularity does not erase older gaps.",
-                "- rsi14: momentum (>70 overbought, <30 oversold); ema20 & ema50: trend; atr14: volatility (size stops off it); bollinger {upper,mid,lower}; recent20 {high,low}: breakout levels.",
+                `## Signals — each watch entry may carry \`indicators\` (nominal ${barLabel(indicatorRangeOf(spec))} candles)`,
+                "- `indicatorContext` reports accepted candle counts, source `asOf` and intervalStatus (regular/irregular/unknown); compare its asOf with observation.asOf for age. /market freshness is separate. nominalIntervalSeconds does not prove fresh, continuous candles. Missing timestamps are unknown; stale, future-dated or irregular candles do not establish a current signal. `recent15` describes only recent spacing; Wilder atr14 also retains earlier history, so recent regularity does not erase older gaps.",
+                `- rsi14: momentum (this agent flags overbought at ${signalThresholdsOf(spec).rsiOverbought} and oversold at ${signalThresholdsOf(spec).rsiOversold}); ema20 & ema50: trend; atr14: volatility (size stops off it); bollinger {upper,mid,lower}; recent20 {high,low}: breakout levels.`,
                 "- boolean reads: aboveEma20, ema20AboveEma50 (uptrend when both true), brokeRecentHigh (breakout), brokeRecentLow (breakdown).",
                 "- a null field = not enough data; ignore it. These INFORM your decision; they never widen a cap.",
             ]
             : []),
-        ...(spec.capabilities.includes("universe_scan")
+        ...(spec.universe
+            ? [
+                "",
+                "## Your market (declared boundaries) — candidates beyond your watchlist",
+                `Each cycle the runner scans the market inside YOUR boundaries: ${describeUniverse(spec.universe)}. Watch entries with \`discovered: true\` are the top rows of that scan, resolved with the same price/sentiment (and indicators) data as your watchlist. observation.universeMovers lists further rows as symbol + 24h change only (context — you cannot trade those directly this cycle). Nothing outside these boundaries is shown to you or tradable.`,
+                "- Treat a discovered candidate like any other symbol: analyze it for catalysts, exhaustion and reversal BEFORE acting. A big move is as often a top as a beginning — chasing candles blind is how discovery loses money.",
+                "- All your normal risk rules apply unchanged: caps, stops, blocklist, confidence floor. Discovery widens what you can SEE, never what you may risk.",
+                "- Your boundaries also bind your watchlist: a watch entry with `withinBoundaries: false` (or no withinBoundaries and not discovered) is context only. You may close or sell an existing position in it, but a new entry is REJECTED (outside_universe).",
+            ]
+            : []),
+        ...(!spec.universe && spec.capabilities.includes("universe_scan")
             ? [
                 "",
                 "## Universe scan (discovered movers) — candidates beyond your watchlist",
@@ -391,6 +456,31 @@ export function buildUserPrompt(obs, journal, opts = {}) {
                 ]
                 : []));
     }
+    // Futures entry rules the runner enforces, stated with THIS agent's numbers.
+    // The weekly house report (2026-09-30..10-07) found the two largest refusal
+    // classes were opens below the fee-inclusive reward:risk floor
+    // (capital_quote_reward_risk_too_low) and SL/TP on an add
+    // (add_cannot_carry_sltp). Wording only: the validators are unchanged.
+    if (hasFutures && !futuresOpenWithheld) {
+        const held = Array.from(new Set(obs.openPositions
+            .filter((p) => p.venue === "futures" &&
+            (p.status ?? "open") === "open" &&
+            typeof p.symbol === "string" &&
+            p.symbol.length > 0)
+            .map((p) => p.symbol.toUpperCase())));
+        const minRewardRisk = opts.capitalSizing?.minRewardRisk;
+        if (typeof minRewardRisk === "number" &&
+            Number.isFinite(minRewardRisk) &&
+            minRewardRisk >= 1) {
+            lines.push(`REWARD:RISK FLOOR ${minRewardRisk} (your capitalSizing.minRewardRisk, enforced with fees; an open below it is rejected as capital_quote_reward_risk_too_low): the take-profit's distance from entry, minus the entry and exit fees, must be at least ${minRewardRisk}x the stop's distance from entry plus those fees. A target exactly ${minRewardRisk}x the stop distance FAILS once fees are counted, so leave room. If the setup cannot offer such a target, do not open it.`);
+        }
+        if (held.length > 0) {
+            const list = held.join(", ");
+            lines.push(opts.capitalSizing
+                ? `You already hold futures on ${list}. Under your capital policy you cannot ADD to them: every futures_open needs its own stopLossPrice and takeProfitPrice for sizing, and the server refuses SL/TP on an add (add_cannot_carry_sltp). Propose NO futures_open on ${list}; manage them with futures_set_sltp or futures_close on their positionId.`
+                : `You already hold futures on ${list}. A futures_open on any of them is an ADD and must carry NO stopLossPrice or takeProfitPrice (the whole open is rejected as add_cannot_carry_sltp); adjust protection with futures_set_sltp on the positionId instead.`);
+        }
+    }
     // Flat-state steer: when the agent holds NOTHING, weaker models (Llama 3.1 8B)
     // still emit futures_close / futures_set_sltp / spot_cancel with a hallucinated
     // positionId/orderId — which fails the whole cycle's strict parse (one bad id
@@ -442,7 +532,7 @@ export function buildUserPrompt(obs, journal, opts = {}) {
     lines.push("", "```json", 
     // Compact (no pretty-print indentation — ~40% fewer tokens, still valid JSON)
     // and the trade ledger is capped so a busy shared book can't bloat the prompt.
-    JSON.stringify({
+    serializePromptObservation({
         asOf: obs.asOf,
         ...(opts.dailyRiskBudget
             ? { dailyRiskBudget: opts.dailyRiskBudget }
@@ -505,8 +595,9 @@ export function buildUserPrompt(obs, journal, opts = {}) {
         universeMovers: obs.universeMovers,
         whaleContext: obs.whaleContext,
         marketMood: obs.marketMood,
+        ...(obs.macro ? { macro: obs.macro } : {}),
         newClosedTrades: obs.newClosedTrades.slice(0, 20),
         polledBeforeWrite: obs.polledBeforeWrite,
-    }), "```", "", "Return ONLY the JSON decision object.");
+    }, opts.compactTables), "```", "", "Return ONLY the JSON decision object.");
     return lines.join("\n");
 }

package/dist/agent/promptTables.d.ts

@@ -0,0 +1 @@
+export declare function serializePromptObservation(value: unknown, compact?: boolean): string;

package/dist/agent/promptTables.js

@@ -0,0 +1,33 @@
+const row = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+// Keep market refs and per-outcome settlement rules in their proven object
+// representation. A provider probe mis-associated an optional rule with a ref.
+const TABLE_FIELDS = ["watch", "pmPositions", "newClosedTrades"];
+const FORMAT = "Tabular lists use columns and rows: each row's values map to the columns in order. Every row remains a separate item; nested objects keep their field names. References such as watch[].priceUsd refer to the reconstructed row. Only lists with identical fields use tables. Market refs and settlement rules remain objects. Return the normal decision JSON with actions as an array of objects.";
+export function serializePromptObservation(value, compact = false) {
+    const original = JSON.stringify(value);
+    if (!compact)
+        return original;
+    const data = JSON.parse(original);
+    let changed = false;
+    for (const field of TABLE_FIELDS) {
+        const list = data[field];
+        if (!Array.isArray(list) || list.length < 3 || !list.every(row))
+            continue;
+        const columns = Object.keys(list[0]).filter((k) => list.every((r) => Object.hasOwn(r, k)));
+        if (columns.length < 3 ||
+            list.some((r) => Object.keys(r).length !== columns.length))
+            continue;
+        const table = {
+            columns,
+            rows: list.map((r) => columns.map((k) => r[k])),
+        };
+        if (JSON.stringify(list).length - JSON.stringify(table).length < 512)
+            continue;
+        data[field] = table;
+        changed = true;
+    }
+    if (!changed)
+        return original;
+    const result = JSON.stringify({ tableFormat: FORMAT, ...data });
+    return result.length < original.length ? result : original;
+}

package/dist/agent/providerCapabilities.d.ts

@@ -1,6 +1,11 @@
 import { ProviderName } from "./types.js";
 export declare const NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1";
 export declare const DECISION_TOOL_NAME = "submit_trading_decision";
+export declare function canRetrySuperToolOutput(route: {
+    provider: string;
+    model: string;
+    baseUrl?: string | null;
+}, responseSource: string | undefined, actionsStringDiagnostic: string | undefined): boolean;
 export interface ChatShape {
     family: "openai-reasoning" | "nvidia-nemotron" | "anthropic" | "openai-compat";
     tokenParam: "max_tokens" | "max_completion_tokens";
@@ -13,6 +18,7 @@ export interface ChatShape {
     minProbeCompletionTokens: number;
 }
 export declare function chatShapeFor(provider: ProviderName, model: string, baseUrl?: string): ChatShape;
+export declare function withJsonContentTransport(shape: ChatShape): ChatShape;
 export type DecisionActionExclusion = "futures_open";
 export declare function restrictDecisionSchema(schema: Record<string, unknown>, exclude: readonly DecisionActionExclusion[] | undefined): Record<string, unknown>;
 /** Build the chat-completions body for a route from its capability shape. */

package/dist/agent/providerCapabilities.js

@@ -1,6 +1,16 @@
 import { DECISION_JSON_SCHEMA } from "./decision.js";
 export const NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1";
 export const DECISION_TOOL_NAME = "submit_trading_decision";
+// A retry changes transport only after the strict parser has rejected a known
+// Super tool-argument encoding failure. Valid responses and other routes keep
+// their original request shape. A custom endpoint is deliberately excluded.
+export function canRetrySuperToolOutput(route, responseSource, actionsStringDiagnostic) {
+    return (route.provider === "nvidia" &&
+        route.model === "nvidia/nemotron-3-super-120b-a12b" &&
+        (route.baseUrl == null || route.baseUrl === NVIDIA_BASE_URL) &&
+        responseSource === "tool_call" &&
+        actionsStringDiagnostic !== undefined);
+}
 // gpt-5*, o1/o3/o4* — the OpenAI reasoning-API family, wherever it is served.
 const OPENAI_REASONING_MODEL = /^(gpt-5|o[0-9])/i;
 const NEMOTRON_MODEL = /nemotron/i;
@@ -54,6 +64,19 @@ export function chatShapeFor(provider, model, baseUrl) {
         minProbeCompletionTokens: 1024,
     };
 }
+// Opt-in alternative for a hosted Nemotron route: plain JSON content
+// (`response_format: json_object`) instead of the forced decision tool call.
+// Hosted Super has returned the forced tool call with `actions` as a string
+// (519 of 533 malformed attempts in a 24h sample, 2026-10-05). In an 8-call
+// synthetic smoke pilot the tool-call arms failed 0/4 with the same coarse
+// string shape and the JSON-content arm parsed 2/2; that is not a rate
+// measurement and the exact serialization cause is not established. Only the
+// request transport changes: parseDecision still validates the full contract.
+export function withJsonContentTransport(shape) {
+    if (shape.family !== "nvidia-nemotron")
+        return shape;
+    return { ...shape, jsonSchema: undefined, jsonSchemaTransport: undefined };
+}
 // Transport-only restriction: drop the excluded variants from the action oneOf
 // a route decodes against. parseDecision keeps validating the FULL contract, so
 // a route that does not enforce a schema can still propose the action and the

package/dist/agent/providers.d.ts

@@ -1,8 +1,20 @@
 import { AgentSpec, ProviderName } from "./types.js";
+import { type ActionsStringDiagnostic } from "./decision.js";
 import { type DecisionActionExclusion } from "./providerCapabilities.js";
+export interface ProviderUsage {
+    promptTokens: number;
+    completionTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+    cacheWrite5mTokens?: number;
+    cacheWrite1hTokens?: number;
+}
+export declare function anthropicUsage(raw: unknown): ProviderUsage | undefined;
 export interface DecideInput {
     system: string;
     user: string;
+    /** Optional equivalent presentation for explicitly verified hosted routes. */
+    compactUser?: string;
     maxTokens?: number;
     timeoutMs?: number;
     excludeActionTypes?: readonly DecisionActionExclusion[];
@@ -16,6 +28,10 @@ export interface DecideRouteAttempt {
     retryAfterMs?: number;
     latencyMs: number;
     error?: string;
+    responseSource?: "tool_call" | "content_fallback" | "content";
+    actionsStringDiagnostic?: ActionsStringDiagnostic;
+    /** Scheduler admission categories, never free-form provider error text. */
+    admissionReasons?: Array<"request_budget" | "token_budget" | "concurrency" | "shared_key_cooldown" | "model_cooldown">;
 }
 export interface DecideRouteMeta {
     policyVersion: string;
@@ -29,14 +45,13 @@ export type DecideResult = {
     ok: true;
     text: string;
     responseSource?: "tool_call" | "content_fallback" | "content";
-    usage?: {
-        promptTokens: number;
-        completionTokens: number;
-    };
+    usage?: ProviderUsage;
     route?: DecideRouteMeta;
 } | {
     ok: false;
     error: string;
+    failureClass?: "malformed";
+    usage?: ProviderUsage;
     status?: number;
     retryAfterMs?: number;
     retryableHttpFailure?: true;
@@ -58,10 +73,13 @@ export interface ProviderEnv {
 /** Keep direct and routed cycle evidence consistent about NVIDIA backpressure. */
 export declare function classifyProviderFailure(result: Extract<DecideResult, {
     ok: false;
-}>): "capacity" | "permanent" | "transient";
-export declare function selectProvider(spec: AgentSpec, env: ProviderEnv, fetchFn?: typeof fetch): Provider;
+}>): "capacity" | "permanent" | "transient" | "malformed";
+export interface ProviderRouteOptions {
+    nemotronJsonContent?: boolean | (() => boolean);
+}
+export declare function selectProvider(spec: AgentSpec, env: ProviderEnv, fetchFn?: typeof fetch, options?: ProviderRouteOptions): Provider;
 export declare function providerForRoute(route: {
     provider: ProviderName;
     model: string;
     baseUrl?: string | null;
-}, apiKey: string, fetchFn?: typeof fetch): Provider;
+}, apiKey: string, fetchFn?: typeof fetch, options?: ProviderRouteOptions): Provider;