@coinrithm/mcp-trading 0.7.15 → 0.7.17

package/dist/agent/pmPaperDecision.d.ts

@@ -0,0 +1,187 @@
+import { z } from "zod";
+import type { ActionsStringDiagnostic } from "./decision.js";
+export declare const pmV2OpenActionSchema: z.ZodObject<Omit<{
+    source: z.ZodEnum<["kalshi", "polymarket"]>;
+    slug: z.ZodString;
+    outcomeExternalMarketId: z.ZodString;
+    side: z.ZodEnum<["yes", "no"]>;
+    maxCashBudget: z.ZodEffects<z.ZodString, string, string>;
+    idempotencyKey: z.ZodString;
+    minEntryProbabilityPct: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+    thesis: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+} & {
+    forecastProbability: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+}, "idempotencyKey" | "minEntryProbabilityPct"> & {
+    type: z.ZodLiteral<"pm_v2_open">;
+}, "strict", z.ZodTypeAny, {
+    source: "kalshi" | "polymarket";
+    type: "pm_v2_open";
+    slug: string;
+    outcomeExternalMarketId: string;
+    side: "yes" | "no";
+    maxCashBudget: string;
+    forecastProbability: string;
+    thesis?: string | null | undefined;
+}, {
+    source: "kalshi" | "polymarket";
+    type: "pm_v2_open";
+    slug: string;
+    outcomeExternalMarketId: string;
+    side: "yes" | "no";
+    maxCashBudget: string;
+    forecastProbability: string;
+    thesis?: string | null | undefined;
+}>;
+export declare const pmV2CloseActionSchema: z.ZodObject<Omit<{
+    positionId: z.ZodNumber;
+    idempotencyKey: z.ZodString;
+    detail: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+}, "idempotencyKey"> & {
+    type: z.ZodLiteral<"pm_v2_close">;
+}, "strict", z.ZodTypeAny, {
+    type: "pm_v2_close";
+    positionId: number;
+    detail?: string | null | undefined;
+}, {
+    type: "pm_v2_close";
+    positionId: number;
+    detail?: string | null | undefined;
+}>;
+export declare const pmPaperDecisionSchema: z.ZodEffects<z.ZodObject<{
+    decision: z.ZodEnum<["act", "skip"]>;
+    reason: z.ZodOptional<z.ZodString>;
+    rationale: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    actions: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<Omit<{
+        source: z.ZodEnum<["kalshi", "polymarket"]>;
+        slug: z.ZodString;
+        outcomeExternalMarketId: z.ZodString;
+        side: z.ZodEnum<["yes", "no"]>;
+        maxCashBudget: z.ZodEffects<z.ZodString, string, string>;
+        idempotencyKey: z.ZodString;
+        minEntryProbabilityPct: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+        thesis: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+    } & {
+        forecastProbability: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    }, "idempotencyKey" | "minEntryProbabilityPct"> & {
+        type: z.ZodLiteral<"pm_v2_open">;
+    }, "strict", z.ZodTypeAny, {
+        source: "kalshi" | "polymarket";
+        type: "pm_v2_open";
+        slug: string;
+        outcomeExternalMarketId: string;
+        side: "yes" | "no";
+        maxCashBudget: string;
+        forecastProbability: string;
+        thesis?: string | null | undefined;
+    }, {
+        source: "kalshi" | "polymarket";
+        type: "pm_v2_open";
+        slug: string;
+        outcomeExternalMarketId: string;
+        side: "yes" | "no";
+        maxCashBudget: string;
+        forecastProbability: string;
+        thesis?: string | null | undefined;
+    }>, z.ZodObject<Omit<{
+        positionId: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+        detail: z.ZodOptional<z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>>;
+    }, "idempotencyKey"> & {
+        type: z.ZodLiteral<"pm_v2_close">;
+    }, "strict", z.ZodTypeAny, {
+        type: "pm_v2_close";
+        positionId: number;
+        detail?: string | null | undefined;
+    }, {
+        type: "pm_v2_close";
+        positionId: number;
+        detail?: string | null | undefined;
+    }>]>, "many">;
+}, "strict", z.ZodTypeAny, {
+    decision: "skip" | "act";
+    actions: ({
+        source: "kalshi" | "polymarket";
+        type: "pm_v2_open";
+        slug: string;
+        outcomeExternalMarketId: string;
+        side: "yes" | "no";
+        maxCashBudget: string;
+        forecastProbability: string;
+        thesis?: string | null | undefined;
+    } | {
+        type: "pm_v2_close";
+        positionId: number;
+        detail?: string | null | undefined;
+    })[];
+    confidence?: number | undefined;
+    reason?: string | undefined;
+    rationale?: string | undefined;
+}, {
+    decision: "skip" | "act";
+    actions: ({
+        source: "kalshi" | "polymarket";
+        type: "pm_v2_open";
+        slug: string;
+        outcomeExternalMarketId: string;
+        side: "yes" | "no";
+        maxCashBudget: string;
+        forecastProbability: string;
+        thesis?: string | null | undefined;
+    } | {
+        type: "pm_v2_close";
+        positionId: number;
+        detail?: string | null | undefined;
+    })[];
+    confidence?: number | undefined;
+    reason?: string | undefined;
+    rationale?: string | undefined;
+}>, {
+    decision: "skip" | "act";
+    actions: ({
+        source: "kalshi" | "polymarket";
+        type: "pm_v2_open";
+        slug: string;
+        outcomeExternalMarketId: string;
+        side: "yes" | "no";
+        maxCashBudget: string;
+        forecastProbability: string;
+        thesis?: string | null | undefined;
+    } | {
+        type: "pm_v2_close";
+        positionId: number;
+        detail?: string | null | undefined;
+    })[];
+    confidence?: number | undefined;
+    reason?: string | undefined;
+    rationale?: string | undefined;
+}, {
+    decision: "skip" | "act";
+    actions: ({
+        source: "kalshi" | "polymarket";
+        type: "pm_v2_open";
+        slug: string;
+        outcomeExternalMarketId: string;
+        side: "yes" | "no";
+        maxCashBudget: string;
+        forecastProbability: string;
+        thesis?: string | null | undefined;
+    } | {
+        type: "pm_v2_close";
+        positionId: number;
+        detail?: string | null | undefined;
+    })[];
+    confidence?: number | undefined;
+    reason?: string | undefined;
+    rationale?: string | undefined;
+}>;
+export type PmPaperAction = z.infer<typeof pmV2OpenActionSchema> | z.infer<typeof pmV2CloseActionSchema>;
+export declare function parsePmPaperDecision(text: string): {
+    ok: true;
+    decision: z.infer<typeof pmPaperDecisionSchema>;
+} | {
+    ok: false;
+    error: string;
+    actionsStringDiagnostic?: ActionsStringDiagnostic;
+};
+export declare const PM_PAPER_DECISION_JSON_SCHEMA: Record<string, unknown>;

