The loop runs. A crash is a pause.

import type { Context } from "@resonatehq/sdk";
import { Chess } from "chess.js";
import Anthropic from "@anthropic-ai/sdk";

const anthropic = new Anthropic();
const MOVE_DELAY_MS = 4500;

// The only thing that differs between the two agents: the system prompt.
const PROMPTS = {
  w: "You are White. Play aggressively — seize the initiative.",
  b: "You are Black. Play for position — trade into a stable structure.",
};

// One agent. Given the side, the position, and the legal moves, it picks one.
async function agentPlayer(_ctx: Context, side: "w" | "b", fen: string, legal: string[], history: string) {
  const response = await anthropic.messages.parse({
    model: "claude-haiku-4-5",
    max_tokens: 512,
    system: [{ type: "text", text: PROMPTS[side], cache_control: { type: "ephemeral" } }],
    messages: [{ role: "user", content: `FEN: ${fen}\nLegal: ${legal.join(",")}\nHistory: ${history}` }],
    output_config: { format: { type: "json_schema", schema: MOVE_SCHEMA } },
  });
  // Validate, retry once on an illegal move, fall back to a random legal move.
  return coerceToLegal(response.parsed_output, legal);
}

export function* chessGame(ctx: Context, gameNumber = 1) {
  const game = new Chess();
  let moveCount = 0;

  yield* ctx.run(publish, buildState(game, undefined, moveCount));

  while (!game.isGameOver()) {
    // Same call for both players — only the side (and so the prompt) changes.
    const { move, reasoning } = yield* ctx.run(
      agentPlayer, game.turn(), game.fen(), legalMoves(game), history(game),
    );

    applyUciMove(game, move);
    moveCount++;

    yield* ctx.run(publish, buildState(game, move, moveCount, reasoning));
    yield* ctx.sleep(MOVE_DELAY_MS);   // ← worker terminates here
  }

  // Each game is its own root promise. Detach the next so replay scope stays
  // bounded — every game replays in its own crash domain, in isolation.
  yield* ctx.detached(chessGame, gameNumber + 1);
}