@coinrithm/mcp-trading 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+All notable changes to `@coinrithm/mcp-trading` are documented here. The package
+ships two binaries — `coinrithm-mcp` (the MCP server) and `coinrithm-agent` (the
+self-host agent runner) — versioned together. The CoinRithm **API contract** is
+versioned separately (see `openapi.yaml` `info.version`, currently `1.4.0`).
+
+## 0.3.0
+
+- **Agent risk config: coin deny-list (`blocklist`).** `risk.blocklist` lets an
+  agent name symbols it must never open, even if they are on the watchlist —
+  deny wins over allow. Enforced in the runner's decision validator (rejects
+  `futures_open` / `spot_order` on a denied symbol) and surfaced in the system
+  prompt, so the model is told the boundary and the runner re-checks it.
+- **Docs: Open Knowledge Format positioning.** Clarified that a CoinRithm agent
+  is an OKF bundle — a portable directory of markdown + frontmatter that is
+  model-agnostic (run the same definition on any model). Develop and prove it
+  free on paper, then run it anywhere.
+- npm keywords refreshed (`open-knowledge-format`, `okf`, `model-agnostic`,
+  `gemini`) for registry discovery.
+
+## 0.2.0
+
+- Added the **`coinrithm-agent`** self-host runner binary alongside the MCP
+  server: a folder-as-architecture (OKF) agent you bring your own model key to,
+  with caps enforced by the runner (not the model), dry-run by default,
+  paper-only.
+
+## 0.1.x
+
+- Initial `coinrithm-mcp` MCP server: reads, quotes, scoped spot/futures/PM
+  writes, ledger export, and Agent Arena integration over a user-minted API key.

package/README.md

@@ -6,7 +6,7 @@ CoinRithm paper-trading toolkit. Two binaries:
   CoinRithm (spot, futures, prediction markets) using a personal API key.
 - **`coinrithm-agent`** — a self-host **agent runner**: author an agent as a
   folder and run an observe→decide→validate→act loop with your own model key
