@coinrithm/mcp-trading 0.7.8 → 0.7.9

package/dist/agent/decisionReceipt.js

@@ -49,6 +49,7 @@ export function buildDecisionInputRecord(input) {
     const budget = buildDailyRiskBudget(input.spec, input.state);
     const record = {
         version: "coinrithm.decision-input.v1",
+        projectionVersion: "coinrithm.decision-input-projection.v2",
         visibility: "private",
         completeness: "partial",
         phase: input.phase,
@@ -149,6 +150,12 @@ export function buildDecisionInputRecord(input) {
             ema20AboveEma50: bool(obj(r.indicators).ema20AboveEma50),
             brokeRecentHigh: bool(obj(r.indicators).brokeRecentHigh),
             brokeRecentLow: bool(obj(r.indicators).brokeRecentLow),
+            bollinger: numeric(obj(obj(r.indicators).bollinger), [
+                "upper",
+                "mid",
+                "lower",
+            ]),
+            recent20: numeric(obj(obj(r.indicators).recent20), ["high", "low"]),
         },
         fundamentals: numeric(obj(r.fundamentals), [
             "marketCapRank",
@@ -156,11 +163,18 @@ export function buildDecisionInputRecord(input) {
             "volume24hUsd",
         ]),
     }));
+    // Context-only movers are not executable candidates. Preserve their order
+    // and numeric facts without copying provider names or arbitrary free text.
+    add("universeMovers", obs.universeMovers, (r) => ({
+        symbol: id(r.symbol, 20),
+        ...numeric(r, ["change24hPct", "priceUsd"]),
+    }));
     add("futuresPositions", obs.openPositions, (r) => ({
         id: num(r.id),
         symbol: id(r.symbol, 20),
         coinId: id(r.coinId, 32),
         side: code(r.side, ["long", "short"]),
+        openedAt: sourceTimestamp(r.openedAt) ?? null,
         ...numeric(r, [
             "leverage",
             "marginMusd",
@@ -238,7 +252,6 @@ export function buildDecisionInputRecord(input) {
         ["news", obs.news],
         ["pmResolutions", obs.pmResolutions],
         ["newClosedTrades", obs.newClosedTrades],
-        ["universeMovers", obs.universeMovers],
         ["journal", input.state.journal],
     ]) {
         record.counts[name] = {
@@ -247,7 +260,7 @@ export function buildDecisionInputRecord(input) {
             omitted: arr(values).length,
         };
     }
-    record.omissions.push("unlisted_fields_and_nested_indicators_excluded");
+    record.omissions.push("unlisted_fields_excluded");
     if (Object.values(record.counts).some((v) => v.omitted > 0))
         record.omissions.push("list_rows_omitted");
     // Leave room for fixed outcome/error metadata. Drop the largest remaining
@@ -303,6 +316,7 @@ const OMISSIONS = [
     "config_fingerprint_unavailable",
     "observation_not_available",
     "unlisted_fields_and_nested_indicators_excluded",
+    "unlisted_fields_excluded",
     "list_rows_omitted",
     "byte_budget_exceeded",
     "evidence_capture_failed",
@@ -327,6 +341,7 @@ const LIST_KEYS = {
         "symbol",
         "coinId",
         "side",
+        "openedAt",
         "leverage",
         "marginMusd",
         "unrealizedPnlMusd",
@@ -361,6 +376,7 @@ const LIST_KEYS = {
         "decisionSupport",
     ],
     signals: ["symbol", "kind", "bias", "strength", "held"],
+    universeMovers: ["symbol", "change24hPct", "priceUsd"],
 };
 const NESTED_KEYS = {
     freshness: ["status", "ageSeconds", "asOf", "basis"],
@@ -391,7 +407,11 @@ const NESTED_KEYS = {
         "ema20AboveEma50",
         "brokeRecentHigh",
         "brokeRecentLow",
+        "bollinger",
+        "recent20",
     ],
+    bollinger: ["upper", "mid", "lower"],
+    recent20: ["high", "low"],
     fundamentals: ["marketCapRank", "marketCapUsd", "volume24hUsd"],
 };
 function keysOnly(value, keys) {
@@ -408,7 +428,7 @@ function validRow(value, keys) {
             return true;
         if (NESTED_KEYS[key])
             return validRow(v, NESTED_KEYS[key]);
-        if (key === "asOf" || key === "assessedAt")
+        if (key === "asOf" || key === "assessedAt" || key === "openedAt")
             return sourceTimestamp(v) === v;
         if (key === "basis")
             return code(v, FRESHNESS_BASES) !== null;
@@ -489,6 +509,7 @@ export function sanitizeDecisionInputRecord(value) {
         const r = JSON.parse(encoded);
         if (!keysOnly(r, [
             "version",
+            "projectionVersion",
             "visibility",
             "completeness",
             "phase",
@@ -506,6 +527,9 @@ export function sanitizeDecisionInputRecord(value) {
             "omissions",
         ]))
             return undefined;
+        if (r.projectionVersion !== undefined &&
+            r.projectionVersion !== "coinrithm.decision-input-projection.v2")
+            return undefined;
         if (r.version !== "coinrithm.decision-input.v1" ||
             r.visibility !== "private" ||
             r.completeness !== "partial")

package/dist/agent/gate.js

@@ -58,27 +58,27 @@ export function evaluateGate(observation, state, policy, nowMs) {
     // evaluate PREDICTION MARKETS — they carry edge even when crypto prices are flat,
     // so an agent on a quiet tape shouldn't go dark on PM. At most once per cooldown
     // (gated on the last LLM call, which any fire resets), so it's not every cycle.
+    let pmPeriodic = false;
     if (codeList.length === 0) {
         const pmAvailable = observation.pmMarkets.length > 0;
         const sinceLastCall = state.lastLlmCallAt == null ? Infinity : nowMs - state.lastLlmCallAt;
         if (pmAvailable &&
             policy.pmEvalCooldownMinutes > 0 &&
             sinceLastCall >= policy.pmEvalCooldownMinutes * 60_000) {
+            pmPeriodic = true;
+            codeList.push("PM_PERIODIC");
+        }
+        else {
             return {
-                fire: true,
-                codes: ["PM_PERIODIC"],
-                reason: "PM periodic eval (quiet price tape)",
+                fire: false,
+                codes: [],
+                reason: "no trigger (flat tape, no open position)",
             };
         }
-        return {
-            fire: false,
-            codes: [],
-            reason: "no trigger (flat tape, no open position)",
-        };
     }
     // A real trigger exists. Open positions are NEVER starved by budget/debounce
     // (managing a live position is always allowed); the caps below only throttle
-    // fresh entry-only cycles so a chop-storm of entry setups can't burn the budget.
+    // fresh entry-only cycles, including periodic PM evaluations.
     if (!hasPosition) {
         if (policy.maxLlmCallsPerHour > 0) {
             const recent = (state.llmCallTimestamps ?? []).filter((t) => nowMs - t < 3_600_000);
@@ -90,7 +90,8 @@ export function evaluateGate(observation, state, policy, nowMs) {
                 };
             }
         }
-        if (policy.debounceMinutes > 0) {
+        // PM already passed its own cooldown; debounce only crypto-entry triggers.
+        if (!pmPeriodic && policy.debounceMinutes > 0) {
             const fp = [...codeList].sort().join(",");
             if (state.lastTriggerFingerprint === fp &&
                 state.lastLlmCallAt != null &&
@@ -106,7 +107,9 @@ export function evaluateGate(observation, state, policy, nowMs) {
     return {
         fire: true,
         codes: codeList,
-        reason: `triggers: ${codeList.join(",")}`,
+        reason: pmPeriodic
+            ? "PM periodic eval (quiet price tape)"
+            : `triggers: ${codeList.join(",")}`,
     };
 }
 // Record that this cycle spent an LLM call — feeds the budget + debounce next

package/dist/agent/providers.d.ts

@@ -20,7 +20,7 @@ export interface DecideRouteMeta {
     profile: "fast" | "strong" | "configured";
     effectiveProvider?: string;
     effectiveModel?: string;
-    reason: "configured" | "circuit_fallback" | "capacity_fallback" | "provider_fallback" | "malformed_fallback" | "byo";
+    reason: "configured" | "configured_direct" | "circuit_fallback" | "capacity_fallback" | "provider_fallback" | "malformed_fallback" | "byo";
     attempts: DecideRouteAttempt[];
 }
 export type DecideResult = {
@@ -36,6 +36,7 @@ export type DecideResult = {
     error: string;
     status?: number;
     retryAfterMs?: number;
+    retryableHttpFailure?: true;
     deferred?: boolean;
     route?: DecideRouteMeta;
 };

package/dist/agent/providers.js

@@ -2,6 +2,7 @@
 // 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 { 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>" }`.
@@ -27,6 +28,7 @@ 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.
@@ -58,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) {
@@ -165,7 +169,7 @@ class AnthropicProvider {
                         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)}`,
+                        error: `anthropic HTTP ${res.status}: ${safeProviderError(await res.text(), this.apiKey)}`,
                         status: res.status,
                         retryAfterMs: retryAfterMs(res),
                     };
@@ -186,9 +190,9 @@ class AnthropicProvider {
         catch (err) {
             return {
                 ok: false,
-                error: failureResponse
+                error: safeProviderError(failureResponse
                     ? `anthropic HTTP ${failureResponse.status}: ${callError(err, timeoutMs)}`
-                    : callError(err, timeoutMs),
+                    : callError(err, timeoutMs), this.apiKey),
                 ...(failureResponse
                     ? {
                         status: failureResponse.status,
@@ -240,9 +244,12 @@ class OpenAiCompatProvider {
                         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)}`,
+                        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 }
+                            : {}),
                     };
                 }
                 const json = (await res.json());
@@ -263,9 +270,9 @@ class OpenAiCompatProvider {
         catch (err) {
             return {
                 ok: false,
-                error: failureResponse
+                error: safeProviderError(failureResponse
                     ? `provider HTTP ${failureResponse.status}: ${callError(err, timeoutMs)}`
-                    : callError(err, timeoutMs),
+                    : callError(err, timeoutMs), this.apiKey),
                 ...(failureResponse
                     ? {
                         status: failureResponse.status,
@@ -276,6 +283,86 @@ 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.
+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.
@@ -308,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/runner.js

@@ -1291,13 +1291,18 @@ async function runCycleCore(deps, capture) {
     state.consecutiveExecFailures =
         anyExecFailed && !anyExecuted ? state.consecutiveExecFailures + 1 : 0;
     state.rateLimitHits = client.rateLimitHits ?? state.rateLimitHits;
-    // Slice-3 memory: journal the accepted move(s) + the thesis behind them so next
-    // cycle has continuity (manage with memory of WHY; don't re-open what we just did).
+    // Memory describes completed moves, not policy acceptance. A backend rejection,
+    // lost response, or dry-run plan must not become "opened" / "trailed stop" in
+    // the next model prompt. Attempts remain in planned[] and the audit ledger.
     const moves = planned
-        .filter((p) => p.accepted)
+        .filter((p) => p.accepted && p.executed === true)
         .map((p) => summarizeAction(p.action));
     if (moves.length > 0) {
-        const did = `${moves.join("; ")}${rationale ? ` — ${rationale.slice(0, 90)}` : ""}`;
+        // A cycle-wide rationale may describe a failed/rejected sibling action.
+        // Keep it only when every proposed action executed; per-action theses are
+        // already included by summarizeAction for confirmed opens.
+        const confirmedRationale = moves.length === planned.length ? rationale : undefined;
+        const did = `${moves.join("; ")}${confirmedRationale ? ` — ${confirmedRationale.slice(0, 90)}` : ""}`;
         state.journal = [
             ...(state.journal ?? []),
             { at: observation.asOf, did },

package/dist/agent/state.js

@@ -1,6 +1,7 @@
 // Local run state: the cursor, dedupe set, daily counters, and the kill-switch
 // inputs. Persisted to a JSON file so a re-run resumes where it left off.
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync, rmSync, } from "node:fs";
+import { randomUUID } from "node:crypto";
 import { dirname } from "node:path";
 import { dayKey } from "./util.js";
 import { asObj, asNum } from "./extract.js";
@@ -59,8 +60,22 @@ export function loadState(file, runId) {
 export function saveState(file, state) {
     if (!file)
         return;
+    const serialized = JSON.stringify(state, null, 2);
     mkdirSync(dirname(file), { recursive: true });
-    writeFileSync(file, JSON.stringify(state, null, 2), "utf8");
+    // A sibling file keeps rename on the same filesystem. Readers see either
+    // the previous complete state or the new one, never a truncated JSON write.
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, serialized, {
+            encoding: "utf8",
+            flag: "wx",
+            mode: 0o600,
+        });
+        renameSync(temporary, file);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
 }
 export function rollDay(state) {
     const today = dayKey();

package/dist/agent/templates.js

@@ -182,6 +182,10 @@ export function ejectFiles(fm, body) {
     };
     if (fm.sizing)
         agentFm.sizing = fm.sizing;
+    if (fm.capitalSizing !== undefined)
+        agentFm.capitalSizing = fm.capitalSizing;
+    if (fm.triggerPolicy !== undefined)
+        agentFm.triggerPolicy = fm.triggerPolicy;
     if (fm.objective)
         agentFm.objective = fm.objective;
     if (fm.capabilities)

package/dist/client.js

@@ -17,6 +17,7 @@
 //
 // IMPORTANT: this module must NEVER write to stdout (stdout is the MCP JSON-RPC
 // channel). All diagnostics go to stderr via the logger below.
+import { retryAfterSeconds } from "./retryAfter.js";
 export const DEFAULT_BASE_URL = "https://api.coinrithm.com";
 export function log(...args) {
     // stderr only — stdout is reserved for the MCP protocol.
@@ -139,12 +140,12 @@ export class CoinRithmClient {
         if (res.status === 429) {
             // Surface the back-off contract so an agent can pace itself instead of
             // hammering: 120 req/min per key baseline, 20 trade-writes/min.
-            const retryAfter = Number(res.headers.get("retry-after"));
+            const retryAfter = retryAfterSeconds(res.headers.get("retry-after"));
             data = {
                 ...(typeof data === "object" && data !== null
                     ? data
                     : { error: String(data) }),
-                retryAfterSeconds: Number.isFinite(retryAfter) ? retryAfter : null,
+                retryAfterSeconds: retryAfter ?? null,
                 hint: "Rate limited. Wait retryAfterSeconds (or the Retry-After header) before retrying; pace future calls using the RateLimit-Remaining response header.",
             };
         }

package/dist/http.d.ts

@@ -1,2 +1,8 @@
 #!/usr/bin/env node
-export {};
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { CoinRithmClient } from "./client.js";
+import { type CompletionLogger } from "./httpCompletion.js";
+export declare function createHttpApp(client: CoinRithmClient, options?: {
+    completionLogger?: CompletionLogger;
+    createServer?: () => McpServer;
+}): import("express-serve-static-core").Express;

package/dist/http.js

@@ -24,8 +24,8 @@
 //     forwards as `extra.authInfo`, giving requestKey() a second source. Either
 //     way the caller's own key — and only that key — is used for their tool call.
 //   - Unauthenticated MCP initialization and tool-list introspection are allowed
-//     so registries can verify the server. Actual tool calls without a key return
-//     a structured 401 from CoinRithmClient before any upstream request is made.
+//     so registries can verify the server. Public data tools are also keyless;
+//     protected tools return a structured 401 when their key is missing.
 //
 // Config (env):
 //   COINRITHM_API_URL  (optional)  upstream base URL (default production).
@@ -35,15 +35,23 @@
 // the correct isolation model for a multi-user, per-request-keyed surface — no
 // session state is shared between users.
 import express from "express";
+import { pathToFileURL } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { CoinRithmClient, bearerFromHeader, loadHttpConfig, log, } from "./client.js";
 import { registerTools } from "./tools.js";
 import { SERVER_VERSION } from "./version.js";
-async function main() {
-    const config = loadHttpConfig(); // no global key — keys arrive per request
-    const client = new CoinRithmClient(config); // constructed WITHOUT a default key
+import { observeHttpCompletion, } from "./httpCompletion.js";
+// Factory permits isolated localhost SDK tests without opening a listener on import.
+export function createHttpApp(client, options = {}) {
     const app = express();
+    const completions = new WeakMap();
+    app.use((req, res, next) => {
+        if (req.method === "POST" && /^\/mcp\/?$/i.test(req.path)) {
+            completions.set(res, observeHttpCompletion(req, res, options.completionLogger));
+        }
+        next();
+    });
     app.use(express.json());
     // Lightweight, unauthenticated liveness probe (handy for Coolify/uptime checks).
     // Keep `/healthz` as the deployment contract and expose `/health` as a
@@ -110,8 +118,8 @@ async function main() {
         // Per-request auth: read THIS caller's key from the Authorization header,
         // or from Smithery's non-reserved forwarding header.
         // It is optional at the transport layer so registries can initialize the
-        // server and list tool schemas. Tool handlers still require a key and return
-        // a structured 401 if one is missing.
+        // server and list tool schemas. Public data tools are keyless; protected
+        // tool handlers return a structured 401 if their key is missing.
         const apiKey = bearerFromHeader(req.headers.authorization) ??
             bearerFromHeader(req.headers["x-coinrithm-api-key"]);
         // Belt-and-suspenders: also expose the token via the SDK's authInfo channel.
@@ -120,11 +128,13 @@ async function main() {
         if (apiKey) {
             req.auth = { token: apiKey, clientId: "coinrithm-key", scopes: [] };
         }
-        const server = new McpServer({
-            name: "coinrithm-trading",
-            version: SERVER_VERSION,
-        });
-        registerTools(server, client);
+        const server = options.createServer?.() ??
+            new McpServer({
+                name: "coinrithm-trading",
+                version: SERVER_VERSION,
+            });
+        if (!options.createServer)
+            registerTools(server, client);
         const transport = new StreamableHTTPServerTransport({
             sessionIdGenerator: undefined, // stateless: no cross-request/user state
         });
@@ -134,6 +144,7 @@ async function main() {
         });
         try {
             await server.connect(transport);
+            completions.get(res)?.attach(transport);
             // The transport reads req.headers (→ extra.requestInfo) and req.auth
             // (→ extra.authInfo); tools.ts picks up the caller's key from there.
             await transport.handleRequest(req, res, req.body);
@@ -149,13 +160,22 @@ async function main() {
             }
         }
     });
+    return app;
+}
+async function main() {
+    const config = loadHttpConfig(); // no global key — keys arrive per request
+    const client = new CoinRithmClient(config); // constructed WITHOUT a default key
+    const app = createHttpApp(client);
     const port = Number(process.env.PORT) || 8787;
     app.listen(port, () => {
         log(`HTTP MCP listening on :${port}/mcp (multi-user, per-request key). ` +
             `upstream=${config.baseUrl}. Paper only.`);
     });
 }
-main().catch((err) => {
-    log("fatal:", err instanceof Error ? err.message : err);
-    process.exit(1);
-});
+if (process.argv[1] &&
+    import.meta.url === pathToFileURL(process.argv[1]).href) {
+    main().catch((err) => {
+        log("fatal:", err instanceof Error ? err.message : err);
+        process.exit(1);
+    });
+}

package/dist/httpCompletion.d.ts

@@ -0,0 +1,33 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+export declare const COMPLETION_TOOL_NAMES: readonly ["whoami", "get_portfolio", "get_wallet", "list_open_orders", "get_positions", "resolve_symbol", "get_equity_curve", "get_my_trades", "get_market_context", "get_candles", "discover_pm_markets", "get_performance", "get_agent_ledger", "export_agent_ledger", "export_run_evidence", "get_arena_leaderboard", "get_arena_agent", "futures_quote", "pm_quote", "spot_quote", "place_spot_order", "cancel_spot_order", "open_futures_position", "set_futures_sl_tp", "close_futures_position", "open_pm_position", "report_pm_opportunity", "pm_data_overview", "pm_data_sources", "pm_data_sources_health", "pm_data_events", "pm_data_event", "pm_data_whales", "pm_data_disagreements", "pm_data_calibration", "pm_data_canonical", "pm_data_volume_history", "get_crypto_movers"];
+type Operation = "initialize" | "tools_list" | "tools_call" | "notification" | "other" | "invalid";
+type Outcome = "result" | "tool_error" | "protocol_error" | "no_response" | "not_applicable";
+type ToolName = (typeof COMPLETION_TOOL_NAMES)[number] | "unknown" | null;
+type RpcCompletion = {
+    operation: Operation;
+    tool: ToolName;
+    rpc_outcome: Outcome;
+    result_http_status: number | null;
+    result_ok: boolean | null;
+};
+export type HttpCompletionRecord = Readonly<RpcCompletion & {
+    event: "mcp_completion";
+    schema_version: 1;
+    completed_at: string;
+    duration_ms: number;
+    service_version: string;
+    transport: "streamable_http";
+    credential_supplied: boolean;
+    http_status: number | null;
+    delivery: "finished" | "aborted";
+}>;
+export type CompletionLogger = (line: string) => void;
+/** Attach before JSON parsing; malformed/rejected HTTP requests remain invalid,
+ * no_response, with their actual HTTP status. Do not read bodies or raw errors.
+ * Authentication and caller origin are deliberately NOT inferred from headers.
+ */
+export declare function observeHttpCompletion(req: IncomingMessage, res: ServerResponse, logger?: CompletionLogger): {
+    attach: (transport: Transport) => void;
+};
+export {};