@coinrithm/mcp-trading 0.7.6 → 0.7.8

package/dist/agent/providerCapabilities.js

@@ -0,0 +1,105 @@
+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";
+// 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;
+export function chatShapeFor(provider, model, baseUrl) {
+    if (provider === "anthropic") {
+        return {
+            family: "anthropic",
+            tokenParam: "max_tokens",
+            allowsTemperature: true,
+            jsonResponseFormat: false,
+            minProbeCompletionTokens: 1024,
+        };
+    }
+    if (provider === "openai" || OPENAI_REASONING_MODEL.test(model)) {
+        return {
+            family: "openai-reasoning",
+            tokenParam: "max_completion_tokens",
+            allowsTemperature: false,
+            jsonResponseFormat: true,
+            minProbeCompletionTokens: 1024,
+        };
+    }
+    if (NEMOTRON_MODEL.test(model)) {
+        const isNvidiaEndpoint = baseUrl === NVIDIA_BASE_URL;
+        return {
+            family: "nvidia-nemotron",
+            tokenParam: "max_tokens",
+            allowsTemperature: true,
+            jsonResponseFormat: true,
+            jsonSchema: isNvidiaEndpoint
+                ? DECISION_JSON_SCHEMA
+                : undefined,
+            // integrate.api.nvidia.com currently ignores both response_format
+            // json_schema and guided_json for these hosted models. Its forced tool
+            // call path is the live-probed contract-enforcing transport.
+            jsonSchemaTransport: isNvidiaEndpoint ? "tool_call" : undefined,
+            // The kwargs switch is only honored (and only safe to send) on the NVIDIA
+            // endpoint; the system hint helps on any endpoint serving a Nemotron.
+            extraBody: isNvidiaEndpoint
+                ? { chat_template_kwargs: { enable_thinking: false } }
+                : undefined,
+            systemHint: "detailed thinking off",
+            minProbeCompletionTokens: 1024,
+        };
+    }
+    return {
+        family: "openai-compat",
+        tokenParam: "max_tokens",
+        allowsTemperature: true,
+        jsonResponseFormat: true,
+        minProbeCompletionTokens: 1024,
+    };
+}
+/** Build the chat-completions body for a route from its capability shape. */
+export function buildChatBody(shape, args) {
+    const system = shape.systemHint
+        ? `${shape.systemHint}\n\n${args.system}`
+        : args.system;
+    return {
+        model: args.model,
+        ...(shape.allowsTemperature
+            ? { temperature: args.temperature ?? 0.2 }
+            : {}),
+        [shape.tokenParam]: args.maxTokens,
+        ...(shape.jsonSchema && shape.jsonSchemaTransport === "tool_call"
+            ? {
+                tools: [
+                    {
+                        type: "function",
+                        function: {
+                            name: DECISION_TOOL_NAME,
+                            description: "Submit the complete CoinRithm paper-trading decision for this cycle.",
+                            parameters: shape.jsonSchema,
+                        },
+                    },
+                ],
+                tool_choice: {
+                    type: "function",
+                    function: { name: DECISION_TOOL_NAME },
+                },
+            }
+            : {}),
+        ...(shape.jsonResponseFormat && shape.jsonSchemaTransport !== "tool_call"
+            ? {
+                response_format: shape.jsonSchema
+                    ? {
+                        type: "json_schema",
+                        json_schema: {
+                            name: "coinrithm_trading_decision",
+                            schema: shape.jsonSchema,
+                        },
+                    }
+                    : { type: "json_object" },
+            }
+            : {}),
+        ...(shape.extraBody ?? {}),
+        messages: [
+            { role: "system", content: system },
+            { role: "user", content: args.user },
+        ],
+    };
+}

package/dist/agent/providers.d.ts

@@ -1,10 +1,28 @@
-import { AgentSpec } from "./types.js";
+import { AgentSpec, ProviderName } from "./types.js";
 export interface DecideInput {
     system: string;
     user: string;
     maxTokens?: number;
     timeoutMs?: number;
 }
