@coinrithm/mcp-trading 0.7.7 → 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/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 {};