@coinrithm/mcp-trading 0.7.6 → 0.7.8

package/dist/agent/decision.js

@@ -3,6 +3,7 @@
 // JSON, an unknown action type, a free-form endpoint/tool name, extra unknown
 // fields, or a missing required field — fails closed (the runner skips).
 import { z } from "zod";
+import { coerceThesis } from "./thesis.js";
 // Small models (especially Llama 3.1 8B) frequently emit numbers as JSON strings
 // ("12345", "0.8", "62000"). Coerce a *clean* numeric string to a number before
 // validating; leave anything else untouched so genuine garbage ("abc", "pos#5")
@@ -31,6 +32,15 @@ const forecastProbability = z
     return typeof n === "number" && Number.isFinite(n) ? n : undefined;
 })
     .optional();
+// The thesis an OPEN is made on (slice 2, 2026-09-02): {summary, invalidation}.
+// TOLERANT like forecastProbability: a missing / malformed thesis becomes
+// undefined and never fails an otherwise-valid open. The prompt requires it and
+// the structured-output schema below lists it as required; the runner binds it
+// to the position the server returns and evaluates it every cycle.
+const thesis = z
+    .any()
+    .transform((v) => coerceThesis(v))
+    .optional();
 const futuresOpen = z
     .object({
     type: z.literal("futures_open"),
@@ -42,6 +52,7 @@ const futuresOpen = z
     takeProfitPrice: num(z.number()).nullable().optional(),
     confidence,
     rationaleSummary: z.string().optional(),
+    thesis,
 })
     .strict();
 const futuresClose = z
@@ -51,6 +62,11 @@ const futuresClose = z
     fraction: num(z.number().positive().max(1)).optional(),
     confidence,
     rationaleSummary: z.string().optional(),
+    // Accepted-and-unused: models copy the open-side `thesis` onto every
+    // action exactly as they copied `confidence` (the .strict() fail-closed
+    // lesson of 2026-08-19). The structured-output schema never asks for it
+    // here; a BYO model that echoes it must not zero the whole cycle.
+    thesis,
 })
     .strict();
 const futuresSetSltp = z
@@ -66,6 +82,7 @@ const futuresSetSltp = z
     // trade actions already have.
     confidence,
     rationaleSummary: z.string().optional(),
+    thesis, // accepted-and-unused, see futures_close
 })
     .strict();
 const spotOrder = z
@@ -79,6 +96,7 @@ const spotOrder = z
     stopPrice: num(z.number().positive()).optional(),
     confidence,
     rationaleSummary: z.string().optional(),
+    thesis,
 })
     .strict();
 const spotCancel = z
@@ -88,6 +106,7 @@ const spotCancel = z
     // Same accepted-and-unused tolerance as futures_set_sltp above.
     confidence,
     rationaleSummary: z.string().optional(),
+    thesis,
 })
     .strict();
 // pm_open accepts EITHER a short ref (pm1…pmN, what the prompt now asks for) OR
@@ -107,6 +126,7 @@ const pmOpen = z
     confidence,
     rationaleSummary: z.string().optional(),
     forecastProbability,
