@coinrithm/mcp-trading 0.2.0 → 0.4.0

package/dist/agent/runner.js

@@ -1,14 +1,15 @@
-// The execution loop: observe -> decide (BYO model) -> validate -> act. v1
-// futures only. Dry-run never writes. Live uses idempotency keys + agentTrace
-// and exports run evidence. The client + provider are injected so the loop is
-// fully unit-testable with no network and no model calls.
+// The execution loop: observe -> decide (BYO model) -> validate -> act across
+// spot, futures, and prediction markets. Dry-run never writes. Live uses
+// idempotency keys + agentTrace and exports run evidence. The client + provider
+// are injected so the loop is fully unit-testable with no network/model calls.
+import { spotBuyCost, } from "./types.js";
 import { observe } from "./observe.js";
 import { buildSystemPrompt, buildUserPrompt } from "./prompt.js";
 import { parseDecision } from "./decision.js";
 import { validateAction } from "./decisionValidator.js";
 import { fetchQuote, executeAction } from "./act.js";
 import { makeDecisionId, makeTrace, exportRunEvidence } from "./runEvidence.js";
-import { rollDay, checkKillSwitch, accrueRealized, saveState } from "./state.js";
+import { rollDay, checkKillSwitch, accrueRealized, saveState, } from "./state.js";
 import { asObj, asNum, asStr } from "./extract.js";
 import { parseCadenceMs, sleep } from "./util.js";
 // A stable idempotency-key component per distinct intent (so a lost response