package/dist/agent/pmPaperDecision.js

@@ -0,0 +1,101 @@
+import { z } from "zod";
+import { pmPaperAgentOpenSchema, pmPaperCloseSchema } from "../pmPaperV2.js";
+// forecastProbability is required: a house open without it fails locally
+// instead of spending a write on the API's 422 forecast_required.
+export const pmV2OpenActionSchema = pmPaperAgentOpenSchema
+    .omit({ idempotencyKey: true, minEntryProbabilityPct: true })
+    .extend({ type: z.literal("pm_v2_open") })
+    .strict();
+export const pmV2CloseActionSchema = pmPaperCloseSchema
+    .omit({ idempotencyKey: true })
+    .extend({ type: z.literal("pm_v2_close") })
+    .strict();
+export const pmPaperDecisionSchema = z
+    .object({
+    decision: z.enum(["act", "skip"]),
+    reason: z.string().max(280).optional(),
+    rationale: z.string().max(1000).optional(),
+    confidence: z.number().min(0).max(1).optional(),
+    actions: z
+        .array(z.discriminatedUnion("type", [
+        pmV2OpenActionSchema,
+        pmV2CloseActionSchema,
+    ]))
+        .max(1),
+})
+    .strict()
+    .refine((value) => value.decision === "act"
+    ? value.actions.length === 1
+    : value.actions.length === 0);
+export function parsePmPaperDecision(text) {
+    try {
+        const parsed = pmPaperDecisionSchema.safeParse(JSON.parse(text));
+        return parsed.success
+            ? { ok: true, decision: parsed.data }
+            : { ok: false, error: "invalid PM paper v2 decision" };
+    }
+    catch {
+        return { ok: false, error: "invalid PM paper v2 JSON" };
+    }
+}
+const decimal = {
+    type: "string",
+    pattern: "^(0|[1-9]\\d*)(\\.\\d{1,18})?$",
+    maxLength: 40,
+};
+export const PM_PAPER_DECISION_JSON_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    required: ["decision", "actions"],
+    properties: {
+        decision: { type: "string", enum: ["act", "skip"] },
+        reason: { type: "string", maxLength: 280 },
+        rationale: { type: "string", maxLength: 1000 },
+        confidence: { type: "number", minimum: 0, maximum: 1 },
+        actions: {
+            type: "array",
+            maxItems: 1,
+            items: {
+                oneOf: [
+                    {
+                        type: "object",
+                        additionalProperties: false,
+                        required: [
+                            "type",
+                            "source",
+                            "slug",
+                            "outcomeExternalMarketId",
+                            "side",
+                            "maxCashBudget",
+                            "forecastProbability",
+                        ],
+                        properties: {
+                            type: { const: "pm_v2_open" },
+                            source: { type: "string", enum: ["kalshi", "polymarket"] },
+                            slug: { type: "string", minLength: 1, maxLength: 256 },
+                            outcomeExternalMarketId: {
+                                type: "string",
+                                minLength: 1,
+                                maxLength: 256,
+                            },
+                            side: { type: "string", enum: ["yes", "no"] },
+                            maxCashBudget: decimal,
+                            forecastProbability: decimal,
+                            thesis: { type: ["string", "null"], maxLength: 280 },
+                        },
+                    },
+                    {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["type", "positionId"],
+                        properties: {
+                            type: { const: "pm_v2_close" },
+                            positionId: { type: "integer", minimum: 1, maximum: 2147483647 },
+                            detail: { type: ["string", "null"], maxLength: 1024 },
+                        },
+                    },
+                ],
+            },
+        },
+    },
+};