-  (paper, futures v1). See [Agent runner](#agent-runner-coinrithm-agent) below.
+  (paper: spot, futures, prediction markets). See [Agent runner](#agent-runner-coinrithm-agent) below.
 
 > **Paper trading only** — virtual funds (50,000 mUSD). Not financial advice.
 
@@ -23,7 +23,7 @@ This package also ships a **self-host agent runner**. You write an agent as a
 folder (strategy + hard caps in markdown/YAML); the runner compiles it and runs
 an `observe → decide → validate → act` loop, asking *your* model (bring-your-own
 key) for structured decisions and executing only the ones that pass your caps —
-**dry-run by default**, paper-only, futures in v1.
+**dry-run by default**, paper-only across spot, futures, and prediction markets.
 
 ```bash
 coinrithm-agent new my-agent --preset conservative

package/dist/agent/act.d.ts

@@ -0,0 +1,4 @@
+import { CoinRithmClient } from "./client.js";
+import { ProposedAction, AgentTrace, ApiResult, Observation, QuoteEvidence } from "./types.js";
+export declare function fetchQuote(client: CoinRithmClient, action: ProposedAction, observation: Observation, trace?: AgentTrace): Promise<QuoteEvidence | undefined>;
+export declare function executeAction(client: CoinRithmClient, action: ProposedAction, observation: Observation, trace: AgentTrace, idempotencyKey: string): Promise<ApiResult>;

package/dist/agent/act.js

@@ -1,5 +1,6 @@
 // Act phase: fetch the quote evidence for an open (the runner does this, never
-// the model) and execute a validated futures action with an idempotency key.
+// the model) and execute a validated action (futures / spot / PM) with an
+// idempotency key.
 import { asObj, asNum, asStr } from "./extract.js";
 function coinIdFor(observation, symbol) {
     return observation.watch.find((w) => w.symbol.toUpperCase() === symbol.toUpperCase())?.coinId ?? undefined;
@@ -11,20 +12,40 @@ function freshnessOf(block) {
 }
 // Read-only quote BEFORE any open. Returns ineligible (never throws) on error.
 export async function fetchQuote(client, action, observation, trace) {
-    if (action.type !== "futures_open")
-        return undefined;
-    const coinId = coinIdFor(observation, action.symbol);
-    if (!coinId)
-        return { eligible: false, blockReasons: ["unresolved_symbol"] };
-    const r = await client.futuresQuote({ coinId, side: action.side, leverage: action.leverage, marginMusd: action.marginMusd }, trace);
+    let r;
+    if (action.type === "futures_open") {
+        const coinId = coinIdFor(observation, action.symbol);
+        if (!coinId)
+            return { eligible: false, blockReasons: ["unresolved_symbol"] };
+        r = await client.futuresQuote({ coinId, side: action.side, leverage: action.leverage, marginMusd: action.marginMusd }, trace);
+    }
+    else if (action.type === "spot_order") {
+        const coinId = coinIdFor(observation, action.symbol);
+        if (!coinId)
+            return { eligible: false, blockReasons: ["unresolved_symbol"] };
+        r = await client.spotQuote({ coinId, side: action.side, quantity: action.quantity }, trace);
+    }
+    else if (action.type === "pm_open") {
+        r = await client.pmQuote({
+            source: action.source,
+            slug: action.slug,
+            outcomeExternalMarketId: action.outcomeExternalMarketId,
+            stakeMusd: action.stakeMusd,
+        }, trace);
+    }
+    else {
+        return undefined; // close / set-sltp / cancel need no quote
+    }
     if (!r.ok)
         return { eligible: false, blockReasons: [`quote_http_${r.status}`] };
     const d = asObj(r.data);
     return {
         eligible: d.eligible === true,
         blockReasons: d.blockReasons,
-        entryPrice: asNum(d.entryPrice),
-        liquidationPrice: asNum(d.liquidationPrice),
+        entryPrice: asNum(d.entryPrice), // futures
+        liquidationPrice: asNum(d.liquidationPrice), // futures
+        executionPrice: asNum(d.executionPrice), // spot live fill price
+        estimatedCostMusd: asNum(d.estimatedCostMusd), // spot gross notional
         // Freshness lives in the response's `observation` block (anti-look-ahead).
         freshness: freshnessOf(asObj(d.observation)),
     };
@@ -61,5 +82,33 @@ export async function executeAction(client, action, observation, trace, idempote
             agentTrace: trace,
         });
     }
+    if (action.type === "spot_order") {
+        const coinId = coinIdFor(observation, action.symbol);
+        if (!coinId)
+            return { ok: false, status: 0, data: { error: "unresolved_symbol" } };
+        return client.placeSpotOrder({
+            coinId,
+            side: action.side,
+            orderType: action.orderType,
+            quantity: action.quantity,
+            limitPrice: action.limitPrice,
+            stopPrice: action.stopPrice,
+            idempotencyKey,
+            agentTrace: trace,
+        });
+    }
+    if (action.type === "spot_cancel") {
+        return client.cancelSpotOrder(action.orderId, trace);
+    }
+    if (action.type === "pm_open") {
+        return client.openPmPosition({
+            source: action.source,
+            slug: action.slug,
+            outcomeExternalMarketId: action.outcomeExternalMarketId,
+            stakeMusd: action.stakeMusd,
+            idempotencyKey,
+            agentTrace: trace,
+        });
+    }
     return { ok: false, status: 0, data: { error: "unsupported_action" } };
 }

package/dist/agent/capabilityGuard.d.ts

@@ -0,0 +1,2 @@
+import { AgentSpec, ResolvedAgent, ResolveIssue } from "./types.js";
+export declare function checkCapabilityDrift(resolved: ResolvedAgent, spec: AgentSpec): ResolveIssue[];

package/dist/agent/capabilityGuard.js

@@ -0,0 +1,131 @@
+// Capability drift guard.
+//
+// An agent's PROSE (thesis, persona, tactic skills) is authored separately from
+// the runner's code, so a skill can name a venue, an action, or a cap that the
+// runner does NOT support — and rot silently, exactly the way a stale doc drifts
+// from a live enum. (We watched this happen in a sibling system: a knowledge file
+// kept naming post types the live enum had dropped, and a test pinned the stale
+// names so the suite stayed green while the model was fed a wrong taxonomy.)
+//
+// This guard asserts that every capability IDENTIFIER referenced in authored
+// prose is in the runner's LIVE capability set AND — for actions/venues — in THIS
+// agent's enabled venues. It is deliberately deterministic and low-false-positive:
+// it inspects only identifier-shaped tokens (snake_case `<venue>_<verb>` actions
+// scanned anywhere; cap/venue identifiers scanned only inside markdown code
+// spans), never free English. Runtime memory (journal/notes.md) is excluded — it
+// records history, and may legitimately recall a venue later disabled.
+import { VENUES, ACTION_TYPES, } from "./types.js";
+import { levenshtein } from "./strictLint.js";
+import { RISK_CAPS, LIMIT_CAPS } from "./mergeRules.js";
+const KNOWN_ACTIONS = new Set(ACTION_TYPES);
+// Every enforced cap the runner knows: risk + limits + killSwitch + abstention.
+const LIVE_CAPS = [
+    ...Object.keys(RISK_CAPS),
+    ...Object.keys(LIMIT_CAPS),
+    "maxDrawdownMusd",
+    "maxConsecutiveRejects",
+    "maxConsecutiveModelFailures",
+    "onRateLimitPressure",
+    "onStaleData",
+    "onWeakSignal",
+    "onMissingQuote",
+    "onInsufficientBalance",
+    "minConfidence",
+];
+const LIVE_CAP_SET = new Set(LIVE_CAPS);
+// `<venue>_<verb>` action references. The verb is restricted to the runner's
+// real verbs, so descriptive tokens (spot_price, futures_curve) never match —
+// only action-shaped references (real OR plausibly-fake) do.
+const ACTION_RE = /\b(spot|futures|pm)_(open|close|order|cancel|set_sltp)\b/g;
+// camelCase cap-shaped identifiers (maxLeverage, minConfidence, requireStopLoss…).
+const CAP_RE = /\b(?:max|min|require|on|per)[A-Z][A-Za-z0-9]+\b/g;
+// markdown inline code spans — where authors put identifiers.
+const CODESPAN_RE = /`([^`\n]+)`/g;
+// Levenshtein threshold for "this is a typo/rename of a real cap" — matches the
+// strictLint "did you mean" threshold (< 3, i.e. edit distance <= 2).
+const CAP_NEARMISS_MAX = 3;
+function venueOf(action) {
+    return action.split("_")[0];
+}
+// Authored knowledge only: keystone + character/* + skills/*. journal/notes.md is
+// runtime memory and is intentionally NOT checked.
+function authoredProse(resolved) {
+    return resolved.proseParts.filter((p) => p.source !== "journal/notes.md");
+}
+// Returns one issue per (token, source) drift found. Empty = no drift.
+export function checkCapabilityDrift(resolved, spec) {
+    const issues = [];
+    const enabled = new Set(spec.venues);
+    const seen = new Set(); // dedupe "kind|token|source"
+    const once = (key) => {
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    };
+    for (const part of authoredProse(resolved)) {
+        const where = part.source;
+        // ── action references (anywhere in the body) ──
+        for (const m of part.text.matchAll(ACTION_RE)) {
+            const action = m[0];
+            if (!once(`a|${action}|${where}`))
+                continue;
+            if (!KNOWN_ACTIONS.has(action)) {
+                issues.push({
+                    code: "drift_unknown_action",
+                    path: where,
+                    message: `prose references action \`${action}\`, which the runner does not support (allowed: ${ACTION_TYPES.join(", ")})`,
+                });
+            }
+            else {
+                const venue = venueOf(action);
+                if (!enabled.has(venue)) {
+                    issues.push({
+                        code: "drift_venue_not_enabled",
+                        path: where,
+                        message: `prose references \`${action}\` but venue \`${venue}\` is not in this agent's venues [${spec.venues.join(", ")}]`,
+                    });
+                }
+            }
+        }
+        // ── venue + cap references inside code spans only ──
+        for (const span of part.text.matchAll(CODESPAN_RE)) {
+            const inner = span[1];
+            // An exact venue identifier in a code span (e.g. `pm`) that the agent has
+            // not enabled — a prose promise the runner cannot keep.
+            if (VENUES.includes(inner) &&
+                !enabled.has(inner) &&
+                once(`v|${inner}|${where}`)) {
+                issues.push({
+                    code: "drift_venue_not_enabled",
+                    path: where,
+                    message: `prose references venue \`${inner}\` but it is not in this agent's venues [${spec.venues.join(", ")}]`,
+                });
+            }
+            // cap-shaped identifiers — flag only a near-miss of a REAL cap (a typo or
+            // rename); unrelated identifiers are left alone to avoid false positives.
+            for (const cm of inner.matchAll(CAP_RE)) {
+                const token = cm[0];
+                if (LIVE_CAP_SET.has(token))
+                    continue;
+                let nearest = null;
+                let best = CAP_NEARMISS_MAX;
+                for (const cap of LIVE_CAPS) {
+                    const d = levenshtein(token.toLowerCase(), cap.toLowerCase());
+                    if (d < best) {
+                        best = d;
+                        nearest = cap;
+                    }
+                }
+                if (nearest && once(`c|${token}|${where}`)) {
+                    issues.push({
+                        code: "drift_unknown_cap",
+                        path: where,
+                        message: `prose references cap \`${token}\`, which is not a runner cap — did you mean \`${nearest}\`?`,
+                    });
+                }
+            }
+        }
+    }
+    return issues;
+}

package/dist/agent/cli.d.ts

@@ -0,0 +1,21 @@
+import { SkillValidationMode } from "./skillValidator.js";
+export interface CmdResult {
+    ok: boolean;
+    code: number;
+    lines: string[];
+    data?: unknown;
+}
+export declare function cmdNew(targetPath: string, opts?: {
+    template?: string;
+    preset?: string;
+}): CmdResult;
+export declare function cmdValidate(path: string, mode?: SkillValidationMode): CmdResult;
+export declare function cmdLock(path: string): CmdResult;
+export declare function cmdEject(path: string): CmdResult;
+export declare function cmdInspect(path: string, json?: boolean): CmdResult;
+export declare function cmdRun(path: string, opts?: {
+    once?: boolean;
+    live?: boolean;
+    stateFile?: string;
+}): Promise<CmdResult>;
+export declare function main(argv: string[]): Promise<number>;

package/dist/agent/cli.js

@@ -7,15 +7,16 @@
 import { mkdirSync, writeFileSync, existsSync, statSync, readFileSync, openSync, closeSync, unlinkSync, } from "node:fs";
 import { resolve as resolvePath, dirname, join, basename } from "node:path";
 import { parse as parseYaml } from "yaml";
-import { resolveAgent, ResolveError } from "./resolve.js";
+import { resolveAgent, ResolveError, mergeProseParts, isSkillProseSource } from "./resolve.js";
 import { buildSpec, loadAgent } from "./skill.js";
 import { validateSkill } from "./skillValidator.js";
 import { strictLint } from "./strictLint.js";
+import { checkCapabilityDrift } from "./capabilityGuard.js";
 import { buildManifest, writeManifest } from "./manifest.js";
 import { parseFrontmatter } from "./frontmatter.js";
 import { renderFolderOfOne, ejectFiles, PRESET_NAMES } from "./templates.js";
 import { COINRITHM_API } from "./version.js";
-import { stableStringify } from "./util.js";
+import { stableStringify, envFlag } from "./util.js";
 import { CoinRithmClient } from "./client.js";
 import { selectProvider } from "./providers.js";
 import { runLoop } from "./runner.js";
@@ -91,8 +92,8 @@ export function cmdValidate(path, mode = "self-host") {
         throw e;
     }
     const raw = resolved.rawFrontmatter;
-    const lint = strictLint(raw);
     const spec = buildSpec(raw);
+    const lint = [...strictLint(raw), ...checkCapabilityDrift(resolved, spec)];
     const v = validateSkill({ spec, body: resolved.mergedProse, raw }, mode);
     const lintFatal = mode === "hosted";
     const lines = [];
@@ -114,7 +115,17 @@ export function cmdLock(path) {
     const spec = buildSpec(resolved.rawFrontmatter);
     const manifest = buildManifest(resolved, spec);
     const out = writeManifest(agentDirOf(path), manifest);
-    return { ok: true, code: 0, lines: [`wrote ${out}`, `configHash ${manifest.configHash}`] };
+    // Self-host treats capability drift as advisory (not fatal), but locking past
+    // it silently would hide it — surface it so the author isn't surprised when
+    // `validate --hosted` later rejects the same folder.
+    const drift = (v.data?.lint ?? []).filter((i) => i.code.startsWith("drift_"));
+    const warn = drift.length
+        ? [
+            `⚠ locked with ${drift.length} advisory capability-drift note(s) — \`validate --hosted\` would reject these:`,
+            ...drift.map((i) => `  [${i.code}] ${i.path ? `${i.path}: ` : ""}${i.message}`),
+        ]
+        : [];
+    return { ok: true, code: 0, lines: [`wrote ${out}`, `configHash ${manifest.configHash}`, ...warn] };
 }
 export function cmdEject(path) {
     const agentDir = agentDirOf(path);
@@ -159,7 +170,7 @@ export function cmdInspect(path, json = false) {
         throw e;
     }
     const spec = buildSpec(resolved.rawFrontmatter);
-    const lint = strictLint(resolved.rawFrontmatter);
+    const lint = [...strictLint(resolved.rawFrontmatter), ...checkCapabilityDrift(resolved, spec)];
     const v = validateSkill({ spec, body: resolved.mergedProse, raw: resolved.rawFrontmatter }, "self-host");
     const output = {
         resolvedConfig: resolved.rawFrontmatter,
@@ -258,11 +269,22 @@ export async function cmdRun(path, opts = {}) {
         const lines = [
             `run ${live ? "LIVE (paper trades WILL be placed)" : "DRY-RUN (no writes; set --live or LIVE=1)"} — ${loaded.spec.name}`,
         ];
+        // Skills ablation kill-switch: drop tactic-skill prose from the prompt for
+        // token-cost control or A/B testing. Affects ONLY the run-time prompt — the
+        // resolver, manifest, and caps are untouched (the spec is still enforced).
+        const disableSkills = envFlag(process.env.COINRITHM_AGENT_DISABLE_SKILLS);
+        const mergedProse = disableSkills
+            ? mergeProseParts(loaded.resolved.proseParts.filter((p) => !isSkillProseSource(p.source)))
+            : loaded.body;
+        if (disableSkills) {
+            const dropped = loaded.resolved.proseParts.filter((p) => isSkillProseSource(p.source)).length;
+            lines.push(`skills DISABLED via COINRITHM_AGENT_DISABLE_SKILLS — ${dropped} tactic skill(s) dropped from the prompt (caps unchanged)`);
+        }
         const deps = {
             client,
             provider,
             spec: loaded.spec,
-            mergedProse: loaded.body,
+            mergedProse,
             state,
             live,
             stateFile,

package/dist/agent/client.d.ts

@@ -0,0 +1,107 @@
+import { AgentTrace, ApiResult } from "./types.js";
+export declare const DEFAULT_BASE_URL = "https://api.coinrithm.com";
+export interface ClientConfig {
+    apiKey: string;
+    baseUrl?: string;
+    fetchFn?: typeof fetch;
+    sleepFn?: (ms: number) => Promise<void>;
+    maxRetries?: number;
+}
+export declare class CoinRithmClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly fetchFn;
+    private readonly sleepFn;
+    private readonly maxRetries;
+    rateLimitHits: number;
+    constructor(cfg: ClientConfig);
+    private request;
+    me(trace?: AgentTrace): Promise<ApiResult>;
+    portfolio(trace?: AgentTrace): Promise<ApiResult>;
+    wallet(query?: {
+        coinId?: string;
+    }, trace?: AgentTrace): Promise<ApiResult>;
+    resolve(q: string, trace?: AgentTrace): Promise<ApiResult>;
+    market(coinId: string, trace?: AgentTrace): Promise<ApiResult>;
+    candles(coinId: string, range: string, trace?: AgentTrace): Promise<ApiResult>;
+    trades(query?: {
+        venue?: string;
+        limit?: number;
+        updatedSince?: string;
+    }, trace?: AgentTrace): Promise<ApiResult>;
+    futuresPositions(query?: {
+        updatedSince?: string;
+    }, trace?: AgentTrace): Promise<ApiResult>;
+    futuresQuote(body: {
+        coinId: string;
+        side: string;
+        leverage: number;
+        marginMusd: number;
+    }, trace?: AgentTrace): Promise<ApiResult>;
+    openOrders(query?: {
+        coinId?: string;
+        updatedSince?: string;
+    }, trace?: AgentTrace): Promise<ApiResult>;
+    spotQuote(body: {
+        coinId: string;
+        side: string;
+        quantity: number;
+    }, trace?: AgentTrace): Promise<ApiResult>;
+    discoverPmMarkets(query?: {
+        q?: string;
+        source?: string;
+        limit?: number;
+    }, trace?: AgentTrace): Promise<ApiResult>;
+    pmPositions(query?: {
+        updatedSince?: string;
+    }, trace?: AgentTrace): Promise<ApiResult>;
+    pmQuote(body: {
+        source: string;
+        slug: string;
+        outcomeExternalMarketId: string;
+        stakeMusd: number;
+    }, trace?: AgentTrace): Promise<ApiResult>;
+    openFutures(body: {
+        coinId: string;
+        side: string;
+        leverage: number;
+        marginMusd: number;
+        idempotencyKey: string;
+        stopLossPrice?: number | null;
+        takeProfitPrice?: number | null;
+        agentTrace?: AgentTrace;
+    }): Promise<ApiResult>;
+    closeFutures(body: {
+        positionId: number;
+        fraction?: number;
+        idempotencyKey: string;
+        agentTrace?: AgentTrace;
+    }): Promise<ApiResult>;
+    setFuturesSlTp(body: {
+        positionId: number;
+        stopLossPrice?: number | null;
+        takeProfitPrice?: number | null;
+        agentTrace?: AgentTrace;
+    }): Promise<ApiResult>;
+    placeSpotOrder(body: {
+        coinId: string;
+        side: string;
+        orderType: string;
+        quantity: number;
+        limitPrice?: number;
+        stopPrice?: number;
+        idempotencyKey: string;
+        agentTrace?: AgentTrace;
+    }): Promise<ApiResult>;
+    cancelSpotOrder(orderId: number, trace?: AgentTrace): Promise<ApiResult>;
+    openPmPosition(body: {
+        source: string;
+        slug: string;
+        outcomeExternalMarketId: string;
+        stakeMusd: number;
+        idempotencyKey: string;
+        agentTrace?: AgentTrace;
+    }): Promise<ApiResult>;
+    exportRunEvidence(runId: string): Promise<ApiResult>;
+}
+export declare function isFailClosed(status: number): boolean;

package/dist/agent/client.js

@@ -125,6 +125,23 @@ export class CoinRithmClient {
     futuresQuote(body, trace) {
         return this.request("POST", "/api/agent/futures/quote", { body: { ...body, agentTrace: trace } });
     }
+    // ── spot ─────────────────────────────────────────────────────────────────
+    openOrders(query, trace) {
+        return this.request("GET", "/api/agent/orders/open", { query, trace });
+    }
+    spotQuote(body, trace) {
+        return this.request("POST", "/api/agent/spot/quote", { body: { ...body, agentTrace: trace } });
+    }
+    // ── prediction markets ───────────────────────────────────────────────────
+    discoverPmMarkets(query, trace) {
+        return this.request("GET", "/api/agent/pm/discover", { query, trace });
+    }
+    pmPositions(query, trace) {
+        return this.request("GET", "/api/agent/positions/pm", { query, trace });
+    }
+    pmQuote(body, trace) {
+        return this.request("POST", "/api/agent/pm/quote", { body: { ...body, agentTrace: trace } });
+    }
     // ── writes ─────────────────────────────────────────────────────────────────
     openFutures(body) {
         return this.request("POST", "/api/agent/futures/open", { body });
@@ -135,6 +152,15 @@ export class CoinRithmClient {
     setFuturesSlTp(body) {
         return this.request("POST", "/api/agent/futures/sl-tp", { body });
     }
+    placeSpotOrder(body) {
+        return this.request("POST", "/api/agent/spot/order", { body });
+    }
+    cancelSpotOrder(orderId, trace) {
+        return this.request("POST", `/api/agent/spot/order/${orderId}/cancel`, { trace });
+    }
+    openPmPosition(body) {
+        return this.request("POST", "/api/agent/pm/open", { body });
+    }
     // Run-evidence export — runId is URL-encoded into the query.
     exportRunEvidence(runId) {
         return this.request("GET", "/api/agent/ledger/export", { query: { runId } });

package/dist/agent/decision.d.ts

@@ -0,0 +1,137 @@
+import { z } from "zod";
+import { Decision } from "./types.js";
+export declare const actionSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"futures_open">;
+    symbol: z.ZodString;
+    side: z.ZodEnum<["long", "short"]>;
+    leverage: z.ZodNumber;
+    marginMusd: z.ZodNumber;
+    stopLossPrice: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    takeProfitPrice: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    rationaleSummary: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    symbol: string;
+    side: "long" | "short";
+    leverage: number;
+    marginMusd: number;
+    type: "futures_open";
+    stopLossPrice?: number | null | undefined;
+    takeProfitPrice?: number | null | undefined;
+    confidence?: number | undefined;
+    rationaleSummary?: string | undefined;
+}, {
+    symbol: string;
+    side: "long" | "short";
+    leverage: number;
+    marginMusd: number;
+    type: "futures_open";
+    stopLossPrice?: number | null | undefined;
+    takeProfitPrice?: number | null | undefined;
+    confidence?: number | undefined;
+    rationaleSummary?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"futures_close">;
+    positionId: z.ZodNumber;
+    fraction: z.ZodOptional<z.ZodNumber>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    rationaleSummary: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    positionId: number;
+    type: "futures_close";
+    fraction?: number | undefined;
+    confidence?: number | undefined;
+    rationaleSummary?: string | undefined;
+}, {
+    positionId: number;
+    type: "futures_close";
+    fraction?: number | undefined;
+    confidence?: number | undefined;
+    rationaleSummary?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"futures_set_sltp">;
+    positionId: z.ZodNumber;
+    stopLossPrice: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    takeProfitPrice: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, "strict", z.ZodTypeAny, {
+    positionId: number;
+    type: "futures_set_sltp";
+    stopLossPrice?: number | null | undefined;
+    takeProfitPrice?: number | null | undefined;
+}, {
+    positionId: number;
+    type: "futures_set_sltp";
+    stopLossPrice?: number | null | undefined;
+    takeProfitPrice?: number | null | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"spot_order">;
+    symbol: z.ZodString;
+    side: z.ZodEnum<["buy", "sell"]>;
+    orderType: z.ZodEnum<["market", "limit", "stop"]>;
+    quantity: z.ZodNumber;
+    limitPrice: z.ZodOptional<z.ZodNumber>;
+    stopPrice: z.ZodOptional<z.ZodNumber>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    rationaleSummary: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    symbol: string;
+    side: "buy" | "sell";
+    orderType: "limit" | "market" | "stop";
+    quantity: number;
+    type: "spot_order";
+    limitPrice?: number | undefined;
+    stopPrice?: number | undefined;
+    confidence?: number | undefined;
+    rationaleSummary?: string | undefined;
+}, {
+    symbol: string;
+    side: "buy" | "sell";
+    orderType: "limit" | "market" | "stop";
+    quantity: number;
+    type: "spot_order";
+    limitPrice?: number | undefined;
+    stopPrice?: number | undefined;
+    confidence?: number | undefined;
+    rationaleSummary?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"spot_cancel">;
+    orderId: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    type: "spot_cancel";
+    orderId: number;
+}, {
+    type: "spot_cancel";
+    orderId: number;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"pm_open">;
+    source: z.ZodString;
+    slug: z.ZodString;
+    outcomeExternalMarketId: z.ZodString;
+    stakeMusd: z.ZodNumber;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    rationaleSummary: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    source: string;
+    slug: string;
+    outcomeExternalMarketId: string;
+    stakeMusd: number;
+    type: "pm_open";
+    confidence?: number | undefined;
+    rationaleSummary?: string | undefined;
+}, {
+    source: string;
+    slug: string;
+    outcomeExternalMarketId: string;
+    stakeMusd: number;
+    type: "pm_open";
+    confidence?: number | undefined;
+    rationaleSummary?: string | undefined;
+}>]>;
+export type ParseDecisionResult = {
+    ok: true;
+    decision: Decision;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function parseDecision(text: string): ParseDecisionResult;