Data freshness.

// Module 08: Pre-trade freshness gate
//
// Backed by `limitless orderbook events <slug>` (GET /markets/{slug}/events).
// The `limitless` CLI was installed in Module 07. No extra tool needed.
import { spawn } from 'node:child_process';

// One entry of the market event feed (newest first).
// Fields per GET /markets/{slug}/events.
interface MarketEvent {
  createdAt:    string;          // ISO timestamp of the trade
  side?:        number;          // 0 = buy, 1 = sell
  price?:       number;
  matchedSize?: string;
}
interface MarketEventsResponse { events: MarketEvent[]; }

// Freshness budget: skip any market whose newest trade is older than this.
const FRESHNESS_BUDGET_SEC = 90;

function fetchEvents(marketSlug: string, limit = 1): Promise<MarketEventsResponse> {
  return new Promise((resolve, reject) => {
    // Global flag `--output json` forces structured output.
    const proc = spawn('limitless', [
      'orderbook', 'events', marketSlug,
      '--limit', String(limit),
      '--output', 'json',
    ]);
    let out = '';
    proc.stdout.on('data', c => { out += c; });
    proc.on('close', code => {
      if (code !== 0) return reject(new Error(`limitless exited ${code}`));
      try { resolve(JSON.parse(out)); } catch (e) { reject(e); }
    });
  });
}

export const checkFreshnessTool = {
  name:        'check_freshness',
  description: 'Check how recently a market actually traded. Returns the age of the newest event and a safe_to_trade boolean. Call this before EVERY order.',
  input_schema: {
    type: 'object',
    properties: { market_slug: { type: 'string', description: 'Limitless market slug.' } },
    required:   ['market_slug'],
  },
} as const;

export async function checkFreshness(input: { market_slug: string }) {
  try {
    const { events } = await fetchEvents(input.market_slug);
    if (!events?.length) {
      // No trades at all: treat as stale, not as "fine".
      return JSON.stringify({ market_slug: input.market_slug, status: 'empty', safe_to_trade: false });
    }
    const ageSec = (Date.now() - Date.parse(events[0].createdAt)) / 1000;
    return JSON.stringify({
      market_slug:   input.market_slug,
      newest_age_sec: Math.round(ageSec),
      status:        ageSec <= FRESHNESS_BUDGET_SEC ? 'fresh' : 'stale',
      safe_to_trade: ageSec <= FRESHNESS_BUDGET_SEC,
    });
  } catch (e: any) {
    // Treat any failure as unsafe: never trade blind.
    return JSON.stringify({
      market_slug: input.market_slug,
      status:      'error',
      safe_to_trade: false,
      error: e.message,
    });
  }
}

# Module 08: Pre-trade freshness gate
#
# Backed by `limitless orderbook events ` (GET /markets/{slug}/events).
# The `limitless` CLI was installed in Module 07. No extra tool needed.
import json
import subprocess
from datetime import datetime, timezone
from typing import Any

# Freshness budget: skip any market whose newest trade is older than this.
FRESHNESS_BUDGET_SEC = 90


def fetch_events(market_slug: str, limit: int = 1) -> dict[str, Any]:
    # Global flag `--output json` forces structured output.
    proc = subprocess.run(
        ["limitless", "orderbook", "events", market_slug,
         "--limit", str(limit),
         "--output", "json"],
        capture_output = True,
        text           = True,
        timeout        = 10,
    )
    if proc.returncode != 0:
        raise RuntimeError(f"limitless exited {proc.returncode}: {proc.stderr.strip()}")
    return json.loads(proc.stdout)


check_freshness_tool: dict[str, Any] = {
    "type": "function",
    "function": {
        "name": "check_freshness",
        "description": "Check how recently a market actually traded. Returns the age of the newest event and a safe_to_trade boolean. Call this before EVERY order.",
        "parameters": {
            "type": "object",
            "properties": {"market_slug": {"type": "string", "description": "Limitless market slug."}},
            "required":   ["market_slug"],
        },
    },
}


def check_freshness(market_slug: str) -> str:
    try:
        events = fetch_events(market_slug).get("events", [])
        if not events:
            # No trades at all: treat as stale, not as "fine".
            return json.dumps({"market_slug": market_slug, "status": "empty", "safe_to_trade": False})
        created = datetime.fromisoformat(events[0]["createdAt"].replace("Z", "+00:00"))
        age_sec = (datetime.now(timezone.utc) - created).total_seconds()
        fresh = age_sec <= FRESHNESS_BUDGET_SEC
        return json.dumps({
            "market_slug":    market_slug,
            "newest_age_sec": round(age_sec),
            "status":         "fresh" if fresh else "stale",
            "safe_to_trade":  fresh,
        })
    except Exception as e:
        # Treat any failure as unsafe: never trade blind.
        return json.dumps({
            "market_slug":   market_slug,
            "status":        "error",
            "safe_to_trade": False,
            "error":         str(e),
        })