@coinrithm/mcp-trading 0.7.15 → 0.7.17

package/dist/agent/providers.js

@@ -3,7 +3,64 @@
 // single structured-JSON decision (parsed in decision.ts). No free-form tool
 // execution — the model only proposes; the runner disposes.
 import { retryAfterSeconds } from "../retryAfter.js";
-import { chatShapeFor, buildChatBody, DECISION_TOOL_NAME, NVIDIA_BASE_URL as CAP_NVIDIA_BASE_URL, } from "./providerCapabilities.js";
+import { parseDecisionForContract, } from "./decision.js";
+import { chatShapeFor, buildChatBody, withJsonContentTransport, canRetrySuperToolOutput, DECISION_TOOL_NAME, NVIDIA_BASE_URL as CAP_NVIDIA_BASE_URL, } from "./providerCapabilities.js";
+// A token count as Anthropic reports it: a non-negative safe integer. Zero
+// is a real count; anything else (missing, null, negative, NaN, fractional,
+// a string) is malformed.
+function exactCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0
+        ? value
+        : undefined;
+}
+// Anthropic usage, including prompt-cache reads and writes (and the 5m/1h
+// write split) when reported. Strict, because paid metering prices it (root
+// review of #118): input_tokens and output_tokens are mandatory, and a
+// malformed reported field (mandatory or cache) makes the WHOLE usage unknown
+// (undefined), never zero, so the call is metered uncertain instead of free.
+// Cache fields the response does not carry at all stay absent. A reported
+// write total must equal its 5m/1h split; a split without a total implies it.
+export function anthropicUsage(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+        return undefined;
+    const u = raw;
+    const promptTokens = exactCount(u.input_tokens);
+    const completionTokens = exactCount(u.output_tokens);
+    if (promptTokens === undefined || completionTokens === undefined)
+        return undefined;
+    const usage = { promptTokens, completionTokens };
+    const optional = (value) => value === undefined ? undefined : (exactCount(value) ?? null);
+    const cacheRead = optional(u.cache_read_input_tokens);
+    const cacheWrite = optional(u.cache_creation_input_tokens);
+    let write5m;
+    let write1h;
+    if (u.cache_creation !== undefined) {
+        const split = u.cache_creation;
+        if (typeof split !== "object" || split === null || Array.isArray(split))
+            return undefined;
+        const s = split;
+        write5m = optional(s.ephemeral_5m_input_tokens);
+        write1h = optional(s.ephemeral_1h_input_tokens);
+    }
+    if ([cacheRead, cacheWrite, write5m, write1h].includes(null))
+        return undefined;
+    if (write5m != null || write1h != null) {
+        const splitTotal = (write5m ?? 0) + (write1h ?? 0);
+        if (cacheWrite != null && cacheWrite !== splitTotal)
+            return undefined;
+        usage.cacheWriteTokens = splitTotal;
+        if (write5m != null)
+            usage.cacheWrite5mTokens = write5m;
+        if (write1h != null)
+            usage.cacheWrite1hTokens = write1h;
+    }
+    else if (cacheWrite != null) {
+        usage.cacheWriteTokens = cacheWrite;
+    }
+    if (cacheRead != null)
+        usage.cacheReadTokens = cacheRead;
+    return usage;
+}
 // NVIDIA NIM is OpenAI-compatible; the `nvidia` preset hard-wires the hosted
 // endpoint so an agent only needs `{ provider: nvidia, name: "<model id>" }`.
 const NVIDIA_BASE_URL = CAP_NVIDIA_BASE_URL;
@@ -31,6 +88,8 @@ const DEFAULT_TIMEOUT_MS = 300_000;
 const RETRYABLE_SERVER_STATUSES = new Set([500, 502, 503, 504]);
 /** Keep direct and routed cycle evidence consistent about NVIDIA backpressure. */
 export function classifyProviderFailure(result) {
+    if (result.failureClass === "malformed")
+        return "malformed";
     if (result.status === 429 ||
         (result.status === 503 &&
             /resourceexhausted|worker local total request limit/i.test(result.error ?? "")))
@@ -186,15 +245,27 @@ class AnthropicProvider {
                 }
                 const json = (await res.json());
                 const text = json.content?.map((c) => c.text ?? "").join("") ?? "";
-                const usage = json.usage
-                    ? {
-                        promptTokens: json.usage.input_tokens ?? 0,
-                        completionTokens: json.usage.output_tokens ?? 0,
-                    }
-                    : undefined;
+                // Absent or malformed usage is undefined (unknown), never zero.
+                const usage = anthropicUsage(json.usage);
+                if (json.stop_reason === "max_tokens" ||
+                    json.stop_reason === "model_context_window_exceeded") {
+                    return {
+                        ok: false,
+                        failureClass: "malformed",
+                        error: json.stop_reason === "max_tokens"
+                            ? "provider returned incomplete decision (output token limit)"
+                            : "provider returned incomplete decision (context window limit)",
+                        usage,
+                    };
+                }
                 return text
                     ? { ok: true, text, usage, responseSource: "content" }
-                    : { ok: false, error: "anthropic returned empty content" };
+                    : // Answered (and billed) with nothing usable: keep the usage.
+                        {
+                            ok: false,
+                            error: "anthropic returned empty content",
+                            ...(usage ? { usage } : {}),
+                        };
             });
         }
         catch (err) {
@@ -213,24 +284,40 @@ class AnthropicProvider {
         }
     }
 }