@@ -23,7 +24,33 @@ function intentKeyOf(action) {
     if (action.type === "futures_set_sltp") {
         return `sltp:${action.positionId}`;
     }
-    return `other:${action.type}`; // unreachable: only futures actions are executed
+    if (action.type === "spot_order") {
+        return `spot:${action.symbol.toUpperCase()}:${action.side}:${action.orderType}:${action.quantity}:${action.limitPrice ?? ""}:${action.stopPrice ?? ""}`;
+    }
+    if (action.type === "spot_cancel") {
+        return `cancel:${action.orderId}`;
+    }
+    if (action.type === "pm_open") {
+        return `pm:${action.source.toLowerCase()}:${action.slug.toLowerCase()}:${action.outcomeExternalMarketId}:${action.stakeMusd}`;
+    }
+    return "other"; // unreachable: every action type is handled above
+}
+// Estimated cash a successful action consumes (for the running-cash guard):
+// futures margin, spot buy notional, or a PM stake. Closes/cancels/sells free
+// cash or are neutral, so they consume nothing here. Spot buys use the SAME
+// `spotBuyCost` helper the validator gates on, so the gate and this decrement
+// never diverge. The `?? 0` is unreachable for an EXECUTED buy: the validator
+// fails closed (missing_quote_price) on any buy whose cost can't be sized, so
+// nothing with an undefined cost ever reaches execution to be decremented.
+function cashConsumed(action, quote) {
+    if (action.type === "futures_open")
+        return action.marginMusd;
+    if (action.type === "pm_open")
+        return action.stakeMusd;
+    if (action.type === "spot_order" && action.side === "buy") {
+        return spotBuyCost(action, quote) ?? 0;
+    }
+    return 0;
 }
 export async function runCycle(deps) {
     const { client, provider, spec, mergedProse, state, live, stateFile } = deps;
@@ -37,7 +64,13 @@ export async function runCycle(deps) {
         state.disabledReason = tripped;
         saveState(stateFile, state);
         log(`disabled: ${tripped}`);
-        return { decision: "skip", planned: [], disabled: true, disabledReason: tripped, live };
+        return {
+            decision: "skip",
+            planned: [],
+            disabled: true,
+            disabledReason: tripped,
+            live,
+        };
     }
     const runId = state.runId;
     const decisionId = makeDecisionId(state.cyclesRun);
@@ -55,12 +88,19 @@ export async function runCycle(deps) {
     // not only realized losses.
     const unrealized = observation.openPositions.reduce((s, p) => s + (p.unrealizedPnlMusd ?? 0), 0);
     if (spec.killSwitch.maxDrawdownMusd > 0 &&
-        state.peakRealizedMusd - (state.realizedPnlMusd + unrealized) >= spec.killSwitch.maxDrawdownMusd) {
+        state.peakRealizedMusd - (state.realizedPnlMusd + unrealized) >=
+            spec.killSwitch.maxDrawdownMusd) {
         state.disabled = true;
         state.disabledReason = `equity drawdown >= ${spec.killSwitch.maxDrawdownMusd}`;
         saveState(stateFile, state);
         log(`disabled: ${state.disabledReason}`);
-        return { decision: "skip", planned: [], disabled: true, disabledReason: state.disabledReason, live };
+        return {
+            decision: "skip",
+            planned: [],
+            disabled: true,
+            disabledReason: state.disabledReason,
+            live,
+        };
     }
     if (obs.skip) {
         state.consecutiveRejectCycles += 1;
@@ -77,14 +117,26 @@ export async function runCycle(deps) {
         state.consecutiveModelFailures += 1;
         saveState(stateFile, state);
         log(`model error: ${res.error}`);
-        return { decision: "skip", skipReason: `model error: ${res.error}`, planned: [], modelFailed: true, live };
+        return {
+            decision: "skip",
+            skipReason: `model error: ${res.error}`,
+            planned: [],
+            modelFailed: true,
+            live,
+        };
     }
     const parsed = parseDecision(res.text);
     if (!parsed.ok) {
         state.consecutiveModelFailures += 1;
         saveState(stateFile, state);
         log(`model output invalid: ${parsed.error}`);
-        return { decision: "skip", skipReason: `model output invalid: ${parsed.error}`, planned: [], modelFailed: true, live };
+        return {
+            decision: "skip",
+            skipReason: `model output invalid: ${parsed.error}`,
+            planned: [],
+            modelFailed: true,
+            live,
+        };
     }
     state.consecutiveModelFailures = 0;
     const decision = parsed.decision;
@@ -92,7 +144,12 @@ export async function runCycle(deps) {
         state.consecutiveRejectCycles += 1;
         saveState(stateFile, state);
         log(`model chose skip${decision.reason ? `: ${decision.reason}` : ""}`);
-        return { decision: "skip", skipReason: decision.reason ?? "model chose skip", planned: [], live };
+        return {
+            decision: "skip",
+            skipReason: decision.reason ?? "model chose skip",
+            planned: [],
+            live,
+        };
     }
     // VALIDATE (+ ACT when live). Quote evidence is fetched by the runner.
     const planned = [];
@@ -105,6 +162,7 @@ export async function runCycle(deps) {
     let cashAvailableMusd = observation.cashAvailableMusd;
     const realizedLossTodayMusd = Math.max(0, -state.realizedPnlTodayMusd);
     const targetedPositionIds = [];
+    const targetedOrderIds = [];
     let anyAccepted = false;
     let anyExecuted = false;
     let anyExecFailed = false;
@@ -112,6 +170,10 @@ export async function runCycle(deps) {
         const quote = await fetchQuote(client, action, observation, baseTrace);
         const ctx = {
             spec,
+            // Inherit the decision-level confidence so the per-action abstention gate
+            // doesn't reject a model that reports conviction on the decision (the
+            // output contract) rather than on each action.
+            decisionConfidence: decision.confidence,
             observation,
             quote,
             writesThisCycle,
@@ -121,10 +183,17 @@ export async function runCycle(deps) {
             openMarginMusd,
             realizedLossTodayMusd,
             targetedPositionIds,
+            targetedOrderIds,
         };
         const v = validateAction(action, ctx);
         if (!v.valid) {
-            planned.push({ action, accepted: false, code: v.code, reason: v.reason, quote });
+            planned.push({
+                action,
+                accepted: false,
+                code: v.code,
+                reason: v.reason,
+                quote,
+            });
             log(`reject ${action.type}: ${v.code} (${v.reason})`);
             continue;
         }
@@ -132,6 +201,9 @@ export async function runCycle(deps) {
         if (action.type === "futures_close" || action.type === "futures_set_sltp") {
             targetedPositionIds.push(action.positionId);
         }
+        if (action.type === "spot_cancel") {
+            targetedOrderIds.push(action.orderId);
+        }
         if (!live) {
             planned.push({ action, accepted: true, quote, executed: false });
             log(`DRY-RUN: would ${action.type}`);
@@ -143,9 +215,15 @@ export async function runCycle(deps) {
         const seq = state.intentSeq[intentKey] ?? 0;
         const idem = `${runId}:${intentKey}:${seq}`;
         const meta = action;
-        const trace = makeTrace(runId, decisionId, spec, meta.confidence, meta.rationaleSummary);
+        const trace = makeTrace(runId, decisionId, spec, meta.confidence ?? decision.confidence, meta.rationaleSummary);
         const r = await executeAction(client, action, observation, trace, idem);
-        planned.push({ action, accepted: true, quote, executed: r.ok, result: r.data });
+        planned.push({
+            action,
+            accepted: true,
+            quote,
+            executed: r.ok,
+            result: r.data,
+        });
         if (r.ok) {
             anyExecuted = true;
             state.intentSeq[intentKey] = seq + 1;
@@ -154,9 +232,11 @@ export async function runCycle(deps) {
             if (action.type === "futures_open") {
                 openCount += 1;
                 openMarginMusd += action.marginMusd;
-                if (cashAvailableMusd != null)
-                    cashAvailableMusd -= action.marginMusd;
             }
+            // Decrement running cash by what this action consumed (futures margin /
+            // spot buy notional / PM stake) so a later action this cycle sees it spent.
+            if (cashAvailableMusd != null)
+                cashAvailableMusd -= cashConsumed(action, quote);
         }
         else {
             anyExecFailed = true;
@@ -167,8 +247,11 @@ export async function runCycle(deps) {
     // live write is not progress, or a persistently failing live agent would
     // never trip the kill-switch.
     const progressed = live ? anyExecuted : anyAccepted;
-    state.consecutiveRejectCycles = progressed ? 0 : state.consecutiveRejectCycles + 1;
-    state.consecutiveExecFailures = anyExecFailed && !anyExecuted ? state.consecutiveExecFailures + 1 : 0;
+    state.consecutiveRejectCycles = progressed
+        ? 0
+        : state.consecutiveRejectCycles + 1;
+    state.consecutiveExecFailures =
+        anyExecFailed && !anyExecuted ? state.consecutiveExecFailures + 1 : 0;
     state.rateLimitHits = client.rateLimitHits ?? state.rateLimitHits;
     saveState(stateFile, state);
     if (live && anyExecuted)

package/dist/agent/scorecard.d.ts

@@ -0,0 +1,24 @@
+export interface ScorecardInput {
+    realizedPnls: number[];
+    cumulative?: number[];
+    returns?: number[];
+    annualizationFactor?: number;
+    trials?: number;
+    predictions?: Array<{
+        p: number;
+        outcome: 0 | 1;
+    }>;
+    gates?: {
+        stopCoverage?: number;
+        evidenceCoverage?: number;
+        leakageClean?: boolean;
+    };
+}
+export interface Scorecard {
+    schema: "coinrithm.agent.scorecard.v1";
+    sampleSize: number;
+    returnsBasis: "returns" | "realized_pnl";
+    metrics: Record<string, number | null>;
+    contentHash: string;
+}
+export declare function computeScorecard(input: ScorecardInput): Scorecard;

package/dist/agent/scorecard.js

@@ -0,0 +1,177 @@
+// Deterministic scorecard engine — pure math over an agent's realized track
+// record. The reproducible-evaluation half of coinrithm.agent.scorecard.v1
+// (see examples/agents/_shared/scorecard.metrics.yaml + DECISIONS D17).
+//
+// DETERMINISM CONTRACT: the same inputs always yield the same metrics AND the
+// same contentHash (sha256 of the canonicalized result), mirroring
+// meta/manifest.lock.json. The engine NEVER calls the network or the model — it
+// reads the run-evidence ledger export + realized equity curve (fetched by the
+// caller) and computes, so tuning-to-the-metric is structurally impossible
+// (leakage separation, arXiv 2512.02227). Every function returns null when there
+// is too little data, so a thin record reports "n/a" rather than a fake number.
+//
+// SCIENTIFIC BASIS: risk-adjusted ratios (Sharpe/Sortino), skill-vs-luck
+// deflation (probabilistic + deflated Sharpe, Bailey & Lopez de Prado), and
+// calibration (Brier/ECE) for probabilistic calls — the reproducible-evaluation
+// layer the field lacks (arXiv 2605.19337).
+import { createHash } from "node:crypto";
+const round = (n, d = 6) => {
+    const f = 10 ** d;
+    return Math.round(n * f) / f;
+};
+const sum = (xs) => xs.reduce((a, b) => a + b, 0);
+const mean = (xs) => (xs.length ? sum(xs) / xs.length : 0);
+// Sample standard deviation (n-1). null for < 2 points (undefined dispersion).
+function sampleStd(xs) {
+    if (xs.length < 2)
+        return null;
+    const m = mean(xs);
+    const v = sum(xs.map((x) => (x - m) ** 2)) / (xs.length - 1);
+    return Math.sqrt(v);
+}
+// Downside deviation about a 0 minimum-acceptable-return (Sortino denominator).
+function downsideDev(xs) {
+    if (xs.length < 2)
+        return null;
+    const sq = xs.map((x) => (x < 0 ? x * x : 0));
+    return Math.sqrt(sum(sq) / xs.length);
+}
+// Population moments used by the (probabilistic) Sharpe formula.
+function moment(xs, k) {
+    const m = mean(xs);
+    return sum(xs.map((x) => (x - m) ** k)) / xs.length;
+}
+// Standard normal CDF via an Abramowitz & Stegun erf approximation (max err ~1e-7).
+function normalCdf(z) {
+    const t = 1 / (1 + 0.2316419 * Math.abs(z));
+    const d = 0.3989422804014327 * Math.exp(-(z * z) / 2);
+    const p = d *
+        t *
+        (0.31938153 +
+            t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))));
+    return z >= 0 ? 1 - p : p;
+}
+// Max peak-to-trough drawdown (mUSD, >= 0) on a cumulative series.
+function maxDrawdown(cumulative) {
+    let peak = -Infinity;
+    let maxDd = 0;
+    for (const c of cumulative) {
+        if (!Number.isFinite(c))
+            continue;
+        peak = Math.max(peak, c);
+        maxDd = Math.max(maxDd, peak - c);
+    }
+    return Number.isFinite(maxDd) ? maxDd : 0;
+}
+// Per-observation Sharpe (mean/std), the basis for the probabilistic SR test.
+function rawSharpe(rs) {
+    const sd = sampleStd(rs);
+    if (sd == null || sd === 0)
+        return null;
+    return mean(rs) / sd;
+}
+// Probabilistic / deflated Sharpe (Bailey & Lopez de Prado, approximated).
+// PSR(SR0) = Phi( (SR - SR0) * sqrt(n-1) / sqrt(1 - skew*SR + ((kurt-1)/4)*SR^2) ).
+// Deflation: SR0 = sqrt(2*ln(trials)) / sqrt(n) — the expected max per-obs Sharpe
+// of `trials` random strategies (extreme-value heuristic). trials=1 -> SR0=0, so
+// it reduces to the probabilistic Sharpe (already penalizing short, skewed tracks).
+function deflatedSharpe(rs, trials) {
+    const n = rs.length;
+    if (n < 3)
+        return null;
+    const sr = rawSharpe(rs);
+    if (sr == null)
+        return null;
+    const m2 = moment(rs, 2);
+    if (m2 === 0)
+        return null;
+    const skew = moment(rs, 3) / m2 ** 1.5;
+    const kurt = moment(rs, 4) / m2 ** 2; // 3 for a normal distribution
+    const denom = Math.sqrt(Math.max(1e-9, 1 - skew * sr + ((kurt - 1) / 4) * sr * sr));
+    const sr0 = Math.sqrt(2 * Math.log(Math.max(1, trials))) / Math.sqrt(n);
+    const z = ((sr - sr0) * Math.sqrt(n - 1)) / denom;
+    return normalCdf(z);
+}
+// Brier score: mean((p - outcome)^2). Lower = better-calibrated.
+function brier(preds) {
+    if (preds.length === 0)
+        return null;
+    return mean(preds.map((x) => (x.p - x.outcome) ** 2));
+}
+// Expected calibration error over 10 equal-width probability buckets.
+function ece(preds) {
+    if (preds.length === 0)
+        return null;
+    const buckets = 10;
+    let total = 0;
+    for (let b = 0; b < buckets; b += 1) {
+        const lo = b / buckets;
+        const hi = (b + 1) / buckets;
+        const inB = preds.filter((x) => (b === buckets - 1 ? x.p >= lo && x.p <= hi : x.p >= lo && x.p < hi));
+        if (inB.length === 0)
+            continue;
+        const avgP = mean(inB.map((x) => x.p));
+        const avgO = mean(inB.map((x) => x.outcome));
+        total += (inB.length / preds.length) * Math.abs(avgP - avgO);
+    }
+    return total;
+}
+export function computeScorecard(input) {
+    const pnls = input.realizedPnls.filter(Number.isFinite);
+    const n = pnls.length;
+    const wins = pnls.filter((x) => x > 0);
+    const losses = pnls.filter((x) => x < 0);
+    const decided = wins.length + losses.length;
+    const grossWin = sum(wins);
+    const grossLoss = Math.abs(sum(losses));
+    const avgWin = wins.length ? grossWin / wins.length : 0;
+    const avgLoss = losses.length ? grossLoss / losses.length : 0;
+    const pWin = decided ? wins.length / decided : null;
+    const rs = input.returns && input.returns.length ? input.returns.filter(Number.isFinite) : pnls;
+    const returnsBasis = input.returns && input.returns.length ? "returns" : "realized_pnl";
+    const ann = input.annualizationFactor ?? 1;
+    const cumulative = input.cumulative && input.cumulative.length
+        ? input.cumulative
+        : pnls.reduce((acc, x) => {
+            acc.push((acc.length ? acc[acc.length - 1] : 0) + x);
+            return acc;
+        }, []);
+    const sd = sampleStd(rs);
+    const dd = downsideDev(rs);
+    const sharpe = sd && sd !== 0 ? (mean(rs) / sd) * ann : null;
+    const sortino = dd && dd !== 0 ? (mean(rs) / dd) * ann : null;
+    const metrics = {
+        realized_pnl_musd: round(sum(pnls)),
+        trade_count: n,
+        decided_count: decided,
+        win_rate: pWin == null ? null : round(pWin),
+        expectancy_musd: pWin == null ? null : round(pWin * avgWin - (1 - pWin) * avgLoss),
+        profit_factor: grossLoss > 0 ? round(grossWin / grossLoss) : grossWin > 0 ? null : 0, // null = ∞ (no losses)
+        reward_to_risk: avgLoss > 0 ? round(avgWin / avgLoss) : null,
+        sharpe: sharpe == null ? null : round(sharpe),
+        sortino: sortino == null ? null : round(sortino),
+        deflated_sharpe: round0(deflatedSharpe(rs, input.trials ?? 1)),
+        max_drawdown_musd: round(maxDrawdown(cumulative)),
+        brier_score: round0(brier(input.predictions ?? [])),
+        calibration_error: round0(ece(input.predictions ?? [])),
+        stop_coverage: input.gates?.stopCoverage ?? null,
+        evidence_coverage: input.gates?.evidenceCoverage ?? null,
+        leakage_clean: input.gates?.leakageClean == null ? null : input.gates.leakageClean ? 1 : 0,
+    };
+    // Canonicalize (sorted keys) and hash, so the report card carries a stable,
+    // verifiable fingerprint — a scorecard whose hash does not reproduce is not trusted.
+    const canonical = JSON.stringify(Object.keys(metrics)
+        .sort()
+        .map((k) => [k, metrics[k]]));
+    const contentHash = createHash("sha256").update(canonical).digest("hex");
+    return {
+        schema: "coinrithm.agent.scorecard.v1",
+        sampleSize: n,
+        returnsBasis,
+        metrics,
+        contentHash,
+    };
+}
+function round0(n) {
+    return n == null ? null : round(n);
+}

package/dist/agent/skill.d.ts

@@ -0,0 +1,12 @@
+import { AgentSpec, ParsedSkill, ResolvedAgent, ResolveIssue } from "./types.js";
+export declare function buildSpec(raw: Record<string, unknown>): AgentSpec;
+export declare function parseSkill(text: string): ParsedSkill;
+export declare function loadSkill(path: string): ParsedSkill;
+export interface LoadedAgent {
+    resolved: ResolvedAgent;
+    spec: AgentSpec;
+    body: string;
+    raw: Record<string, unknown>;
+    lint: ResolveIssue[];
+}
+export declare function loadAgent(inputPath: string, mode?: "self-host" | "hosted"): LoadedAgent;

package/dist/agent/skill.js

@@ -3,6 +3,7 @@ import { parseFrontmatter } from "./frontmatter.js";
 import { VENUES, PROVIDERS, ALLOWED_CAPABILITIES, } from "./types.js";
 import { resolveAgent, ResolveError } from "./resolve.js";
 import { strictLint } from "./strictLint.js";
+import { checkCapabilityDrift } from "./capabilityGuard.js";
 // Safe defaults for the OPTIONAL policy blocks. A minimal self-host skill
 // (name/description/spec/trigger/model/venues/risk) runs under these. Hosted
 // mode requires them to be explicit (see skillValidator).
@@ -83,6 +84,7 @@ export function buildSpec(raw) {
             maxConcurrentPositions: num(risk.maxConcurrentPositions, 0),
             requireStopLoss: bool(risk.requireStopLoss, true),
             watchlist: strArr(risk.watchlist),
+            blocklist: strArr(risk.blocklist),
         },
         limits: {
             maxTradesPerDay: num(limits.maxTradesPerDay, DEFAULT_LIMITS.maxTradesPerDay),
@@ -124,9 +126,11 @@ export function loadSkill(path) {
 export function loadAgent(inputPath, mode = "self-host") {
     const resolved = resolveAgent(inputPath);
     const raw = resolved.rawFrontmatter;
-    const lint = strictLint(raw);
+    const spec = buildSpec(raw);
+    // strictLint = frontmatter keys/enums; capability drift = prose references to
+    // venues/actions/caps the runner (or this agent's venues) does not support.
+    const lint = [...strictLint(raw), ...checkCapabilityDrift(resolved, spec)];
     if (mode === "hosted" && lint.length)
         throw new ResolveError(lint);
-    const spec = buildSpec(raw);
     return { resolved, spec, body: resolved.mergedProse, raw, lint };
 }

package/dist/agent/skillValidator.d.ts

@@ -0,0 +1,7 @@
+import { ParsedSkill, ValidationResult } from "./types.js";
+export type SkillValidationMode = "self-host" | "hosted";
+export interface SkillValidation {
+    valid: boolean;
+    issues: ValidationResult[];
+}
+export declare function validateSkill(parsed: ParsedSkill, mode?: SkillValidationMode): SkillValidation;

package/dist/agent/state.d.ts

@@ -0,0 +1,7 @@
+import { RunState, AgentSpec } from "./types.js";
+export declare function newState(runId: string): RunState;
+export declare function loadState(file: string | undefined, runId: string): RunState;
+export declare function saveState(file: string | undefined, state: RunState): void;
+export declare function rollDay(state: RunState): RunState;
+export declare function accrueRealized(state: RunState, closedTrades: Record<string, unknown>[]): void;
+export declare function checkKillSwitch(spec: AgentSpec, state: RunState): string | null;

package/dist/agent/state.js

@@ -42,7 +42,9 @@ export function loadState(file, runId) {
             ...base,
             ...parsed,
             seen: Array.isArray(parsed.seen) ? parsed.seen : [],
-            intentSeq: parsed.intentSeq && typeof parsed.intentSeq === "object" ? parsed.intentSeq : {},
+            intentSeq: parsed.intentSeq && typeof parsed.intentSeq === "object" && !Array.isArray(parsed.intentSeq)
+                ? parsed.intentSeq
+                : {},
         });
     }
     return newState(runId);

package/dist/agent/strictLint.d.ts

@@ -0,0 +1,3 @@
+import { ResolveIssue } from "./types.js";
+export declare function levenshtein(a: string, b: string): number;
+export declare function strictLint(raw: Record<string, unknown>): ResolveIssue[];

package/dist/agent/strictLint.js

@@ -34,6 +34,7 @@ const ALLOWED_KEYS = {
         "maxConcurrentPositions",
         "requireStopLoss",
         "watchlist",
+        "blocklist",
     ],
     sizing: null,
     limits: [
@@ -58,7 +59,7 @@ const ALLOWED_KEYS = {
     ],
     objective: ["primary", "secondary", "horizon"],
 };
-function levenshtein(a, b) {
+export function levenshtein(a, b) {
     const m = a.length;
     const n = b.length;
     const d = Array.from({ length: n + 1 }, (_, i) => i);

package/dist/agent/templates.d.ts

@@ -0,0 +1,14 @@
+export type PresetName = "conservative" | "balanced" | "bold";
+export declare const PRESET_NAMES: PresetName[];
+export interface AgentTemplate {
+    frontmatter: Record<string, unknown>;
+    body: string;
+}
+export declare function buildAgentObject(name: string, preset: PresetName): AgentTemplate;
+export declare function renderFolderOfOne(name: string, preset: PresetName): string;
+export declare function renderCoinrithmPin(): string;
+export declare function renderRuntime(model: unknown, trigger: unknown): string;
+export interface EjectResult {
+    files: Record<string, string>;
+}
+export declare function ejectFiles(fm: Record<string, unknown>, body: string): EjectResult;