+export interface DecideRouteAttempt {
+    provider: string;
+    model: string;
+    outcome: "success" | "failed" | "deferred";
+    failureClass?: "capacity" | "permanent" | "transient" | "malformed";
+    status?: number;
+    retryAfterMs?: number;
+    latencyMs: number;
+    error?: string;
+}
+export interface DecideRouteMeta {
+    policyVersion: string;
+    profile: "fast" | "strong" | "configured";
+    effectiveProvider?: string;
+    effectiveModel?: string;
+    reason: "configured" | "circuit_fallback" | "capacity_fallback" | "provider_fallback" | "malformed_fallback" | "byo";
+    attempts: DecideRouteAttempt[];
+}
 export type DecideResult = {
     ok: true;
     text: string;
@@ -12,9 +30,14 @@ export type DecideResult = {
         promptTokens: number;
         completionTokens: number;
     };
+    route?: DecideRouteMeta;
 } | {
     ok: false;
     error: string;
+    status?: number;
+    retryAfterMs?: number;
+    deferred?: boolean;
+    route?: DecideRouteMeta;
 };
 export interface Provider {
     label: string;
@@ -29,3 +52,8 @@ export interface ProviderEnv {
     MODEL_API_KEY?: string;
 }
 export declare function selectProvider(spec: AgentSpec, env: ProviderEnv, fetchFn?: typeof fetch): Provider;
+export declare function providerForRoute(route: {
+    provider: ProviderName;
+    model: string;
+    baseUrl?: string | null;
+}, apiKey: string, fetchFn?: typeof fetch): Provider;

package/dist/agent/providers.js

@@ -2,9 +2,10 @@
 // never from an agent file. One call returns one chunk of text that must be a
 // single structured-JSON decision (parsed in decision.ts). No free-form tool
 // execution — the model only proposes; the runner disposes.
+import { chatShapeFor, buildChatBody, DECISION_TOOL_NAME, NVIDIA_BASE_URL as CAP_NVIDIA_BASE_URL, } from "./providerCapabilities.js";
 // 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 = "https://integrate.api.nvidia.com/v1";
+const NVIDIA_BASE_URL = CAP_NVIDIA_BASE_URL;
 // Gemini exposes an OpenAI-compatible surface, so the `gemini` preset hard-wires
 // its hosted endpoint — an agent only needs `{ provider: gemini, name: "gemini-2.0-flash" }`
 // plus a GEMINI_API_KEY. The free tier (no credit card, generous Flash quota) makes
@@ -26,23 +27,26 @@ const GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai
 // (the recurring Leo/70B timeout). A real hang still aborts -> retried next cadence.
 // MUST stay below the scheduler's RUN_LOCK_SECONDS and HEARTBEAT_STALE_MS.
 const DEFAULT_TIMEOUT_MS = 300_000;
-// Reasoning models (NVIDIA Nemotron) DEFAULT to emitting a long <think> chain:
-// measured ~30-60s/call and a JSON-leak risk. The documented toggle is a
-// "detailed thinking off" line in the system prompt, which drops them to
-// instruct mode (measured ~3-4s, clean JSON). Apply it automatically for any
-// nemotron model so a per-cadence decision never blows the cadence.
-function applyReasoningToggle(model, system) {
-    return /nemotron/i.test(model)
-        ? `detailed thinking off\n\n${system}`
-        : system;
-}
-// fetch with a hard timeout via AbortController. A custom fetchFn (tests) that
-// ignores `signal` still works — the timer just never fires for it.
-async function fetchWithTimeout(fetchFn, url, init, timeoutMs) {
+// Per-route request quirks (reasoning toggles, token param, temperature) live
+// in the capability table — providerCapabilities.ts is the single source; this
+// module only assembles and sends.
+// One deadline covers both headers AND response-body consumption. fetch resolves
+// at headers, so clearing a fetch-only timer there leaves text/json unbounded.
+// Abort native I/O and race the deadline as well: an injected implementation that
+// ignores AbortSignal must still release the caller rather than its run lock.
+async function withProviderTimeout(timeoutMs, operation) {
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let timer;
+    const deadline = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => {
+            reject(Object.assign(new Error("model deadline exceeded"), {
+                name: "AbortError",
+            }));
+            controller.abort();
+        }, timeoutMs);
+    });
     try {
-        return await fetchFn(url, { ...init, signal: controller.signal });
+        return await Promise.race([operation(controller.signal), deadline]);
     }
     finally {
         clearTimeout(timer);
@@ -54,6 +58,23 @@ function callError(err, timeoutMs) {
     }
     return err instanceof Error ? err.message : String(err);
 }
