@coinrithm/mcp-trading 0.7.14 → 0.7.16

package/dist/agent/pmContext.d.ts

@@ -1,4 +1,4 @@
-import type { Freshness, PmDecisionSupport, PmQuality } from "./types.js";
+import type { Freshness, PmCalibration, PmConsensus, PmDecisionSupport, PmQuality, PmOutcomeRule, PmSettlementRule } from "./types.js";
 export declare const PM_BLOCK_REASONS: readonly ["structurally_invalid", "stale_freshness", "freshness_unknown", "unpriced", "quote_dead", "dead_zero", "not_open", "source_degraded", "settlement_limbo"];
 export declare const PM_WARNING_REASONS: readonly ["lagging_freshness", "unproven_no_activity", "untraded_default", "play_money", "anomaly_flagged", "source_time_unverified", "sum_atypical_independent"];
 export declare const PM_FLAGS: readonly ["thinMarket", "inactiveMarket", "highAmbiguity", "nearResolution", "staleData"];
@@ -10,4 +10,13 @@ export declare const knownCode: (value: unknown, allowed: readonly string[]) =>
 export declare function sourceTimestamp(value: unknown): string | undefined;
 export declare function freshnessOf(block: Record<string, unknown>): Freshness | undefined;
 export declare function pmQualityOf(value: unknown): PmQuality | undefined;
+export declare const PM_RULES_TEXT_MAX = 500;
+export declare function pmSettlementRuleOf(event: Record<string, unknown>): PmSettlementRule | null | undefined;
+export declare const PM_OUTCOME_PRIMARY_MAX = 400;
+export declare const PM_OUTCOME_SECONDARY_MAX = 300;
+export declare function pmOutcomeRuleOf(rules: PmSettlementRule | null | undefined, outcome: Record<string, unknown>): PmOutcomeRule | undefined;
+export declare const PM_CONSENSUS_KINDS: readonly ["binary", "leader"];
+export declare function pmConsensusOf(event: Record<string, unknown>): PmConsensus | null | undefined;
+export declare const PM_CALIBRATION_MIN_SETTLED = 20;
+export declare function pmCalibrationOf(value: unknown): PmCalibration | undefined;
 export declare function pmDecisionSupportOf(value: unknown): PmDecisionSupport | undefined;

package/dist/agent/pmContext.js

@@ -1,4 +1,4 @@
-import { asArr, asNum, asObj } from "./extract.js";
+import { asArr, asNum, asObj, asStr } from "./extract.js";
 export const PM_BLOCK_REASONS = [
     "structurally_invalid",
     "stale_freshness",
@@ -114,6 +114,168 @@ export function pmQualityOf(value) {
             omitted(raw.blockReasons, PM_BLOCK_REASONS),
     };
 }
