@coinrithm/mcp-trading 0.3.0 → 0.5.0

package/dist/agent/providers.js

@@ -5,6 +5,53 @@
 // 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";
+// 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
+// it the easiest key a USER can bring for their OWN agent — and a per-user key means
+// each agent draws on its own quota, which is how the fleet actually scales.
+const GEMINI_BASE_URL = "https://generativelanguage.googleapis.com/v1beta/openai";
+// Cap any single model call so a hung provider can't block an agent forever — but
+// generously. The scheduler runs cycles SEQUENTIALLY per agent (it locks the row
+// while a cycle runs and schedules the next from COMPLETION, not from claim), so a
+// slow call no longer overlaps the next cadence; it just delays it. That lets the
+// cap be long enough for a large model (e.g. a 70B on a busy free key) to finish
+// and ACT, instead of being killed mid-thought and counted as a failure. On a real
+// timeout the call still aborts -> a model failure -> retried next cadence (and the
+// disable threshold is now far more tolerant of the odd flaky cycle).
+// 5 minutes. Sequential scheduling (the scheduler RUN-LOCKS an agent while a cycle
+// runs and reschedules the NEXT from completion) means a slow call never overlaps
+// the next cadence — it just delays it. So a generous timeout lets a busy free 70B
+// finish and ACT instead of being killed mid-thought and counted as a failure
+// (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) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetchFn(url, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function callError(err, timeoutMs) {
+    if (err instanceof Error && err.name === "AbortError") {
+        return `model call timed out after ${timeoutMs}ms`;
+    }
+    return err instanceof Error ? err.message : String(err);
+}
 function envKey(provider, env) {
     switch (provider) {
         case "anthropic":
@@ -15,6 +62,8 @@ function envKey(provider, env) {
             return env.GROQ_API_KEY;
         case "nvidia":
             return env.NVIDIA_API_KEY ?? env.MODEL_API_KEY;
+        case "gemini":
+            return env.GEMINI_API_KEY ?? env.MODEL_API_KEY;
         case "openai-compatible":
             return env.MODEL_API_KEY ?? env.OPENAI_API_KEY;
     }
@@ -27,6 +76,8 @@ function baseUrlFor(provider, configured) {
             return "https://api.groq.com/openai/v1";
         case "nvidia":
             return NVIDIA_BASE_URL;
+        case "gemini":
+            return GEMINI_BASE_URL;
         case "openai-compatible":
             return (configured ?? "").replace(/\/+$/, "");
         case "anthropic":
@@ -45,8 +96,9 @@ class AnthropicProvider {
         this.label = `anthropic/${model}`;
     }
     async decide(input) {
+        const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         try {
-            const res = await this.fetchFn("https://api.anthropic.com/v1/messages", {
+            const res = await fetchWithTimeout(this.fetchFn, "https://api.anthropic.com/v1/messages", {
                 method: "POST",
                 headers: {
                     "x-api-key": this.apiKey,
@@ -59,15 +111,26 @@ class AnthropicProvider {
                     system: input.system,
                     messages: [{ role: "user", content: input.user }],
                 }),
-            });
+            }, timeoutMs);
             if (!res.ok)
-                return { ok: false, error: `anthropic HTTP ${res.status}: ${await res.text()}` };
+                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("") ?? "";
-            return text ? { ok: true, text } : { ok: false, error: "anthropic returned empty content" };
+            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: err instanceof Error ? err.message : String(err) };
+            return { ok: false, error: callError(err, timeoutMs) };
         }
     }
 }
@@ -85,8 +148,9 @@ class OpenAiCompatProvider {
         this.label = `${baseUrl}/${model}`;
     }
     async decide(input) {
+        const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
         try {
-            const res = await this.fetchFn(`${this.baseUrl}/chat/completions`, {
+            const res = await fetchWithTimeout(this.fetchFn, `${this.baseUrl}/chat/completions`, {
                 method: "POST",
                 headers: {
                     Authorization: `Bearer ${this.apiKey}`,
@@ -98,19 +162,30 @@ class OpenAiCompatProvider {
                     max_tokens: input.maxTokens ?? 1024,
                     response_format: { type: "json_object" },
                     messages: [
-                        { role: "system", content: input.system },
+                        { role: "system", content: applyReasoningToggle(this.model, input.system) },
                         { role: "user", content: input.user },
                     ],
                 }),
-            });
+            }, timeoutMs);
             if (!res.ok)
-                return { ok: false, error: `provider HTTP ${res.status}: ${await res.text()}` };
+                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 ?? "";
-            return text ? { ok: true, text } : { ok: false, error: "provider returned empty 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: err instanceof Error ? err.message : String(err) };
+            return { ok: false, error: callError(err, timeoutMs) };
         }
     }
 }
@@ -130,7 +205,9 @@ export function selectProvider(spec, env, fetchFn = fetch) {
                 ? "GROQ_API_KEY"
                 : provider === "nvidia"
                     ? "NVIDIA_API_KEY"
-                    : "OPENAI_API_KEY / MODEL_API_KEY";
+                    : provider === "gemini"
+                        ? "GEMINI_API_KEY"
+                        : "OPENAI_API_KEY / MODEL_API_KEY";
         throw new Error(`missing model API key: set ${varName} in the environment (never in an agent file)`);
     }
     if (provider === "anthropic")

package/dist/agent/resolve.js

@@ -48,6 +48,7 @@ const JOURNAL_MAX_LINES = 200;
 const JOURNAL_MAX_BYTES = 8_000;
 // Optional prose files (markdown the LLM reads), in assembly order.
 const PROSE_FILES = ["character/thesis.md", "character/persona.md"];
+const FUNCTIONALITY_PIN = "functionality/coinrithm.yaml";
 // Enforced cap field names. sizing.yaml is SOFT guidance and must NOT contain
 // any of these (or a user could think a limit binds when it does not).
 const ENFORCED_FIELD_NAMES = new Set([
@@ -58,6 +59,7 @@ const ENFORCED_FIELD_NAMES = new Set([
     "maxConsecutiveModelFailures",
     "onRateLimitPressure",
 ]);
+const SKILL_METADATA_KEYS = new Set(["type", "title", "description", "tags"]);
 // A $ref must be a LOCAL, RELATIVE path inside the agent folder — never a URL,
 // an absolute path, a home/drive path, or a Windows backslash path.
 function refSyntaxIssue(ref) {
@@ -391,6 +393,13 @@ function resolveDirectory(dir) {
             // a skill file may be pure prose (no frontmatter) — treat whole as body.
             body = readFileSync(abs, "utf8");
         }
+        for (const f of scanForSecrets(patch)) {
+            ctx.issues.push({
+                code: "secret_in_frontmatter",
+                path: refPath,
+                message: `${f} (skill frontmatter is committable metadata — remove secrets)`,
+            });
+        }
         includeOrder.push(name);
         skillProse.push({ source: refPath, text: body });
         applySkillPatch(ctx, rawFrontmatter, patch, refPath);
@@ -420,6 +429,23 @@ function resolveDirectory(dir) {
             });
         }
     }
+    // Optional API/tool contract pin. It is locked for reproducibility and stale
+    // warnings, but it is not part of AgentSpec and is never sent to the model.
+    const functionalityPath = join(dir, FUNCTIONALITY_PIN);
+    if (existsSync(functionalityPath)) {
+        const abs = safePath(ctx, FUNCTIONALITY_PIN, "functionality pin");
+        if (abs) {
+            const parsed = parseYamlSafe(ctx, readHashed(ctx, abs), FUNCTIONALITY_PIN);
+            for (const f of scanForSecrets(parsed)) {
+                ctx.issues.push({
+                    code: "secret_in_functionality",
+                    path: FUNCTIONALITY_PIN,
+                    message: `${f} (the functionality pin is committable metadata — remove secrets)`,
+                });
+            }
+            sources.functionality = FUNCTIONALITY_PIN;
+        }
+    }
     const mergedProse = mergeProseParts(proseParts);
     checkSizing(ctx, rawFrontmatter);
     scanSecrets(ctx, rawFrontmatter, mergedProse);
@@ -444,6 +470,8 @@ function resolveDirectory(dir) {
 // permitted, tighten-only; anything else is rejected (no permission expansion).
 function applySkillPatch(ctx, rawFrontmatter, patch, sourceLabel) {
     for (const key of Object.keys(patch)) {
+        if (SKILL_METADATA_KEYS.has(key))
+            continue;
         if (key === "risk" || key === "limits") {
             const caps = key === "risk" ? RISK_CAPS : LIMIT_CAPS;
             const base = rawFrontmatter[key] ?? {};

package/dist/agent/resolvePm.d.ts

@@ -0,0 +1,14 @@
+import { PmMarket, ProposedAction } from "./types.js";
+type PmOpen = Extract<ProposedAction, {
+    type: "pm_open";
+}>;
+export type PmRefResolution = {
+    ok: true;
+    action: PmOpen;
+} | {
+    ok: false;
+    code: string;
+    reason: string;
+};
+export declare function resolvePmRef(action: PmOpen, pmMarkets: PmMarket[]): PmRefResolution;
+export {};

package/dist/agent/resolvePm.js

@@ -0,0 +1,69 @@
+// Resolve a short pm ref (pm1…pmN) on a pm_open action back to the canonical
+// {source, slug, outcomeExternalMarketId} triple, using the cycle's discovered
+// pmMarkets. This is the reliability fix for prediction-market trading: small
+// free models (Llama 3.1 8B) reliably copy a 3-char ref but mis-copy the long
+// outcomeExternalMarketId, which previously made every PM open fail closed with
+// pm_market_not_discovered. The prompt now asks the model for a ref; the runner
+// resolves it here BEFORE validation so the validator/act phase still see the
+// full triple they require.
+//
+// Back-compat: a model that sends the full triple (no ref) passes through
+// unchanged. Robustness: a model that drops the ref into one of the id fields
+// (a common 8B mistake) is still detected and resolved.
+const REF_RE = /^pm\d+$/i;
+const trimLower = (v) => typeof v === "string" ? v.trim().toLowerCase() : "";
+// Find a pmN-shaped token the model may have placed in `ref` or — for sloppy
+// small models — in one of the id fields. Real Kalshi/Polymarket ids are long
+// hex/uuid strings and never match /^pm\d+$/, so this can't false-positive on a
+// genuine id.
+function extractRef(action) {
+    const candidates = [
+        action.ref,
+        action.outcomeExternalMarketId,
+        action.slug,
+        action.source,
+    ];
+    for (const c of candidates) {
+        const t = trimLower(c);
+        if (REF_RE.test(t))
+            return t;
+    }
+    return undefined;
+}
+export function resolvePmRef(action, pmMarkets) {
+    const ref = extractRef(action);
+    if (ref) {
+        const mkt = pmMarkets.find((m) => trimLower(m.ref) === ref);
+        if (!mkt) {
+            const known = pmMarkets.length
+                ? `pm1..pm${pmMarkets.length}`
+                : "(none discovered this cycle)";
+            return {
+                ok: false,
+                code: "pm_ref_unknown",
+                reason: `ref ${ref} is not one of this cycle's listed PM markets ${known}`,
+            };
+        }
+        // Canonicalise: take the triple from the matched market, drop the ref.
+        return {
+            ok: true,
+            action: {
+                ...action,
+                ref: undefined,
+                source: mkt.source,
+                slug: mkt.slug,
+                outcomeExternalMarketId: mkt.outcomeExternalMarketId,
+            },
+        };
+    }
+    // No ref: require the full back-compat triple. Empty/missing → reject with a
+    // clear, model-actionable message rather than a downstream crash.
+    if (action.source && action.slug && action.outcomeExternalMarketId) {
+        return { ok: true, action };
+    }
+    return {
+        ok: false,
+        code: "pm_ref_missing",
+        reason: "pm_open needs a ref (pmN) copied from one observation.pmMarkets entry, or the full source+slug+outcomeExternalMarketId",
+    };
+}

package/dist/agent/runner.d.ts

@@ -1,6 +1,6 @@
 import { CoinRithmClient } from "./client.js";
 import { Provider } from "./providers.js";
-import { AgentSpec, RunState, CycleResult } from "./types.js";
+import { AgentSpec, RunState, CycleResult, ProposedAction, QuoteEvidence } from "./types.js";
 export interface RunnerDeps {
     client: CoinRithmClient;
     provider: Provider;
@@ -11,6 +11,11 @@ export interface RunnerDeps {
     stateFile?: string;
     log?: (line: string) => void;
 }
+export declare function repairFuturesTakeProfit(action: ProposedAction, quote?: QuoteEvidence): {
+    action: ProposedAction;
+    repaired: boolean;
+};
+export declare function rationaleForAction(a: ProposedAction, decisionRationale: string | undefined, perActionSummary: string | undefined, totalActions: number): string | undefined;
 export declare function runCycle(deps: RunnerDeps): Promise<CycleResult>;
 export interface LoopOptions {
     once?: boolean;