package/dist/agent/pmPaperPolicy.d.ts

@@ -0,0 +1,71 @@
+import { z } from "zod";
+export declare const pmHouseIdentitySchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    apiKeyId: z.ZodNumber;
+    walletId: z.ZodNumber;
+    houseAgentId: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    walletId: number;
+    userId: number;
+    apiKeyId: number;
+    houseAgentId: number;
+}, {
+    walletId: number;
+    userId: number;
+    apiKeyId: number;
+    houseAgentId: number;
+}>;
+export declare const pmHousePolicySchema: z.ZodObject<{
+    userId: z.ZodNumber;
+    apiKeyId: z.ZodNumber;
+    walletId: z.ZodNumber;
+    houseAgentId: z.ZodNumber;
+} & {
+    version: z.ZodLiteral<"pm_paper_house_v2">;
+    entryEnabled: z.ZodDefault<z.ZodBoolean>;
+    maxCashBudgetPerEntry: z.ZodEffects<z.ZodString, string, string>;
+    maxOpenPositions: z.ZodNumber;
+    maxEntriesPerDay: z.ZodNumber;
+    maxModelCallsPerHour: z.ZodDefault<z.ZodNumber>;
+    maxDailyLoss: z.ZodEffects<z.ZodString, string, string>;
+    discoveryQuery: z.ZodString;
+    maxEndDays: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    version: "pm_paper_house_v2";
+    walletId: number;
+    userId: number;
+    apiKeyId: number;
+    houseAgentId: number;
+    entryEnabled: boolean;
+    maxCashBudgetPerEntry: string;
+    maxOpenPositions: number;
+    maxEntriesPerDay: number;
+    maxModelCallsPerHour: number;
+    maxDailyLoss: string;
+    discoveryQuery: string;
+    maxEndDays?: number | undefined;
+}, {
+    version: "pm_paper_house_v2";
+    walletId: number;
+    userId: number;
+    apiKeyId: number;
+    houseAgentId: number;
+    maxCashBudgetPerEntry: string;
+    maxOpenPositions: number;
+    maxEntriesPerDay: number;
+    maxDailyLoss: string;
+    discoveryQuery: string;
+    entryEnabled?: boolean | undefined;
+    maxModelCallsPerHour?: number | undefined;
+    maxEndDays?: number | undefined;
+}>;
+export type PmHouseIdentity = z.infer<typeof pmHouseIdentitySchema>;
+export type PmHousePolicy = z.infer<typeof pmHousePolicySchema>;
+export declare const samePmHouse: (a: PmHouseIdentity, b: PmHouseIdentity) => boolean;
+export declare function readPmHousePolicies(raw: string | undefined): readonly PmHousePolicy[];
+export declare function selectPmHousePolicy(agent: {
+    id: number;
+    ownerUserId?: number | null;
+    isHouse?: boolean;
+}, policies?: readonly PmHousePolicy[]): PmHousePolicy | undefined;
+export declare function pmCashUnits(value: string): bigint;