+function wantsJsonContent(options) {
+    const v = options.nemotronJsonContent;
+    if (typeof v !== "function")
+        return v === true;
+    try {
+        return v() === true;
+    }
+    catch {
+        return false;
+    }
+}
 class OpenAiCompatProvider {
     provider;
     model;
     apiKey;
     baseUrl;
     fetchFn;
+    options;
     label;
-    constructor(provider, model, apiKey, baseUrl, fetchFn) {
+    constructor(provider, model, apiKey, baseUrl, fetchFn, options = {}) {
         this.provider = provider;
         this.model = model;
         this.apiKey = apiKey;
         this.baseUrl = baseUrl;
         this.fetchFn = fetchFn;
+        this.options = options;
         this.label = `${baseUrl}/${model}`;
     }
     async decide(input) {
         const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-        const shape = chatShapeFor(this.provider, this.model, this.baseUrl);
+        const baseShape = chatShapeFor(this.provider, this.model, this.baseUrl);
+        const shape = wantsJsonContent(this.options)
+            ? withJsonContentTransport(baseShape)
+            : baseShape;
         let failureResponse;
         try {
             return await withProviderTimeout(timeoutMs, async (signal) => {
@@ -247,6 +334,7 @@ class OpenAiCompatProvider {
                         user: input.user,
                         maxTokens: input.maxTokens ?? 1024,
                         excludeActionTypes: input.excludeActionTypes,
+                        decisionContract: input.decisionContract,
                     })),
                 });
                 if (!res.ok) {
@@ -273,6 +361,14 @@ class OpenAiCompatProvider {
                         completionTokens: json.usage.completion_tokens ?? 0,
                     }
                     : undefined;
+                if (json.choices?.[0]?.finish_reason === "length") {
+                    return {
+                        ok: false,
+                        failureClass: "malformed",
+                        error: "provider returned incomplete decision (output token limit)",
+                        usage,
+                    };
+                }
                 return text
                     ? {
                         ok: true,
@@ -303,20 +399,24 @@ class OpenAiCompatProvider {
         }
     }
 }
-// A direct NVIDIA 5xx previously lost the whole cycle until the next cadence.
-// Retry only an explicit server refusal, once, on the identical configured
-// route. The shared router owns its own attempt/capacity budget and MUST NOT
-// receive this wrapper. No auth/404/429, network, timeout or decision repair
-// retries; no model substitution or request-parameter changes.
+// Direct NVIDIA recovery has one shared two-call/deadline budget. Explicit
+// server refusals retry the original request; rejected Super tool encoding
+// retries JSON content on the same configured route. The shared router owns
+// its own admission budget and MUST NOT receive this wrapper. No model
+// substitution or repair/coercion of a rejected decision is allowed.
 class SameModelRetryProvider {
     delegate;
     provider;
     model;
+    contentRetry;
+    baseUrl;
     label;
-    constructor(delegate, provider, model) {
+    constructor(delegate, provider, model, contentRetry, baseUrl) {
         this.delegate = delegate;
         this.provider = provider;
         this.model = model;
+        this.contentRetry = contentRetry;
+        this.baseUrl = baseUrl;
         this.label = delegate.label;
     }
     async decide(input) {
@@ -324,56 +424,99 @@ class SameModelRetryProvider {
         const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         const first = await this.delegate.decide(input);
         const firstFinished = Date.now();
-        if (first.ok || !first.retryableHttpFailure) {
+        const parsedFirst = first.ok
+            ? parseDecisionForContract(first.text, input.decisionContract)
+            : undefined;
+        const retryContent = first.ok &&
+            parsedFirst?.ok === false &&
+            this.contentRetry !== undefined &&
+            canRetrySuperToolOutput({ provider: this.provider, model: this.model, baseUrl: this.baseUrl }, first.responseSource, parsedFirst.actionsStringDiagnostic);
+        if (!retryContent && (first.ok || !first.retryableHttpFailure)) {
             return first;
         }
-        const delayMs = Math.max(1000, first.retryAfterMs ?? 0);
+        const delayMs = retryContent
+            ? 0
+            : Math.max(1000, first.ok ? 0 : (first.retryAfterMs ?? 0));
         // Honor the provider's cooldown; a long one waits for the next cycle. Both
         // attempts and this backoff share the ORIGINAL deadline, never two 5m caps.
         if (delayMs > 5000 || delayMs >= timeoutMs - (firstFinished - started)) {
             return first;
         }
-        await new Promise((resolve) => setTimeout(resolve, delayMs));
+        if (delayMs > 0)
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
         const retryStarted = Date.now();
         const remainingMs = timeoutMs - (retryStarted - started);
         if (remainingMs <= 0)
             return first;
-        const result = await this.delegate.decide({
+        const retryResult = await (retryContent ? this.contentRetry : this.delegate).decide({
             ...input,
             timeoutMs: remainingMs,
         });
-        const attempt = (res, latencyMs) => ({
-            provider: this.provider,
-            model: this.model,
-            outcome: res.ok ? "success" : "failed",
-            latencyMs,
-            ...(!res.ok
-                ? {
-                    error: res.error,
-                    status: res.status,
-                    retryAfterMs: res.retryAfterMs,
-                    failureClass: classifyProviderFailure(res) === "capacity"
-                        ? "capacity"
-                        : res.status !== undefined && res.status < 500
-                            ? "permanent"
-                            : "transient",
-                }
-                : {}),
-        });
+        const parsedRetry = retryResult.ok
+            ? parseDecisionForContract(retryResult.text, input.decisionContract)
+            : undefined;
+        const result = retryResult.ok && parsedRetry?.ok === false
+            ? {
+                ok: false,
+                failureClass: "malformed",
+                error: parsedRetry.error,
+                usage: retryResult.usage,
+            }
+            : retryResult;
+        const attempt = (res, latencyMs) => {
+            const parsed = res.ok
+                ? parseDecisionForContract(res.text, input.decisionContract)
+                : undefined;
+            return {
+                provider: this.provider,
+                model: this.model,
+                outcome: res.ok && parsed?.ok ? "success" : "failed",
+                latencyMs,
+                ...(res.ok ? { responseSource: res.responseSource } : {}),
+                ...(parsed?.ok === false
+                    ? {
+                        failureClass: "malformed",
+                        error: parsed.error,
+                        actionsStringDiagnostic: parsed.actionsStringDiagnostic,
+                    }
+                    : {}),
+                ...(!res.ok
+                    ? {
+                        error: res.error,
+                        status: res.status,
+                        retryAfterMs: res.retryAfterMs,
+                        failureClass: res.failureClass ??
+                            (classifyProviderFailure(res) === "capacity"
+                                ? "capacity"
+                                : res.status !== undefined && res.status < 500
+                                    ? "permanent"
+                                    : "transient"),
+                    }
+                    : {}),
+            };
+        };
+        // Sum reported usage from both physical calls, including rejected output.
+        // Missing usage is unknown, not evidence that a request consumed no tokens.
+        const usage = first.usage || result.usage
+            ? {
+                promptTokens: (first.usage?.promptTokens ?? 0) +
+                    (result.usage?.promptTokens ?? 0),
+                completionTokens: (first.usage?.completionTokens ?? 0) +
+                    (result.usage?.completionTokens ?? 0),
+            }
+            : undefined;
         return {
-            // Usage, when present, describes only the final response. The preceding
-            // 5xx did not report usage; attempt evidence is not total billed tokens
-            // or a certificate that returned text passed the trading-decision parser.
             ...result,
+            ...(usage ? { usage } : {}),
             route: {
-                policyVersion: "coinrithm.configured-same-model-retry.v2",
+                policyVersion: "coinrithm.configured-same-model-retry.v3",
                 profile: "configured",
                 effectiveProvider: this.provider,
                 effectiveModel: this.model,
                 reason: "configured_direct",
                 attempts: [
                     attempt(first, firstFinished - started),
-                    attempt(result, Date.now() - retryStarted),
+                    attempt(retryResult, Date.now() - retryStarted),
                 ],
             },
         };
@@ -382,7 +525,7 @@ class SameModelRetryProvider {
 // Build the provider from the spec's model block + env key. Throws a clear
 // error if no model is configured (self-host requires one) or the env key is
 // missing. fetch is injectable for tests.
-export function selectProvider(spec, env, fetchFn = fetch) {
+export function selectProvider(spec, env, fetchFn = fetch, options = {}) {
     if (!spec.model) {
         throw new Error("no model configured: set model.provider + model.name in the agent (self-host needs an explicit model)");
     }
@@ -411,15 +554,17 @@ export function selectProvider(spec, env, fetchFn = fetch) {
     if (!resolvedBase) {
         throw new Error("openai-compatible provider needs model.baseUrl");
     }
-    const direct = new OpenAiCompatProvider(provider, name, key, resolvedBase, fetchFn);
+    const direct = new OpenAiCompatProvider(provider, name, key, resolvedBase, fetchFn, options);
     return provider === "nvidia"
-        ? new SameModelRetryProvider(direct, provider, name)
+        ? new SameModelRetryProvider(direct, provider, name, new OpenAiCompatProvider(provider, name, key, resolvedBase, fetchFn, {
+            nemotronJsonContent: true,
+        }), baseUrl)
         : direct;
 }
 // Build a provider for an EXPLICIT route + raw key (no spec, no env) — the
 // decision probe's entry point. Same classes as selectProvider, so a probe
 // exercises byte-identical request shapes to a real cycle.
-export function providerForRoute(route, apiKey, fetchFn = fetch) {
+export function providerForRoute(route, apiKey, fetchFn = fetch, options = {}) {
     if (route.provider === "mechanical")
         return new MechanicalProvider(route.model);
     if (route.provider === "anthropic")
@@ -428,5 +573,5 @@ export function providerForRoute(route, apiKey, fetchFn = fetch) {
     if (!resolvedBase) {
         throw new Error("openai-compatible route needs a baseUrl");
     }
-    return new OpenAiCompatProvider(route.provider, route.model, apiKey, resolvedBase, fetchFn);
+    return new OpenAiCompatProvider(route.provider, route.model, apiKey, resolvedBase, fetchFn, options);
 }

package/dist/agent/resolve.js

@@ -43,6 +43,9 @@ const CONFIG_BLOCKS = [
     "killSwitch",
     "objective",
     "capabilities",
+    "signals",
+    "data",
+    "universe",
 ];
 const JOURNAL_MAX_LINES = 200;
 const JOURNAL_MAX_BYTES = 8_000;

package/dist/agent/runner.d.ts

@@ -1,6 +1,7 @@
 import { CoinRithmClient, ProvenanceReport } from "./client.js";
 import { Provider } from "./providers.js";
-import { AgentSpec, RunState, CycleResult, Decision, ProposedAction, PmMarket, PostedOpportunity, QuoteEvidence } from "./types.js";
+import { AgentSpec, RunState, CycleResult, Decision, PlannedAction, ProposedAction, PmMarket, PostedOpportunity, QuoteEvidence, LastRejection, TakeProfitRepair } from "./types.js";
+import { type ObserveOptions } from "./observe.js";
 import { type DecisionInputRecord } from "./decisionReceipt.js";
 export interface RunnerDeps {
     client: CoinRithmClient;
@@ -13,6 +14,13 @@ export interface RunnerDeps {
     log?: (line: string) => void;
     /** Optional private storage hook. Its failure never changes cycle execution. */
     onDecisionInputRecord?: (record: DecisionInputRecord) => void;
+    /** Hosted shared-pool admission only; protective checks still run every cycle. */
+    minModelIntervalSeconds?: number;
+    /** Opt-in hosted canary; changes presentation only, preserving all values. */
+    compactPromptTables?: boolean;
+    /** Bench replay only (bench.ts): observation overrides. Live runs never
+     *  set it. */
+    observeOptions?: ObserveOptions;
 }
 export declare function houseAgentForecastEnabled(): boolean;
 export declare function agentOpportunityCaptureEnabled(): boolean;
@@ -22,7 +30,15 @@ export declare function sanitizeForecastProbability(raw: unknown): number | unde
 export declare function repairFuturesTakeProfit(action: ProposedAction, quote?: QuoteEvidence, capitalMinimumRewardRisk?: number): {
     action: ProposedAction;
     repaired: boolean;
+    reason?: TakeProfitRepair["reason"];
 };
+export declare const LAST_REJECTIONS_MAX = 5;
+/**
+ * Pure: the rejected actions of one validated decision, newest decision only,
+ * for the next prompt. Undefined when nothing was rejected, so a fixed
+ * mistake drops out at once.
+ */
+export declare function lastRejectionsOf(planned: readonly PlannedAction[], at: string): LastRejection[] | undefined;
 export declare function rationaleForAction(a: ProposedAction, decisionRationale: string | undefined, perActionSummary: string | undefined, totalActions: number): string | undefined;
 export declare function buildSkipOpportunity(decision: Decision, pmMarkets: PmMarket[], forecastEnabled: boolean): PostedOpportunity | null;
 export declare function runCycle(deps: RunnerDeps): Promise<CycleResult>;