@coinrithm/mcp-trading 0.7.7 → 0.7.9

package/dist/agent/providers.js

@@ -2,7 +2,8 @@
 // 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, NVIDIA_BASE_URL as CAP_NVIDIA_BASE_URL, } from "./providerCapabilities.js";
+import { retryAfterSeconds } from "../retryAfter.js";
+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 = CAP_NVIDIA_BASE_URL;
@@ -27,16 +28,27 @@ 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;
+const RETRYABLE_SERVER_STATUSES = new Set([500, 502, 503, 504]);
 // 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.
-// 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) {
+// 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);
@@ -48,22 +60,24 @@ function callError(err, timeoutMs) {
     }
     return err instanceof Error ? err.message : String(err);
 }
+// Error text reaches retained cycle evidence. Redact before truncating so a
+// credential crossing the size boundary cannot leave a partial key behind.
+function safeProviderError(text, apiKey) {
+    return (apiKey ? text.split(apiKey).join("[redacted]") : text)
+        .replace(/Bearer\s+[^\s"'<>\\]+/gi, "Bearer [redacted]")
+        .replace(/(?:nvapi-|crk_live_|sk-|sk_live_|ghp_|AIza)[A-Za-z0-9_-]+/g, "[redacted]")
+        .replace(/eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, "[redacted]")
+        .replace(/((?:api[_-]?key|access[_-]?token|password|secret)["']?\s*[:=]\s*["']?)[^\s"',}&<>]+/gi, "$1[redacted]")
+        .slice(0, 2000);
+}
 // 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;
+    const seconds = retryAfterSeconds(res.headers.get("retry-after"));
+    return seconds === undefined
+        ? undefined
+        : Math.min(Math.round(seconds * 1000), RETRY_AFTER_CAP_MS);
 }
 function envKey(provider, env) {
     switch (provider) {
@@ -131,44 +145,61 @@ 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)}`,
-                    status: res.status,
-                    retryAfterMs: retryAfterMs(res),
-                };
-            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}: ${safeProviderError(await res.text(), this.apiKey)}`,
+                        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: safeProviderError(failureResponse
+                    ? `anthropic HTTP ${failureResponse.status}: ${callError(err, timeoutMs)}`
+                    : callError(err, timeoutMs), this.apiKey),
+                ...(failureResponse
+                    ? {
+                        status: failureResponse.status,
+                        retryAfterMs: retryAfterMs(failureResponse),
+                    }
+                    : {}),
+            };
         }
     }
 }
@@ -190,46 +221,148 @@ 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(buildChatBody(shape, {
-                    model: this.model,
-                    system: input.system,
-                    user: input.user,
-                    maxTokens: input.maxTokens ?? 1024,
-                })),
-            }, 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)}`,
-                    status: res.status,
-                    retryAfterMs: retryAfterMs(res),
-                };
-            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}: ${safeProviderError(await res.text(), this.apiKey)}`,
+                        status: res.status,
+                        retryAfterMs: retryAfterMs(res),
+                        ...(RETRYABLE_SERVER_STATUSES.has(res.status)
+                            ? { retryableHttpFailure: true }
+                            : {}),
+                    };
                 }
-                : 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: safeProviderError(failureResponse
+                    ? `provider HTTP ${failureResponse.status}: ${callError(err, timeoutMs)}`
+                    : callError(err, timeoutMs), this.apiKey),
+                ...(failureResponse
+                    ? {
+                        status: failureResponse.status,
+                        retryAfterMs: retryAfterMs(failureResponse),
+                    }
+                    : {}),
+            };
         }
     }
 }
+// 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.
+class SameModelRetryProvider {
+    delegate;
+    provider;
+    model;
+    label;
+    constructor(delegate, provider, model) {
+        this.delegate = delegate;
+        this.provider = provider;
+        this.model = model;
+        this.label = delegate.label;
+    }
+    async decide(input) {
+        const started = Date.now();
+        const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const first = await this.delegate.decide(input);
+        const firstFinished = Date.now();
+        if (first.ok || !first.retryableHttpFailure) {
+            return first;
+        }
+        const delayMs = Math.max(1000, 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));
+        const retryStarted = Date.now();
+        const remainingMs = timeoutMs - (retryStarted - started);
+        if (remainingMs <= 0)
+            return first;
+        const result = await 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,
+                    ...(res.status !== undefined
+                        ? {
+                            failureClass: res.status === 429
+                                ? "capacity"
+                                : res.status >= 500
+                                    ? "transient"
+                                    : "permanent",
+                        }
+                        : {}),
+                }
+                : {}),
+        });
+        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,
+            route: {
+                policyVersion: "coinrithm.configured-same-model-retry.v1",
+                profile: "configured",
+                effectiveProvider: this.provider,
+                effectiveModel: this.model,
+                reason: "configured_direct",
+                attempts: [
+                    attempt(first, firstFinished - started),
+                    attempt(result, Date.now() - retryStarted),
+                ],
+            },
+        };
+    }
+}
 // 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.
@@ -262,7 +395,10 @@ export function selectProvider(spec, env, fetchFn = fetch) {
     if (!resolvedBase) {
         throw new Error("openai-compatible provider needs model.baseUrl");
     }
-    return new OpenAiCompatProvider(provider, name, key, resolvedBase, fetchFn);
+    const direct = new OpenAiCompatProvider(provider, name, key, resolvedBase, fetchFn);
+    return provider === "nvidia"
+        ? new SameModelRetryProvider(direct, provider, name)
+        : 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

package/dist/agent/resolve.js

@@ -36,6 +36,7 @@ const CONFIG_BLOCKS = [
     "venues",
     "risk",
     "sizing",
+    "capitalSizing",
     "limits",
     "abstention",
     "sync",

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;
 };