+// Parse a Retry-After header (delta-seconds or HTTP-date) into ms, capped at
+// one hour — a provider asking for more is treated as "an hour, then re-probe".
+const RETRY_AFTER_CAP_MS = 3_600_000;
+function retryAfterMs(res) {
+    const raw = res.headers.get("retry-after");
+    if (!raw)
+        return undefined;
+    const secs = Number(raw);
+    if (Number.isFinite(secs) && secs >= 0) {
+        return Math.min(Math.round(secs * 1000), RETRY_AFTER_CAP_MS);
+    }
+    const at = Date.parse(raw);
+    if (!Number.isFinite(at))
+        return undefined;
+    const ms = at - Date.now();
+    return ms > 0 ? Math.min(ms, RETRY_AFTER_CAP_MS) : 0;
+}
 function envKey(provider, env) {
     switch (provider) {
         case "anthropic":
@@ -120,52 +141,73 @@ class AnthropicProvider {
     }
     async decide(input) {
         const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        let failureResponse;
         try {
-            const res = await fetchWithTimeout(this.fetchFn, "https://api.anthropic.com/v1/messages", {
-                method: "POST",
-                headers: {
-                    "x-api-key": this.apiKey,
-                    "anthropic-version": "2023-06-01",
-                    "content-type": "application/json",
-                },
-                body: JSON.stringify({
-                    model: this.model,
-                    max_tokens: input.maxTokens ?? 1024,
-                    system: input.system,
-                    messages: [{ role: "user", content: input.user }],
-                }),
-            }, timeoutMs);
-            if (!res.ok)
-                return {
-                    ok: false,
-                    // Cap the upstream body: it lands in agent_cycles.skip_reason, so an
-                    // unbounded provider error page must not bloat the ledger row.
-                    error: `anthropic HTTP ${res.status}: ${(await res.text()).slice(0, 2000)}`,
-                };
-            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,
+            return await withProviderTimeout(timeoutMs, async (signal) => {
+                const res = await this.fetchFn("https://api.anthropic.com/v1/messages", {
+                    method: "POST",
+                    signal,
+                    headers: {
+                        "x-api-key": this.apiKey,
+                        "anthropic-version": "2023-06-01",
+                        "content-type": "application/json",
+                    },
+                    body: JSON.stringify({
+                        model: this.model,
+                        max_tokens: input.maxTokens ?? 1024,
+                        system: input.system,
+                        messages: [{ role: "user", content: input.user }],
+                    }),
+                });
+                if (!res.ok) {
+                    failureResponse = res;
+                    return {
+                        ok: false,
+                        // Cap the upstream body: it lands in agent_cycles.skip_reason, so an
+                        // unbounded provider error page must not bloat the ledger row.
+                        error: `anthropic HTTP ${res.status}: ${(await res.text()).slice(0, 2000)}`,
+                        status: res.status,
+                        retryAfterMs: retryAfterMs(res),
+                    };
                 }
-                : undefined;
-            return text
-                ? { ok: true, text, usage }
-                : { ok: false, error: "anthropic returned empty content" };
+                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;
+                return text
+                    ? { ok: true, text, usage }
+                    : { ok: false, error: "anthropic returned empty content" };
+            });
         }
         catch (err) {
-            return { ok: false, error: callError(err, timeoutMs) };
+            return {
+                ok: false,
+                error: failureResponse
+                    ? `anthropic HTTP ${failureResponse.status}: ${callError(err, timeoutMs)}`
+                    : callError(err, timeoutMs),
+                ...(failureResponse
+                    ? {
+                        status: failureResponse.status,
+                        retryAfterMs: retryAfterMs(failureResponse),
+                    }
+                    : {}),
+            };
         }
     }
 }
 class OpenAiCompatProvider {
+    provider;
     model;
     apiKey;
     baseUrl;
     fetchFn;
     label;
-    constructor(model, apiKey, baseUrl, fetchFn) {
+    constructor(provider, model, apiKey, baseUrl, fetchFn) {
+        this.provider = provider;
         this.model = model;
         this.apiKey = apiKey;
         this.baseUrl = baseUrl;
@@ -174,48 +216,63 @@ class OpenAiCompatProvider {
     }
     async decide(input) {
         const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const shape = chatShapeFor(this.provider, this.model, this.baseUrl);
+        let failureResponse;
         try {
-            const res = await fetchWithTimeout(this.fetchFn, `${this.baseUrl}/chat/completions`, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${this.apiKey}`,
-                    "content-type": "application/json",
-                },
-                body: JSON.stringify({
-                    model: this.model,
-                    temperature: 0.2,
-                    max_tokens: input.maxTokens ?? 1024,
-                    response_format: { type: "json_object" },
-                    messages: [
-                        {
-                            role: "system",
-                            content: applyReasoningToggle(this.model, input.system),
-                        },
-                        { role: "user", content: input.user },
-                    ],
-                }),
-            }, timeoutMs);
-            if (!res.ok)
-                return {
-                    ok: false,
-                    // Cap the upstream body: it lands in agent_cycles.skip_reason, so an
-                    // unbounded provider error page must not bloat the ledger row.
-                    error: `provider HTTP ${res.status}: ${(await res.text()).slice(0, 2000)}`,
-                };
-            const json = (await res.json());
-            const text = json.choices?.[0]?.message?.content ?? "";
-            const usage = json.usage
-                ? {
-                    promptTokens: json.usage.prompt_tokens ?? 0,
-                    completionTokens: json.usage.completion_tokens ?? 0,
+            return await withProviderTimeout(timeoutMs, async (signal) => {
+                const res = await this.fetchFn(`${this.baseUrl}/chat/completions`, {
+                    method: "POST",
+                    signal,
+                    headers: {
+                        Authorization: `Bearer ${this.apiKey}`,
+                        "content-type": "application/json",
+                    },
+                    body: JSON.stringify(buildChatBody(shape, {
+                        model: this.model,
+                        system: input.system,
+                        user: input.user,
+                        maxTokens: input.maxTokens ?? 1024,
+                    })),
+                });
+                if (!res.ok) {
+                    failureResponse = res;
+                    return {
+                        ok: false,
+                        // Cap the upstream body: it lands in agent_cycles.skip_reason, so an
+                        // unbounded provider error page must not bloat the ledger row.
+                        error: `provider HTTP ${res.status}: ${(await res.text()).slice(0, 2000)}`,
+                        status: res.status,
+                        retryAfterMs: retryAfterMs(res),
+                    };
                 }
-                : undefined;
-            return text
-                ? { ok: true, text, usage }
-                : { ok: false, error: "provider returned empty content" };
+                const json = (await res.json());
+                const message = json.choices?.[0]?.message;
+                const decisionArguments = message?.tool_calls?.find((call) => call.function?.name === DECISION_TOOL_NAME)?.function?.arguments;
+                const text = decisionArguments ?? message?.content ?? "";
+                const usage = json.usage
+                    ? {
+                        promptTokens: json.usage.prompt_tokens ?? 0,
+                        completionTokens: json.usage.completion_tokens ?? 0,
+                    }
+                    : undefined;
+                return text
+                    ? { ok: true, text, usage }
+                    : { ok: false, error: "provider returned empty content" };
+            });
         }
         catch (err) {
-            return { ok: false, error: callError(err, timeoutMs) };
+            return {
+                ok: false,
+                error: failureResponse
+                    ? `provider HTTP ${failureResponse.status}: ${callError(err, timeoutMs)}`
+                    : callError(err, timeoutMs),
+                ...(failureResponse
+                    ? {
+                        status: failureResponse.status,
+                        retryAfterMs: retryAfterMs(failureResponse),
+                    }
+                    : {}),
+            };
         }
     }
 }
@@ -251,5 +308,19 @@ export function selectProvider(spec, env, fetchFn = fetch) {
     if (!resolvedBase) {
         throw new Error("openai-compatible provider needs model.baseUrl");
     }
-    return new OpenAiCompatProvider(name, key, resolvedBase, fetchFn);
+    return new OpenAiCompatProvider(provider, name, key, resolvedBase, fetchFn);
+}
+// 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) {
+    if (route.provider === "mechanical")
+        return new MechanicalProvider(route.model);
+    if (route.provider === "anthropic")
+        return new AnthropicProvider(route.model, apiKey, fetchFn);
+    const resolvedBase = baseUrlFor(route.provider, route.baseUrl ?? undefined);
+    if (!resolvedBase) {
+        throw new Error("openai-compatible route needs a baseUrl");
+    }
+    return new OpenAiCompatProvider(route.provider, route.model, apiKey, resolvedBase, fetchFn);
 }

package/dist/agent/resolve.d.ts

@@ -14,7 +14,7 @@ export declare function mergeProseParts(parts: Array<{
     text: string;
 }>): string;
 export declare function resolveAgent(inputPath: string): ResolvedAgent;
-export declare const HOSTED_PROSE_MAX_CHARS = 8000;
+export declare const HOSTED_PROSE_MAX_CHARS = 12000;
 /** PURE — exported for tests. Mirrors the backend's trim-then-measure. */
 export declare const hostedProseBudget: (mergedProse: string) => {
     used: number;

package/dist/agent/resolve.js

@@ -36,6 +36,7 @@ const CONFIG_BLOCKS = [
     "venues",
     "risk",
     "sizing",
+    "capitalSizing",
     "limits",
     "abstention",
     "sync",
@@ -592,7 +593,26 @@ export function resolveAgent(inputPath) {
 // tokens / 413s per cycle. Mirrored here (backend-v2
 // controllers/agentManage.ts sanitizeStrategyProse) so `validate --hosted`
 // can catch it before a user does.
-export const HOSTED_PROSE_MAX_CHARS = 8000;
+//
+// RAISED 8,000 -> 12,000 on 2026-08-21, from measurement rather than feel.
+// 8,000 made the product's core promise impossible: forking a house template
+// starts you at 7,967 (Olivia) / 7,931 (Carl) / 7,839 (Mia), so a user had
+// 33 to 161 characters to write their own rules in. "Fork a template and make
+// it yours" could not be done.
+//
+// The cap was justified by hosted inference cost. Measured over 8,060 LLM
+// cycles in 24h on prod: average input is 9,038 tokens, of which the prose is
+// only 12.6-40.2% (median ~25%) — the OBSERVATION is the other ~75%. Inputs
+// already reached 17,065 tokens on Llama 3.1 8B and 16,437 on Nemotron 49B
+// (measured on the since-retired NIM line; Nemotron 3 successors match), with
+// ZERO rate-limit errors and estimated_cost_usd of 0.0000 (free NIM tier).
+// +4,000 characters is ~+1,000 tokens/cycle (+11%), landing average input near
+// 10,038 — still below what the fleet already handles at peak today.
+//
+// Self-host is deliberately NOT capped (runner.ts/prompt.ts enforce nothing):
+// those agents run on the user's own model key, so their prompt size costs us
+// nothing. This limit exists only where WE pay for the inference.
+export const HOSTED_PROSE_MAX_CHARS = 12000;
 /** PURE — exported for tests. Mirrors the backend's trim-then-measure. */
 export const hostedProseBudget = (mergedProse) => {
     const used = mergedProse.replace(/\r\n/g, "\n").trim().length;

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 { type DecisionInputRecord } from "./decisionReceipt.js";
 export interface RunnerDeps {
     client: CoinRithmClient;
     provider: Provider;
@@ -10,13 +11,15 @@ export interface RunnerDeps {
     live: boolean;
     stateFile?: string;
     log?: (line: string) => void;
+    /** Optional private storage hook. Its failure never changes cycle execution. */
+    onDecisionInputRecord?: (record: DecisionInputRecord) => void;
 }
 export declare function houseAgentForecastEnabled(): boolean;
 export declare function agentOpportunityCaptureEnabled(): boolean;
 export declare function runnerRuntimeKind(): ProvenanceReport["runtimeKind"];
 export declare function buildRunnerProvenance(spec: AgentSpec): ProvenanceReport;
 export declare function sanitizeForecastProbability(raw: unknown): number | undefined;
-export declare function repairFuturesTakeProfit(action: ProposedAction, quote?: QuoteEvidence): {
+export declare function repairFuturesTakeProfit(action: ProposedAction, quote?: QuoteEvidence, capitalMinimumRewardRisk?: number): {
     action: ProposedAction;
     repaired: boolean;
 };