RiskOutline: addOutline Registration and Validation Rules

import { addOutline, ask, dumpOutlineResult, IOutlineHistory } from 'agent-swarm-kit';
import { zodResponseFormat } from "openai/helpers/zod";
import { OutlineName } from '../../enum/OutlineName';
import { CompletionName } from '../../enum/CompletionName';
import { RiskOutlineContract, RiskOutlineFormat } from '../../contract/RiskOutline';

addOutline<RiskOutlineContract>({
  outlineName: OutlineName.RiskOutline,              // "risk_outline"
  completion: CompletionName.OllamaOutlineToolCompletion,
  format: zodResponseFormat(RiskOutlineFormat, "risk_assessment"),
  getOutlineHistory: async ({ history }, symbol, direction, targets, stoploss) => { ... },
  validations: [...],
  callbacks: { onValidDocument: async (result) => { ... } },
});

import { z } from "zod";

export const RiskOutlineFormat = z.object({
  action: z.enum(["skip", "follow"]),
  sure_level: z.enum(["low", "low_medium", "medium", "medium_high", "high"]),
  confidence: z.enum(["reliable", "not_reliable"]),
  description: z.string(),
  reasoning: z.string(),
});

export type RiskOutlineContract = z.infer<typeof RiskOutlineFormat>;

const PRE_CANDLES_LIMIT = 1440;          // 24 h of 1m candles for metrics
const SHORT_MIN_AVG_RANGE_PCT = 0.07;    // Rule 1 threshold
const LONG_MIN_MOMENTUM_24H_PCT = -1;    // Rule 2 threshold

validations: [
  {
    validate: ({ data }) => {
      const ACTIONS = ["skip", "follow"];
      if (!ACTIONS.includes(data.action)) {
        throw new Error(`action "${data.action}" вне допустимого набора ${ACTIONS.join(", ")}`);
      }
    },
    docDescription: "Проверяет, что action — skip или follow.",
  },
  {
    validate: ({ data }) => {
      const SURE_LEVELS = ["low", "low_medium", "medium", "medium_high", "high"];
      if (!SURE_LEVELS.includes(data.sure_level)) {
        throw new Error(`sure_level "${data.sure_level}" вне допустимого набора ${SURE_LEVELS.join(", ")}`);
      }
    },
    docDescription: "Проверяет, что sure_level — один из пяти допустимых уровней.",
  },
  {
    validate: ({ data }) => {
      if (data.confidence !== "reliable" && data.confidence !== "not_reliable") {
        throw new Error(`confidence "${data.confidence}" должен быть reliable или not_reliable`);
      }
    },
    docDescription: "Проверяет, что confidence — reliable или not_reliable.",
  },
  {
    validate: ({ data }) => {
      if (typeof data.description !== "string" || data.description.trim().length < 30) {
        throw new Error(`description слишком короткий (${data.description?.length ?? 0} симв.)`);
      }
    },
    docDescription: "Проверяет, что description содержит полноценный вердикт (>= 30 символов).",
  },
  {
    validate: ({ data }) => {
      if (typeof data.reasoning !== "string" || data.reasoning.trim().length < 80) {
        throw new Error(`reasoning слишком короткий (${data.reasoning?.length ?? 0} симв.)`);
      }
    },
    docDescription: "Проверяет, что reasoning содержит обоснование шагов (>= 80 символов).",
  },
],

callbacks: {
  async onValidDocument(result) {
    if (!result.data) {
      return;
    }
    await dumpOutlineResult(result, './dump/outline/risk');
  },
},

interface RiskOutlineParams {
  symbol: string;
  publishedAt: Date;
  exchangeName: string;
  direction: "short" | "long";
  targets: number[];
  stoploss: number;
}

function runRiskOutlineFn({
  symbol,
  direction,
  targets,
  stoploss,
  publishedAt,
  exchangeName,
}: RiskOutlineParams) {
  const when = alignToInterval(publishedAt, "1m");
  return runInMockContext(
    async () => {
      const { data, error, isValid } = await json<RiskOutlineContract>(
        OutlineName.RiskOutline,
        symbol,
        direction,
        targets,
        stoploss,
      );
      if (!isValid) {
        throw new Error(error);
      }
      return data;
    },
    {
      symbol,
      exchangeName,
      when,
      strategyName: "mock-strategy",
      frameName: "mock-frame",
      backtest: true,
    },
  );
}

declare global {
  var runRiskOutline: typeof runRiskOutlineFn;
}

Object.assign(globalThis, { runRiskOutline: runRiskOutlineFn });

const result = await globalThis.runRiskOutline({
  symbol: "BTCUSDT",
  publishedAt: new Date("2024-11-15T14:30:00Z"),
  exchangeName: "binance",
  direction: "short",
  targets: [91500.000000, 90800.000000],
  stoploss: 93200.000000,
});

console.log(result);
// {
//   action: "skip",
//   sure_level: "medium_high",
//   confidence: "reliable",
//   description: "Action skip. SHORT на спящем активе (avgRangePct 0.045% < 0.07%) — stop-hunt мишень.",
//   reasoning: "Шаг 1: avgRangePct=0.045%, momentum24hPct=1.18%\nШаг 2: direction=SHORT И avgRangePct < 0.07% → правило 1 → action=skip\nШаг 3: sure_level=medium_high, confidence=reliable"
// }