@coinrithm/mcp-trading 0.2.0 → 0.3.0

package/dist/agent/decision.js

@@ -1,7 +1,7 @@
 // Parse the model's single text response into a strict, structured Decision.
-// v1 accepts FUTURES actions only. Anything else — invalid JSON, an unknown
-// action type, a free-form endpoint/tool name, extra unknown fields, or a
-// missing required field — fails closed (the runner then skips the cycle).
+// Accepts futures + spot + prediction-market actions. Anything else — invalid
+// 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";
 const futuresOpen = z
     .object({
@@ -33,10 +33,43 @@ const futuresSetSltp = z
     takeProfitPrice: z.number().nullable().optional(),
 })
     .strict();
-const actionSchema = z.discriminatedUnion("type", [
+const spotOrder = z
+    .object({
+    type: z.literal("spot_order"),
+    symbol: z.string().min(1),
+    side: z.enum(["buy", "sell"]),
+    orderType: z.enum(["market", "limit", "stop"]),
+    quantity: z.number().positive(),
+    limitPrice: z.number().positive().optional(),
+    stopPrice: z.number().positive().optional(),
+    confidence: z.number().min(0).max(1).optional(),
+    rationaleSummary: z.string().optional(),
+})
+    .strict();
+const spotCancel = z
+    .object({
+    type: z.literal("spot_cancel"),
+    orderId: z.number(),
+})
+    .strict();
+const pmOpen = z
+    .object({
+    type: z.literal("pm_open"),
+    source: z.string().min(1),
+    slug: z.string().min(1),
+    outcomeExternalMarketId: z.string().min(1),
+    stakeMusd: z.number().positive(),
+    confidence: z.number().min(0).max(1).optional(),
+    rationaleSummary: z.string().optional(),
+})
+    .strict();
+export const actionSchema = z.discriminatedUnion("type", [
     futuresOpen,
     futuresClose,
     futuresSetSltp,
+    spotOrder,
+    spotCancel,
+    pmOpen,
 ]);
 const decisionSchema = z
     .object({

package/dist/agent/decisionValidator.d.ts

@@ -0,0 +1,16 @@
+import { AgentSpec, Observation, ProposedAction, QuoteEvidence, ValidationResult } from "./types.js";
+export interface DecisionContext {
+    spec: AgentSpec;
+    decisionConfidence?: number;
+    observation: Observation;
+    quote?: QuoteEvidence;
+    writesThisCycle: number;
+    writesToday: number;
+    openCount: number;
+    cashAvailableMusd: number | null;
+    openMarginMusd: number;
+    realizedLossTodayMusd: number;
+    targetedPositionIds: number[];
+    targetedOrderIds: number[];
+}
+export declare function validateAction(action: ProposedAction, ctx: DecisionContext): ValidationResult;

package/dist/agent/decisionValidator.js

@@ -1,15 +1,12 @@
 // The decision gate: re-check EVERY proposed action against the spec's hard caps
 // BEFORE any write. The model only proposes; this disposes. Because the caps
 // come from the spec (not the observation or the model), a prompt-injection in
-// market text cannot widen a limit or force a trade. v1 = futures only.
-import { ok, fail, actionVenue, } from "./types.js";
+// market text cannot widen a limit or force a trade. Covers futures + spot + PM.
+import { ok, fail, actionVenue, spotBuyCost, } from "./types.js";
 const SERVER_MAX_LEVERAGE = 20;
+const PM_MIN_STAKE_MUSD = 10; // server minimum prediction-market stake
 export function validateAction(action, ctx) {
     const { spec, observation } = ctx;
-    // v1 scope: futures only.
-    if (action.type === "spot_order" || action.type === "spot_cancel" || action.type === "pm_open") {
-        return fail("out_of_scope_v1", `action "${action.type}" is out of v1 scope (futures only)`);
-    }
     const venue = actionVenue(action);
     if (!spec.venues.includes(venue)) {
         return fail("venue_not_allowed", `venue ${venue} not in [${spec.venues.join(", ")}]`);
@@ -23,9 +20,21 @@ export function validateAction(action, ctx) {
     if (ctx.writesToday >= spec.limits.maxTradesPerDay) {
         return fail("daily_trade_cap", `maxTradesPerDay ${spec.limits.maxTradesPerDay} reached`);
     }
+    // Deny-list: an open on a blocked symbol is rejected up front (deny wins over
+    // the watchlist). PM opens use a market slug, not a coin symbol, so skip them.
+    if (action.type === "futures_open" || action.type === "spot_order") {
+        const blocklist = spec.risk.blocklist;
+        if (Array.isArray(blocklist) && blocklist.length > 0) {
+            const sym = action.symbol.toUpperCase();
+            if (blocklist.some((b) => b.toUpperCase() === sym)) {
+                return fail("blocked_symbol", `${action.symbol} is on the deny-list`);
+            }
+        }
+    }
     if (action.type === "futures_open") {
         // Daily realized-loss stop: once today's loss hits the cap, open no new risk.
-        if (spec.limits.maxDailyLossMusd > 0 && ctx.realizedLossTodayMusd >= spec.limits.maxDailyLossMusd) {
+        if (spec.limits.maxDailyLossMusd > 0 &&
+            ctx.realizedLossTodayMusd >= spec.limits.maxDailyLossMusd) {
             return fail("daily_loss_cap", `today's realized loss ${ctx.realizedLossTodayMusd} >= ${spec.limits.maxDailyLossMusd}`);
         }
         const entry = observation.watch.find((w) => w.symbol.toUpperCase() === action.symbol.toUpperCase());
@@ -44,19 +53,22 @@ export function validateAction(action, ctx) {
         }
         // Aggregate exposure ceiling (existing open margin + this cycle) — the cap
         // that perTradeMargin × maxConcurrentPositions would otherwise blow past.
-        if (ctx.openMarginMusd + action.marginMusd > spec.limits.maxOpenMarginMusd) {
+        if (ctx.openMarginMusd + action.marginMusd >
+            spec.limits.maxOpenMarginMusd) {
             return fail("open_margin_exceeds_cap", `open margin ${ctx.openMarginMusd} + ${action.marginMusd} > ${spec.limits.maxOpenMarginMusd}`);
         }
         if (ctx.openCount >= spec.risk.maxConcurrentPositions) {
             return fail("max_positions", `already ${ctx.openCount} open >= ${spec.risk.maxConcurrentPositions}`);
         }
-        if (ctx.cashAvailableMusd != null && action.marginMusd > ctx.cashAvailableMusd) {
+        if (ctx.cashAvailableMusd != null &&
+            action.marginMusd > ctx.cashAvailableMusd) {
             return fail("insufficient_balance", `margin ${action.marginMusd} > available ${ctx.cashAvailableMusd}`);
         }
         // NOTE: minConfidence keys on the model's SELF-REPORTED confidence — a
         // cooperation hint, NOT an injection-resistant control. The hard caps above
         // (which come from the spec, never the observation) are what actually bind.
-        if ((action.confidence ?? 0) < spec.abstention.minConfidence) {
+        if ((action.confidence ?? ctx.decisionConfidence ?? 0) <
+            spec.abstention.minConfidence) {
             return fail("below_min_confidence", `confidence ${action.confidence ?? 0} < min ${spec.abstention.minConfidence}`);
         }
         if (spec.risk.requireStopLoss) {
@@ -103,5 +115,101 @@ export function validateAction(action, ctx) {
         }
         return ok();
     }
+    if (action.type === "spot_order") {
+        const entry = observation.watch.find((w) => w.symbol.toUpperCase() === action.symbol.toUpperCase());
+        if (!entry)
+            return fail("unknown_symbol", `${action.symbol} is not on the watchlist`);
+        if (!entry.coinId)
+            return fail("unresolved_symbol", `${action.symbol} did not resolve to a coin`);
+        if (action.orderType === "limit" &&
+            !(typeof action.limitPrice === "number" && action.limitPrice > 0)) {
+            return fail("missing_limit_price", "a limit order needs a positive limitPrice");
+        }
+        if (action.orderType === "stop" &&
+            !(typeof action.stopPrice === "number" && action.stopPrice > 0)) {
+            return fail("missing_stop_price", "a stop order needs a positive stopPrice");
+        }
+        // A BUY opens new risk: daily-loss stop, confidence, per-trade notional, cash.
+        if (action.side === "buy") {
+            if (spec.limits.maxDailyLossMusd > 0 &&
+                ctx.realizedLossTodayMusd >= spec.limits.maxDailyLossMusd) {
+                return fail("daily_loss_cap", `today's realized loss ${ctx.realizedLossTodayMusd} >= ${spec.limits.maxDailyLossMusd}`);
+            }
+            if ((action.confidence ?? ctx.decisionConfidence ?? 0) <
+                spec.abstention.minConfidence) {
+                return fail("below_min_confidence", `confidence ${action.confidence ?? 0} < min ${spec.abstention.minConfidence}`);
+            }
+            // Size the BUY with the SAME helper the runner uses to decrement cash, so
+            // the gate and the running-cash accounting never diverge. FAIL CLOSED: an
+            // unpriced market buy (server quote omits executionPrice/estimatedCostMusd)
+            // yields undefined -> reject. The old `cost != null && ...` guards SKIPPED
+            // both caps in that case (notional + balance), a fail-open we must not keep.
+            const cost = spotBuyCost(action, ctx.quote);
+            if (!(typeof cost === "number" && cost > 0)) {
+                return fail("missing_quote_price", "cannot size spot buy notional without a price");
+            }
+            if (cost > spec.risk.perTradeMarginMusd) {
+                return fail("notional_exceeds_cap", `spot notional ${cost} > per-trade cap ${spec.risk.perTradeMarginMusd}`);
+            }
+            if (ctx.cashAvailableMusd != null && cost > ctx.cashAvailableMusd) {
+                return fail("insufficient_balance", `spot cost ${cost} > available ${ctx.cashAvailableMusd}`);
+            }
+        }
+        if (!ctx.quote)
+            return fail("missing_quote", "no quote evidence was fetched for this spot order");
+        if (!ctx.quote.eligible) {
+            return fail("quote_ineligible", `quote blocked: ${JSON.stringify(ctx.quote.blockReasons ?? [])}`);
+        }
+        if (!ctx.quote.freshness || ctx.quote.freshness.status !== "fresh") {
+            return fail("stale_quote", `quote freshness ${ctx.quote.freshness?.status ?? "missing"} (need fresh)`);
+        }
+        return ok();
+    }
+    if (action.type === "spot_cancel") {
+        const o = observation.openOrders.find((x) => x.id === action.orderId);
+        if (!o)
+            return fail("unknown_order", `no open spot order ${action.orderId}`);
+        if (ctx.targetedOrderIds.includes(action.orderId)) {
+            return fail("order_already_targeted", `order ${action.orderId} already cancelled this cycle`);
+        }
+        return ok();
+    }
+    if (action.type === "pm_open") {
+        if (spec.limits.maxDailyLossMusd > 0 &&
+            ctx.realizedLossTodayMusd >= spec.limits.maxDailyLossMusd) {
+            return fail("daily_loss_cap", `today's realized loss ${ctx.realizedLossTodayMusd} >= ${spec.limits.maxDailyLossMusd}`);
+        }
+        // The model may only open a market that DISCOVERY surfaced this cycle — no
+        // hallucinated source/slug. (source/slug are lowercased; outcome is exact.)
+        const mkt = observation.pmMarkets.find((m) => m.source === action.source.toLowerCase() &&
+            m.slug === action.slug.toLowerCase() &&
+            m.outcomeExternalMarketId === action.outcomeExternalMarketId);
+        if (!mkt) {
+            return fail("pm_market_not_discovered", `${action.source}/${action.slug} is not in the discovered PM markets`);
+        }
+        if (action.stakeMusd < PM_MIN_STAKE_MUSD) {
+            return fail("pm_stake_below_min", `stake ${action.stakeMusd} < $${PM_MIN_STAKE_MUSD} minimum`);
+        }
+        if (action.stakeMusd > spec.risk.perTradeMarginMusd) {
+            return fail("pm_stake_exceeds_cap", `stake ${action.stakeMusd} > per-trade cap ${spec.risk.perTradeMarginMusd}`);
+        }
+        if (ctx.cashAvailableMusd != null &&
+            action.stakeMusd > ctx.cashAvailableMusd) {
+            return fail("insufficient_balance", `stake ${action.stakeMusd} > available ${ctx.cashAvailableMusd}`);
+        }
+        if ((action.confidence ?? ctx.decisionConfidence ?? 0) <
+            spec.abstention.minConfidence) {
+            return fail("below_min_confidence", `confidence ${action.confidence ?? 0} < min ${spec.abstention.minConfidence}`);
+        }
+        if (!ctx.quote)
+            return fail("missing_quote", "no quote evidence was fetched for this PM open");
+        if (!ctx.quote.eligible) {
+            return fail("quote_ineligible", `quote blocked: ${JSON.stringify(ctx.quote.blockReasons ?? [])}`);
+        }
+        if (!ctx.quote.freshness || ctx.quote.freshness.status !== "fresh") {
+            return fail("stale_quote", `quote freshness ${ctx.quote.freshness?.status ?? "missing"} (need fresh)`);
+        }
+        return ok();
+    }
     return fail("unknown_action", "unsupported action type");
 }

package/dist/agent/engine.d.ts

@@ -0,0 +1,10 @@
+export { runCycle, type RunnerDeps } from "./runner.js";
+export { selectProvider, type ProviderEnv, type Provider } from "./providers.js";
+export { CoinRithmClient } from "./client.js";
+export { loadAgent, buildSpec, type LoadedAgent } from "./skill.js";
+export { resolveAgent } from "./resolve.js";
+export { validateSkill, type SkillValidationMode } from "./skillValidator.js";
+export { newState, rollDay } from "./state.js";
+export { makeRunId } from "./runEvidence.js";
+export { parseCadenceMs } from "./util.js";
+export type { AgentSpec, RunState, CycleResult, PlannedAction, Venue, ProviderName, ModelConfig, } from "./types.js";

package/dist/agent/engine.js

@@ -0,0 +1,16 @@
+// Public engine surface for an external scheduler (the hosted "free run").
+// The runner is storage-agnostic: runCycle takes { spec, mergedProse, state } as
+// plain objects and saveState(undefined) no-ops, so a scheduler can load state
+// from a DB, run one cycle, and persist the mutated state itself — no file I/O.
+//
+// This barrel is the ONE import a host scheduler needs; it re-exports only the
+// stable engine pieces, never the CLI.
+export { runCycle } from "./runner.js";
+export { selectProvider } from "./providers.js";
+export { CoinRithmClient } from "./client.js";
+export { loadAgent, buildSpec } from "./skill.js";
+export { resolveAgent } from "./resolve.js";
+export { validateSkill } from "./skillValidator.js";
+export { newState, rollDay } from "./state.js";
+export { makeRunId } from "./runEvidence.js";
+export { parseCadenceMs } from "./util.js";

package/dist/agent/extract.d.ts

@@ -0,0 +1,4 @@
+export declare const asObj: (v: unknown) => Record<string, unknown>;
+export declare const asArr: (v: unknown) => unknown[];
+export declare const asNum: (v: unknown) => number | undefined;
+export declare const asStr: (v: unknown) => string | undefined;

package/dist/agent/frontmatter.d.ts

@@ -0,0 +1,5 @@
+export interface Frontmatter {
+    data: Record<string, unknown>;
+    body: string;
+}
+export declare function parseFrontmatter(text: string): Frontmatter;

package/dist/agent/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/agent/indicators.d.ts

@@ -0,0 +1,44 @@
+export interface Candle {
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+}
+export declare function sma(values: number[], period: number): number | null;
+export declare function ema(values: number[], period: number): number | null;
+export declare function rsi(closes: number[], period?: number): number | null;
+export declare function atr(candles: Candle[], period?: number): number | null;
+export interface Bollinger {
+    upper: number;
+    mid: number;
+    lower: number;
+}
+export declare function bollinger(closes: number[], period?: number, mult?: number): Bollinger | null;
+export interface HighLow {
+    high: number;
+    low: number;
+}
+export declare function recentHighLow(candles: Candle[], lookback: number): HighLow | null;
+export interface IndicatorSet {
+    asOfClose: number;
+    rsi14: number | null;
+    ema20: number | null;
+    ema50: number | null;
+    atr14: number | null;
+    bollinger: Bollinger | null;
+    recent20: HighLow | null;
+    aboveEma20: boolean | null;
+    ema20AboveEma50: boolean | null;
+    brokeRecentHigh: boolean | null;
+    brokeRecentLow: boolean | null;
+}
+export interface IndicatorOpts {
+    rsiPeriod?: number;
+    emaFast?: number;
+    emaSlow?: number;
+    atrPeriod?: number;
+    bbPeriod?: number;
+    breakoutLookback?: number;
+}
+export declare function computeIndicators(candles: Candle[], opts?: IndicatorOpts): IndicatorSet | null;

package/dist/agent/indicators.js

@@ -0,0 +1,135 @@
+// Deterministic technical-indicator math — pure functions over OHLC candles.
+//
+// Probe-First note: this module is JUST math (no network). It is the
+// runner-computed half of the `indicators` capability (types.ts) — an agent
+// that declares it gets compact, model-friendly signal (RSI/EMA/ATR/Bollinger/
+// breakout levels) instead of raw bars the free-tier brain cannot reason over.
+// Wiring observe() to FETCH the candles is gated on a live probe of
+// GET /api/agent/market/:coinId/candles (see DECISIONS D16); the math here is
+// independently verifiable and shipped ahead of that.
+//
+// Every function returns null when there are too few candles, so callers can
+// omit an indicator from the observation rather than emit a misleading number.
+const closesOf = (c) => c.map((x) => x.close);
+const finite = (n) => Number.isFinite(n);
+// Simple moving average of the last `period` values.
+export function sma(values, period) {
+    if (period <= 0 || values.length < period)
+        return null;
+    const slice = values.slice(-period);
+    const sum = slice.reduce((a, b) => a + b, 0);
+    return finite(sum) ? sum / period : null;
+}
+// Exponential moving average, seeded with the SMA of the first `period` values
+// (the standard, deterministic seeding).
+export function ema(values, period) {
+    if (period <= 0 || values.length < period)
+        return null;
+    const k = 2 / (period + 1);
+    let prev = values.slice(0, period).reduce((a, b) => a + b, 0) / period;
+    for (let i = period; i < values.length; i++) {
+        prev = values[i] * k + prev * (1 - k);
+    }
+    return finite(prev) ? prev : null;
+}
+// Wilder's RSI over `period` (default 14). 100 = only gains, 0 = only losses.
+export function rsi(closes, period = 14) {
+    if (period <= 0 || closes.length < period + 1)
+        return null;
+    let gain = 0;
+    let loss = 0;
+    for (let i = 1; i <= period; i++) {
+        const ch = closes[i] - closes[i - 1];
+        if (ch >= 0)
+            gain += ch;
+        else
+            loss -= ch;
+    }
+    let avgGain = gain / period;
+    let avgLoss = loss / period;
+    for (let i = period + 1; i < closes.length; i++) {
+        const ch = closes[i] - closes[i - 1];
+        const g = ch >= 0 ? ch : 0;
+        const l = ch < 0 ? -ch : 0;
+        avgGain = (avgGain * (period - 1) + g) / period;
+        avgLoss = (avgLoss * (period - 1) + l) / period;
+    }
+    if (avgLoss === 0)
+        return avgGain === 0 ? 50 : 100;
+    const rs = avgGain / avgLoss;
+    return 100 - 100 / (1 + rs);
+}
+// Wilder's Average True Range over `period` (default 14) — a volatility gauge.
+export function atr(candles, period = 14) {
+    if (period <= 0 || candles.length < period + 1)
+        return null;
+    const tr = [];
+    for (let i = 1; i < candles.length; i++) {
+        const h = candles[i].high;
+        const l = candles[i].low;
+        const pc = candles[i - 1].close;
+        tr.push(Math.max(h - l, Math.abs(h - pc), Math.abs(l - pc)));
+    }
+    if (tr.length < period)
+        return null;
+    let prev = tr.slice(0, period).reduce((a, b) => a + b, 0) / period;
+    for (let i = period; i < tr.length; i++) {
+        prev = (prev * (period - 1) + tr[i]) / period;
+    }
+    return finite(prev) ? prev : null;
+}
+// Bollinger bands: SMA(period) ± mult·stddev over the last `period` closes.
+export function bollinger(closes, period = 20, mult = 2) {
+    if (period <= 0 || closes.length < period)
+        return null;
+    const slice = closes.slice(-period);
+    const mid = slice.reduce((a, b) => a + b, 0) / period;
+    const variance = slice.reduce((a, b) => a + (b - mid) ** 2, 0) / period;
+    const sd = Math.sqrt(variance);
+    if (!finite(mid) || !finite(sd))
+        return null;
+    return { upper: mid + mult * sd, mid, lower: mid - mult * sd };
+}
+// Highest high / lowest low over the last `lookback` candles (breakout levels).
+export function recentHighLow(candles, lookback) {
+    if (lookback <= 0 || candles.length === 0)
+        return null;
+    const slice = candles.slice(-lookback);
+    let high = -Infinity;
+    let low = Infinity;
+    for (const c of slice) {
+        if (c.high > high)
+            high = c.high;
+        if (c.low < low)
+            low = c.low;
+    }
+    return finite(high) && finite(low) ? { high, low } : null;
+}
+// Compute the compact indicator bundle the runner injects into the observation
+// for an agent that declared the `indicators` capability. The breakout flags
+// compare the latest close against the high/low of the PRECEDING window (so a
+// candle closing at a new 20-bar high reads as a breakout, not a tautology).
+export function computeIndicators(candles, opts = {}) {
+    if (candles.length === 0)
+        return null;
+    const closes = closesOf(candles);
+    const close = closes[closes.length - 1];
+    const { rsiPeriod = 14, emaFast = 20, emaSlow = 50, atrPeriod = 14, bbPeriod = 20, breakoutLookback = 20, } = opts;
+    const ema20 = ema(closes, emaFast);
+    const ema50 = ema(closes, emaSlow);
+    // Breakout vs the window BEFORE the latest candle (exclude the current bar).
+    const prior = recentHighLow(candles.slice(0, -1), breakoutLookback);
+    return {
+        asOfClose: close,
+        rsi14: rsi(closes, rsiPeriod),
+        ema20,
+        ema50,
+        atr14: atr(candles, atrPeriod),
+        bollinger: bollinger(closes, bbPeriod),
+        recent20: recentHighLow(candles, breakoutLookback),
+        aboveEma20: ema20 == null ? null : close > ema20,
+        ema20AboveEma50: ema20 == null || ema50 == null ? null : ema20 > ema50,
+        brokeRecentHigh: prior == null ? null : close >= prior.high,
+        brokeRecentLow: prior == null ? null : close <= prior.low,
+    };
+}

package/dist/agent/manifest.d.ts

@@ -0,0 +1,15 @@
+import { AgentSpec, ResolvedAgent, Provenance } from "./types.js";
+export interface AgentManifest {
+    schema: string;
+    spec: string;
+    resolverVersion: string;
+    runnerVersion: string;
+    resolvedConfig: Record<string, unknown>;
+    resolvedSpec: AgentSpec;
+    provenance: Provenance;
+    contentHashes: Record<string, string>;
+    configHash: string;
+}
+export declare function buildManifest(resolved: ResolvedAgent, spec: AgentSpec): AgentManifest;
+export declare function serializeManifest(manifest: AgentManifest): string;
+export declare function writeManifest(agentDir: string, manifest: AgentManifest): string;

package/dist/agent/mergeRules.d.ts

@@ -0,0 +1,11 @@
+import { ResolveIssue } from "./types.js";
+export type CapDirection = "lower" | "higher" | "true";
+export declare const RISK_CAPS: Record<string, CapDirection>;
+export declare const LIMIT_CAPS: Record<string, CapDirection>;
+export declare function isAtLeastAsRestrictive(dir: CapDirection, candidate: unknown, base: unknown): boolean;
+export declare function mostRestrictive(dir: CapDirection, a: unknown, b: unknown): unknown;
+export interface CapMergeResult {
+    merged: Record<string, unknown>;
+    issues: ResolveIssue[];
+}
+export declare function mergeCapPatch(base: Record<string, unknown>, patch: Record<string, unknown>, caps: Record<string, CapDirection>, sourceLabel: string): CapMergeResult;

package/dist/agent/observe.d.ts

@@ -0,0 +1,7 @@
+import { CoinRithmClient } from "./client.js";
+import { AgentSpec, RunState, Observation, AgentTrace } from "./types.js";
+export interface ObserveOutput {
+    observation: Observation;
+    skip?: string;
+}
+export declare function observe(client: CoinRithmClient, spec: AgentSpec, state: RunState, trace?: AgentTrace): Promise<ObserveOutput>;