package/dist/agent/pmPaperPolicy.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { pmPaperOpenSchema } from "../pmPaperV2.js";
+const id = z.number().int().positive().max(2147483647);
+export const pmHouseIdentitySchema = z
+    .object({ userId: id, apiKeyId: id, walletId: id, houseAgentId: id })
+    .strict();
+export const pmHousePolicySchema = pmHouseIdentitySchema
+    .extend({
+    version: z.literal("pm_paper_house_v2"),
+    entryEnabled: z.boolean().default(false),
+    maxCashBudgetPerEntry: pmPaperOpenSchema.shape.maxCashBudget,
+    maxOpenPositions: z.number().int().min(1).max(20),
+    maxEntriesPerDay: z.number().int().min(1).max(100),
+    maxModelCallsPerHour: z.number().int().min(1).max(30).default(12),
+    maxDailyLoss: pmPaperOpenSchema.shape.maxCashBudget,
+    discoveryQuery: z.string().min(1).max(100),
+    maxEndDays: z.number().int().min(1).max(30).optional(),
+})
+    .strict();
+export const samePmHouse = (a, b) => a.userId === b.userId &&
+    a.apiKeyId === b.apiKeyId &&
+    a.walletId === b.walletId &&
+    a.houseAgentId === b.houseAgentId;
+export function readPmHousePolicies(raw) {
+    if (raw === undefined || raw === "")
+        return [];
+    const policies = z.array(pmHousePolicySchema).max(10).parse(JSON.parse(raw));
+    if (new Set(policies.map((p) => p.houseAgentId)).size !== policies.length ||
+        new Set(policies.map((p) => p.apiKeyId)).size !== policies.length ||
+        new Set(policies.map((p) => p.walletId)).size !== policies.length)
+        throw new Error("Duplicate PM house policy identity");
+    return policies;
+}
+export function selectPmHousePolicy(agent, policies = []) {
+    if (agent.isHouse !== true)
+        return undefined;
+    return policies.find((p) => p.houseAgentId === agent.id && p.userId === agent.ownerUserId);
+}
+export function pmCashUnits(value) {
+    if (!/^-?(0|[1-9]\d*)(\.\d{1,18})?$/.test(value) || value.length > 41)
+        throw new Error("Invalid exact paper cash");
+    const negative = value.startsWith("-");
+    const [whole, fraction = ""] = (negative ? value.slice(1) : value).split(".");
+    const units = BigInt(whole) * 10n ** 18n + BigInt(fraction.padEnd(18, "0"));
+    return negative ? -units : units;
+}

package/dist/agent/prompt.d.ts

@@ -1,4 +1,4 @@
-import { AgentSpec, Observation, PmResolution, RunState } from "./types.js";
+import { AgentSpec, Observation, PmResolution, RunState, LastRejection, type ObjectivePrimary, type OpenPosition } from "./types.js";
 import type { DecisionActionExclusion } from "./providerCapabilities.js";
 export interface DailyRiskBudget {
     version: "coinrithm.daily-risk-budget.v1";
@@ -19,10 +19,22 @@ export interface FuturesCapacity {
 }
 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;
+/**
+ * Per-position stop-loss side of the mark for futures_set_sltp. Live
+ * 2026-10-08: 473 stop_loss_not_above/below_mark refusals in 24 h, nearly all
+ * agents moving a short's stop to its entry price or trailing it when the
+ * mark was already at or past that level. States only the observed-mark
+ * constraint the validator applies (pos.markPrice, TRIGGER_PRICE_EPS); the
+ * take-profit side, liquidation and every other check stay authoritative.
+ * Prices print unrounded so the text never contradicts the validator.
+ */
+export declare function stopBoundLines(positions: readonly OpenPosition[]): string[];
 export declare function buildUserPrompt(obs: Observation, journal?: Array<{
     at: string;
     did: string;
@@ -31,5 +43,7 @@ export declare function buildUserPrompt(obs: Observation, journal?: Array<{
     dailyRiskBudget?: DailyRiskBudget;
     capitalSizing?: AgentSpec["capitalSizing"];
     futuresCapacity?: FuturesCapacity;
+    compactTables?: boolean;
     excludeActionTypes?: readonly DecisionActionExclusion[];
+    lastRejections?: readonly LastRejection[];
 }): string;