+// Prompt budget for one event's settlement text. The API bounds it at 700
+// characters; the board shows up to ~10 events, so the runner keeps the
+// condition and its "otherwise" branch and cuts the rest.
+export const PM_RULES_TEXT_MAX = 500;
+// The discover event's optional `resolution` (backend-v2 #111) for the prompt.
+// undefined when the key is absent (older backend), null when it is null or
+// unusable. A rule the venue never published stays published:false with no
+// text: unknown terms, never a rule inferred from the title.
+export function pmSettlementRuleOf(event) {
+    if (!Object.hasOwn(event, "resolution"))
+        return undefined;
+    const raw = event.resolution;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const r = raw;
+    if (typeof r.published !== "boolean")
+        return null;
+    const rules = typeof r.rules === "string" ? r.rules.replace(/\s+/g, " ").trim() : "";
+    const text = !r.published || !rules
+        ? undefined
+        : rules.length > PM_RULES_TEXT_MAX
+            ? `${rules.slice(0, PM_RULES_TEXT_MAX - 1).trimEnd()}…`
+            : rules;
+    const sources = asArr(r.settlementSources)
+        .map((s) => asStr(asObj(s).name)?.trim().slice(0, 60))
+        .filter((name) => !!name)
+        .slice(0, 3);
+    const settlementSource = asStr(r.settlementSource)?.trim().slice(0, 120);
+    if (settlementSource && !sources.includes(settlementSource))
+        sources.unshift(settlementSource);
+    const scope = r.scope === "per_outcome" ? r.scope : undefined;
+    return {
+        published: r.published,
+        ...(text ? { text } : {}),
+        ...(sources.length ? { sources: sources.slice(0, 3) } : {}),
+        ...(scope ? { scope } : {}),
+    };
+}
+// Prompt budget for one outcome's own rule (the API bounds each at 700).
+export const PM_OUTCOME_PRIMARY_MAX = 400;
+export const PM_OUTCOME_SECONDARY_MAX = 300;
+const UNKNOWN_RULE_REASONS = [
+    "source_rules_unavailable",
+    "market_not_found",
+    "rule_missing",
+    "conflicting_duplicates",
+];
+const cut = (text, max) => text.length > max ? `${text.slice(0, max - 1).trimEnd()}…` : text;
+// One discover outcome's own settlement rule, only for a per-outcome event.
+// undefined = the event's rule is not per-outcome (the row carries none);
+// otherwise the exact provider rule or an explicit unknown reason.
+export function pmOutcomeRuleOf(rules, outcome) {
+    if (rules?.scope !== "per_outcome")
+        return undefined;
+    const r = asObj(outcome.rules);
+    const text = (v) => typeof v === "string" ? v.replace(/\s+/g, " ").trim() : "";
+    const primary = text(r.primary);
+    if (r.status === "exact" && primary) {
+        const secondary = text(r.secondary);
+        return {
+            primary: cut(primary, PM_OUTCOME_PRIMARY_MAX),
+            ...(secondary
+                ? { secondary: cut(secondary, PM_OUTCOME_SECONDARY_MAX) }
+                : {}),
+        };
+    }
+    const reason = UNKNOWN_RULE_REASONS.find((v) => v === r.reason);
+    return { unknown: r.status === "unknown" && reason ? reason : "unreadable" };
+}
+export const PM_CONSENSUS_KINDS = ["binary", "leader"];
+// The discover event's optional `referenceProbability` (0..100 points, open
+// events only) as event-level consensus on the 0..1 `prob` scale. Returns
+// undefined when the key is absent (older backend) and null when it is null
+// or unusable. It is copied as-is: never mapped onto a specific outcome row
+// and never flipped for a NO side, because orientation must not be inferred.
+// An unknown kind, or a leader with no named outcome, cannot be read safely
+// and is null.
+export function pmConsensusOf(event) {
+    if (!Object.hasOwn(event, "referenceProbability"))
+        return undefined;
+    const raw = event.referenceProbability;
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const r = raw;
+    const probability = asNum(r.probability);
+    const venues = asNum(r.venueCount);
+    const spreadPts = asNum(r.spreadPoints);
+    const kind = knownCode(r.kind, PM_CONSENSUS_KINDS);
+    const outcome = typeof r.outcomeName === "string" && r.outcomeName.trim() !== ""
+        ? r.outcomeName.slice(0, 80)
+        : r.outcomeName == null
+            ? null
+            : undefined;
+    if (probability == null ||
+        probability < 0 ||
+        probability > 100 ||
+        venues == null ||
+        !Number.isSafeInteger(venues) ||
+        venues < 1 ||
+        spreadPts == null ||
+        spreadPts < 0 ||
+        spreadPts > 100 ||
+        !kind ||
+        outcome === undefined ||
+        (kind === "leader" && outcome === null))
+        return null;
+    return { prob: probability / 100, venues, spreadPts, kind, outcome };
+}
+// Below this many settled forecasts the record is too noisy to steer the
+// model, so it is not shown at all.
+export const PM_CALIBRATION_MIN_SETTLED = 20;
+const PM_CALIBRATION_MAX_BANDS = 10;
+// The optional `pmCalibration` block of GET /api/agent/performance, compacted
+// for the prompt: Brier to 3 decimals, percentages to whole points, bands
+// with an invalid or empty range dropped. Returns undefined when the block is
+// missing, malformed or has fewer than PM_CALIBRATION_MIN_SETTLED settled.
+export function pmCalibrationOf(value) {
+    const raw = asObj(value);
+    const settled = asNum(raw.settled);
+    if (settled == null ||
+        !Number.isSafeInteger(settled) ||
+        settled < PM_CALIBRATION_MIN_SETTLED)
+        return undefined;
+    const brier = (v) => {
+        const n = asNum(v);
+        return n != null && n >= 0 && n <= 1 ? Math.round(n * 1000) / 1000 : null;
+    };
+    const pct = (v) => {
+        const n = asNum(v);
+        return n != null && n >= 0 && n <= 100 ? Math.round(n) : null;
+    };
+    const bands = asArr(raw.bands)
+        .map(asObj)
+        .flatMap((b) => {
+        const fromPct = asNum(b.fromPct);
+        const toPct = asNum(b.toPct);
+        const n = asNum(b.n);
+        const meanForecastPct = pct(b.meanForecastPct);
+        const winRatePct = pct(b.winRatePct);
+        if (fromPct == null ||
+            toPct == null ||
+            fromPct < 0 ||
+            toPct > 100 ||
+            fromPct >= toPct ||
+            n == null ||
+            !Number.isSafeInteger(n) ||
+            n < 1 ||
+            meanForecastPct == null ||
+            winRatePct == null)
+            return [];
+        return [{ fromPct, toPct, n, meanForecastPct, winRatePct }];
+    })
+        .slice(0, PM_CALIBRATION_MAX_BANDS);
+    return {
+        settled,
+        brierAgent: brier(raw.brierAgent),
+        brierMarket: brier(raw.brierMarket),
+        meanForecastPct: pct(raw.meanForecastPct),
+        winRatePct: pct(raw.winRatePct),
+        bands,
+    };
+}
 export function pmDecisionSupportOf(value) {
     const raw = asObj(value);
     if (Object.keys(raw).length === 0)

package/dist/agent/prompt.d.ts

@@ -1,4 +1,5 @@
-import { AgentSpec, Observation, PmResolution, RunState } from "./types.js";
+import { AgentSpec, Observation, PmResolution, RunState, type ObjectivePrimary } from "./types.js";
+import type { DecisionActionExclusion } from "./providerCapabilities.js";
 export interface DailyRiskBudget {
     version: "coinrithm.daily-risk-budget.v1";
     utcDay: string;
@@ -7,9 +8,22 @@ export interface DailyRiskBudget {
     remaining: number | null;
 }
 export declare function buildDailyRiskBudget(spec: AgentSpec, state: Pick<RunState, "dayKey" | "riskIncreasesToday">): DailyRiskBudget;
+export interface FuturesCapacity {
+    version: "coinrithm.futures-capacity.v1";
+    openPositions: number;
+    maxPositions: number;
+    slotsLeft: number;
+    openMarginMusd: number;
+    maxOpenMarginMusd: number;
+    marginHeadroomMusd: number;
+}
+export declare function buildFuturesCapacity(spec: AgentSpec, obs: Pick<Observation, "openPositions">): FuturesCapacity;
 export declare function formatPmResolutions(resolutions: PmResolution[]): string[];
+export declare const OBJECTIVE_GUIDANCE: Record<ObjectivePrimary, string>;
+export declare function objectiveLine(spec: Pick<AgentSpec, "objective">): string | null;
 export declare function buildSystemPrompt(spec: AgentSpec, mergedProse: string, opts?: {
     includeForecast?: boolean;
+    excludeActionTypes?: readonly DecisionActionExclusion[];
 }): string;
 export declare function buildUserPrompt(obs: Observation, journal?: Array<{
     at: string;
@@ -18,4 +32,7 @@ export declare function buildUserPrompt(obs: Observation, journal?: Array<{
     venues?: AgentSpec["venues"];
     dailyRiskBudget?: DailyRiskBudget;
     capitalSizing?: AgentSpec["capitalSizing"];
+    futuresCapacity?: FuturesCapacity;
+    compactTables?: boolean;
+    excludeActionTypes?: readonly DecisionActionExclusion[];
 }): string;