+    thesis,
 })
     .strict();
 export const actionSchema = z.discriminatedUnion("type", [
@@ -117,6 +137,163 @@ export const actionSchema = z.discriminatedUnion("type", [
     spotCancel,
     pmOpen,
 ]);
+// Request-side structured-output contract for providers that support JSON
+// Schema. Keep this beside the Zod parser: the provider must not be allowed to
+// emit an `act` with no actions (the Nano incident on 2026-08-27), while a real
+// skip must carry an empty action list. The runner still parses with Zod and
+// re-validates every action against live quotes/caps before any write.
+//
+// `pm_open` deliberately requires the short per-cycle `ref` here. The parser
+// remains backwards-compatible with the full source/slug/id triple, but the
+// hosted prompt asks models for refs and that is the only reliable generated
+// shape.
+const nullableNumber = { anyOf: [{ type: "number" }, { type: "null" }] };
+const optionalConfidence = { type: "number", minimum: 0, maximum: 1 };
+const optionalRationaleSummary = { type: "string" };
+// Thesis contract for the structured-output transports (the NVIDIA endpoint
+// forces the tool call from this schema, so a field absent here can never be
+// emitted). One shared shape; the runner drops the fields that do not apply to
+// the venue and re-signs nothing.
+const thesisSchema = {
+    type: "object",
+    properties: {
+        summary: { type: "string", maxLength: 200 },
+        invalidation: {
+            type: "object",
+            properties: {
+                priceBelow: { type: "number", exclusiveMinimum: 0 },
+                priceAbove: { type: "number", exclusiveMinimum: 0 },
+                probabilityBelow: { type: "number", exclusiveMinimum: 0, maximum: 100 },
+                probabilityAbove: { type: "number", exclusiveMinimum: 0, maximum: 100 },
+                maxHoldMinutes: { type: "number", exclusiveMinimum: 0 },
+                catalyst: { type: "string", maxLength: 160 },
+            },
+            additionalProperties: false,
+        },
+    },
+    required: ["summary", "invalidation"],
+    additionalProperties: false,
+};
+const generatedActionSchemas = [
+    {
+        type: "object",
+        properties: {
+            type: { const: "futures_open" },
+            symbol: { type: "string", minLength: 1 },
+            side: { enum: ["long", "short"] },
+            leverage: { type: "number", exclusiveMinimum: 0 },
+            marginMusd: { type: "number", exclusiveMinimum: 0 },
+            stopLossPrice: nullableNumber,
+            takeProfitPrice: nullableNumber,
+            confidence: optionalConfidence,
+            rationaleSummary: optionalRationaleSummary,
+            thesis: thesisSchema,
+        },
+        required: ["type", "symbol", "side", "leverage", "marginMusd", "thesis"],
+        additionalProperties: false,
+    },
+    {
+        type: "object",
+        properties: {
+            type: { const: "futures_close" },
+            positionId: { type: "number" },
+            fraction: { type: "number", exclusiveMinimum: 0, maximum: 1 },
+            confidence: optionalConfidence,
+            rationaleSummary: optionalRationaleSummary,
+        },
+        required: ["type", "positionId"],
+        additionalProperties: false,
+    },
+    {
+        type: "object",
+        properties: {
+            type: { const: "futures_set_sltp" },
+            positionId: { type: "number" },
+            stopLossPrice: nullableNumber,
+            takeProfitPrice: nullableNumber,
+            confidence: optionalConfidence,
+            rationaleSummary: optionalRationaleSummary,
+        },
+        required: ["type", "positionId"],
+        additionalProperties: false,
+    },
+    {
+        type: "object",
+        properties: {
+            type: { const: "spot_order" },
+            symbol: { type: "string", minLength: 1 },
+            side: { enum: ["buy", "sell"] },
+            orderType: { enum: ["market", "limit", "stop"] },
+            quantity: { type: "number", exclusiveMinimum: 0 },
+            limitPrice: { type: "number", exclusiveMinimum: 0 },
+            stopPrice: { type: "number", exclusiveMinimum: 0 },
+            confidence: optionalConfidence,
+            rationaleSummary: optionalRationaleSummary,
+            thesis: thesisSchema,
+        },
+        required: ["type", "symbol", "side", "orderType", "quantity", "thesis"],
+        additionalProperties: false,
+    },
+    {
+        type: "object",
+        properties: {
+            type: { const: "spot_cancel" },
+            orderId: { type: "number" },
+            confidence: optionalConfidence,
+            rationaleSummary: optionalRationaleSummary,
+        },
+        required: ["type", "orderId"],
+        additionalProperties: false,
+    },
+    {
+        type: "object",
+        properties: {
+            type: { const: "pm_open" },
+            ref: { type: "string", minLength: 1 },
+            stakeMusd: { type: "number", exclusiveMinimum: 0 },
+            confidence: optionalConfidence,
+            rationaleSummary: optionalRationaleSummary,
+            forecastProbability: { type: "number" },
+            thesis: thesisSchema,
+        },
+        required: ["type", "ref", "stakeMusd", "thesis"],
+        additionalProperties: false,
+    },
+];
+const generatedDecisionProperties = {
+    confidence: optionalConfidence,
+    reason: { type: "string" },
+    rationale: { type: "string", maxLength: 1200 },
+};
+export const DECISION_JSON_SCHEMA = {
+    type: "object",
+    properties: {
+        decision: { enum: ["skip", "act"] },
+        ...generatedDecisionProperties,
+        actions: {
+            type: "array",
+            items: { oneOf: generatedActionSchemas },
+        },
+    },
+    required: ["decision", "actions"],
+    additionalProperties: false,
+    allOf: [
+        {
+            if: {
+                properties: { decision: { const: "act" } },
+                required: ["decision"],
+            },
+            then: { properties: { actions: { minItems: 1 } } },
+        },
+        {
+            if: {
+                properties: { decision: { const: "skip" } },
+                required: ["decision"],
+            },
+            then: { properties: { actions: { maxItems: 0 } } },
+        },
+    ],
+};
 const decisionSchema = z
     .object({
     decision: z.enum(["skip", "act"]),

package/dist/agent/decisionProbe.d.ts

@@ -0,0 +1,17 @@
+import { ProviderName } from "./types.js";
+export interface ProbeRoute {
+    provider: ProviderName;
+    model: string;
+    baseUrl?: string | null;
+    key: string;
+}
+export type ProbeDecisionResult = {
+    ok: true;
+} | {
+    ok: false;
+    stage: "http" | "empty" | "parse";
+    error: string;
+    status?: number;
+    retryAfterMs?: number;
+};
+export declare function probeDecisionContract(route: ProbeRoute, fetchFn?: typeof fetch): Promise<ProbeDecisionResult>;

package/dist/agent/decisionProbe.js

@@ -0,0 +1,70 @@
+// Representative decision probe (reliability slice A, contract frozen on
+// Telegram 2026-08-26). An HTTP-200 chat ping is NOT proof a route can run an
+// agent: the 62f3a12 incident had 200s all round while every cycle failed with
+// "Unexpected token W" (think-chain in the JSON slot), and Codex's gpt-5-nano
+// probe at 256 completion tokens returned EMPTY content with a length finish
+// because reasoning consumed the budget. A route is eligible only when a real
+// call comes back parseable through the REAL decision parser with a non-empty
+// decision — using the exact request shape a cycle would send
+// (providerForRoute -> the same provider classes as the runner).
+//
+// Uses: boot eligibility of fallback-chain targets (slice B), circuit
+// half-open reopens, any future model migration (D18: probe before adopt).
+// The key is used for the one call and never logged; provider error text is
+// sanitized before it can reach any log or ledger row.
+import { providerForRoute } from "./providers.js";
+import { chatShapeFor } from "./providerCapabilities.js";
+import { parseDecision } from "./decision.js";
+// A canned mini-observation whose ONLY correct answer is a tiny skip decision.
+// Small enough to cost nothing, real enough to exercise the full JSON contract.
+const PROBE_SYSTEM = [
+    "You are a trading agent contract probe.",
+    'Reply with EXACTLY one JSON object: {"decision":"skip","reason":"contract probe"}.',
+    "No prose, no code fences, no additional keys.",
+].join(" ");
+const PROBE_USER = "Observation: BTC 24h change 0.0%. Confirm the decision contract.";
+const PROBE_TIMEOUT_MS = 30_000;
+/** Strip the key (and bearer echoes) out of any text a probe might surface. */
+function sanitize(text, key) {
+    let out = (text ?? "").slice(0, 400);
+    if (key)
+        out = out.split(key).join("***");
+    out = out.replace(/Bearer\s+[A-Za-z0-9._-]{8,}/g, "Bearer ***");
+    return out.slice(0, 200);
+}
+export async function probeDecisionContract(route, fetchFn = fetch) {
+    const shape = chatShapeFor(route.provider, route.model, route.baseUrl ?? undefined);
+    const provider = providerForRoute(route, route.key, fetchFn);
+    const res = await provider.decide({
+        system: PROBE_SYSTEM,
+        user: PROBE_USER,
+        // Reasoning models spend hidden tokens first — grant at least the family
+        // floor (1024) or the empty-with-length-finish false negative comes back.
+        maxTokens: Math.max(1024, shape.minProbeCompletionTokens),
+        timeoutMs: PROBE_TIMEOUT_MS,
+    });
+    if (!res.ok) {
+        const error = sanitize(res.error, route.key);
+        // Provider classes report empty 2xx content as "... returned empty content".
+        const stage = /returned empty content/i.test(res.error) ? "empty" : "http";
+        return {
+            ok: false,
+            stage,
+            error,
+            status: res.status,
+            retryAfterMs: res.retryAfterMs,
+        };
+    }
+    if (!res.text.trim()) {
+        return { ok: false, stage: "empty", error: "empty completion" };
+    }
+    const parsed = parseDecision(res.text);
+    if (!parsed.ok) {
+        return {
+            ok: false,
+            stage: "parse",
+            error: sanitize(parsed.error, route.key),
+        };
+    }
+    return { ok: true };
+}

package/dist/agent/decisionReceipt.d.ts

@@ -0,0 +1,45 @@
+import type { AgentSpec, Observation, RunState } from "./types.js";
+import { type DailyRiskBudget } from "./prompt.js";
+export declare const DECISION_INPUT_MAX_BYTES: number;
+export type DecisionInputPhase = "before_observation" | "observed" | "decision_input";
+type Scalar = string | number | boolean | null;
+type Row = Record<string, Scalar | string[] | Record<string, Scalar | string[]>>;
+export interface DecisionInputRecord {
+    version: "coinrithm.decision-input.v1";
+    visibility: "private";
+    completeness: "partial";
+    phase: DecisionInputPhase;
+    outcome: "pending" | "returned" | "runtime_error";
+    runId: string | null;
+    decisionId: string | null;
+    configFingerprint: string | null;
+    observationFingerprint: string | null;
+    preThesisObservationFingerprint: string | null;
+    dailyRiskBudget: DailyRiskBudget | null;
+    guardState: Record<string, number | boolean | null>;
+    account: Record<string, number | boolean | string | null> | null;
+    lists: Record<string, Row[]>;
+    counts: Record<string, {
+        source: number;
+        retained: number;
+        omitted: number;
+    }>;
+    omissions: string[];
+}
+export interface DecisionInputCapture {
+    phase: DecisionInputPhase;
+    runId: string;
+    decisionId: string;
+    spec: AgentSpec;
+    mergedProse: string;
+    state: RunState;
+    observation?: Observation;
+    observationFingerprint?: string;
+    preThesisObservationFingerprint?: string;
+}
+export declare function buildDecisionInputRecord(input: DecisionInputCapture): DecisionInputRecord;
+export declare function unavailableDecisionInputRecord(): DecisionInputRecord;
+/** Defense at the storage boundary. Reject rather than preserve an arbitrary
+ * extension field. Detached JSON copy also prevents post-check mutation. */
+export declare function sanitizeDecisionInputRecord(value: unknown): DecisionInputRecord | undefined;
+export {};