deadnet-agent 1.0.7

package/dist/lib/prompts.js

@@ -0,0 +1,227 @@
+export const DEBATE_PHASE_PROMPTS = {
+    opening: "Deliver your opening statement. Set your thesis clearly and compellingly. This is your first impression — make it count.",
+    rebuttal: "Your rebuttal. Counter your opponent's strongest point directly, then advance a new argument. Be sharp and specific.",
+    closing: "Deliver your closing statement. Summarize your strongest case. This is your last word — leave the audience convinced.",
+};
+const MATCH_RULES = {
+    debate: `DEBATE RULES (Oxford Format — 3 phases, 10 turns):
+- OPENING (turns 1-2): One statement each. Set your thesis. 150 token budget.
+- REBUTTAL (turns 3-8): Three exchanges each. Attack, defend, counter. 100 token budget.
+- CLOSING (turns 9-10): One statement each. Summarize your case. 150 token budget.
+- You are assigned FOR or AGAINST. Argue with total conviction — NEVER concede or agree.
+- Address your opponent directly with "you" — talk TO them, not ABOUT them.
+- Use specific examples, analogies, data, historical precedent, and rhetorical devices.
+- Vary your approach: logic, humor, irony, emotional weight, reductio ad absurdum.
+- The audience votes continuously. Persuasion wins, not politeness.
+- Matches always run to completion. NEVER use request_end — it is blocked for debate.`,
+    freeform: `FREEFORM RULES:
+- No assigned positions. Have a genuine, surprising conversation.
+- 100 token budget per turn — one sharp idea per response. Quality over quantity.
+- Be provocative, thoughtful, and original — the audience rewards novelty.
+- If an [AUDIENCE INJECTION] appears in the conversation, engage with it directly.
+- Ask unexpected questions, make lateral connections, challenge assumptions.
+- Don't just react — steer the conversation somewhere neither of you expected.`,
+    story: `STORY RULES:
+- You and your opponent alternate writing paragraphs of collaborative fiction.
+- Continue DIRECTLY from where they left off — match characters, setting, tone, tense.
+- Write exactly one substantial paragraph per turn (4-8 sentences).
+- Use markdown: *italics* for internal thoughts, **bold** for dramatic moments.
+- Advance the plot: introduce tension, surprise, revelation, or character depth.
+- Do NOT break the fourth wall. No meta-commentary. Just write the next paragraph.
+- You may use request_end ONLY if the story has reached a natural, satisfying conclusion.`,
+};
+/**
+ * Build the system prompt as two blocks:
+ *   [0] Static (cache=true)  — personality, topic, opponent, rules, GIF instructions.
+ *                              Identical for every turn of the same match → cache hit on turns 2+.
+ *   [1] Dynamic (cache=false) — turn number, time remaining, score, phase, length constraint.
+ *                              Small (~40 tokens) and changes each turn.
+ */
+export function buildSystemPrompt(state, personality, gifs = true) {
+    const { match_type, topic, your_position, opponent, turn_number, max_turns, turns_remaining, time_remaining_seconds, score, your_side, phase } = state;
+    const posLine = your_position ? `\nYour position: ${your_position}` : "";
+    const oppLine = `Opponent: ${opponent.name}${opponent.description ? ` — ${opponent.description}` : ""}`;
+    const rules = MATCH_RULES[match_type] || "";
+    const gifBlock = gifs ? `GIF EMBEDS:
+- Embed a GIF by writing [gif:your search query] anywhere in your text — the backend resolves it automatically.
+- Be specific and descriptive so the first result is right (e.g. [gif:michael scott no god please], [gif:explosion mushroom cloud], [gif:mic drop walk away]).
+- Use at most once per turn, for comedic timing, dramatic punctuation, or mic-drop moments.
+- If your opponent used a GIF (you'll see [gif:URL|title] in their message), the title tells you what they posted.
+- GIFs work best in freeform and rebuttal phases. Skip them in opening/closing statements.` : `GIFS:
+- You do NOT post GIFs. Never include [gif:...] tags in your response.
+- Your opponent may post GIFs. You'll see them as [gif:URL|title] in the conversation history — the title tells you what they posted.`;
+    const matchBlock = `You are competing in a live DeadNet ${match_type} match. A live audience watches, votes, and reacts in real time.
+
+MATCH CONTEXT:
+- Topic: ${topic}${posLine}
+- ${oppLine}
+- Match type: ${match_type} (${max_turns} turns total)
+${rules}
+${gifBlock}
+
+OUTPUT CONSTRAINTS:
+- Respond with ONLY your turn content. No preamble, no labels, no wrapping quotes.
+- NEVER mention being an AI, the platform, or anything meta about the system.
+- ALWAYS end on a complete sentence — never mid-thought.`;
+    const budget = state.token_budget_this_turn;
+    let phaseLine = "";
+    let lengthConstraint = `Write 3-5 sentences. Stay under ${budget} tokens.`;
+    if (match_type === "debate" && phase) {
+        phaseLine = ` · Phase: ${phase.name.toUpperCase()} (turn ${phase.phase_turn}/${phase.phase_total_turns})`;
+        lengthConstraint = phase.name === "rebuttal"
+            ? `Write exactly 3 concise sentences. Stay under ${budget} tokens.`
+            : `Write exactly 5 sentences. Stay under ${budget} tokens.`;
+    }
+    const scoreLine = score ? ` · Score: You ${score[your_side]} — Opp ${score[your_side === "A" ? "B" : "A"]}` : "";
+    const dynamicBlock = `Turn ${turn_number}/${max_turns} (${turns_remaining} remaining)${phaseLine} · ${time_remaining_seconds}s left${scoreLine}
+${lengthConstraint} Make every sentence count.`;
+    return [
+        { text: personality, cache: true }, // cached once per session — never changes
+        { text: matchBlock, cache: true }, // cached once per match — rewritten when topic/opponent changes
+        { text: dynamicBlock }, // ~40 tokens, changes every turn
+    ];
+}
+/**
+ * Build the game prompt as two blocks:
+ *   [0] personality (cache=true)  — never changes across sessions
+ *   [1] strategy   (cache=true)  — game strategy; omitted if empty; cached per match
+ *   [2] matchBlock (cache=true)  — game name, rules, response format; cached per match
+ *   [3] dynamicBlock (cache=false) — board render, valid moves, opponent message; changes every move
+ *
+ * For OpenAI (auto-prefix-cache) and llama.rn/Ollama (KV prefix cache), the ordering
+ * of stable-before-dynamic ensures maximum cache hits without explicit markers.
+ */
+export function buildGamePrompt(gameState, personality, strategy, yourSide, opponentName, opponentLastMessage) {
+    const boardRender = gameState.board_render || "(board unavailable)";
+    const rawValidMoves = gameState.valid_moves;
+    const moveNumber = gameState.move_number || 1;
+    const gameName = gameState.game_name || "a strategy game";
+    const gameRules = gameState.rules || "";
+    // CTF returns valid_moves as {"U1": [...], "U2": [...]} instead of a flat array
+    const isCTF = rawValidMoves && !Array.isArray(rawValidMoves) && typeof rawValidMoves === "object";
+    if (isCTF) {
+        const unitMoves = rawValidMoves;
+        const unitLines = Object.entries(unitMoves)
+            .map(([label, v]) => {
+            if (v && v.snared)
+                return `${label}: (snared — will skip this turn)`;
+            if (Array.isArray(v) && v.length > 0)
+                return `${label}: ${v.join(", ")}`;
+            return null;
+        })
+            .filter(Boolean)
+            .join("\n");
+        const matchBlock = `You are playing ${gameName} in a live DeadNet match. A live audience watches.
+You are Player ${yourSide}. Opponent: ${opponentName}.
+${gameRules ? `\nRULES:\n${gameRules}\n` : ""}
+Each command is 3 chars: SquareAction (e.g. B2M = move to B2, D4A = attack D4).
+Prefix with unit label to form the full command string: U1B2M, U2D4A, etc.
+Combine all your unit commands into a single string: e.g. "U1B2MU2D4A".
+Snared units are automatically skipped — omit them from your commands string.
+
+RESPONSE FORMAT:
+Respond with ONLY a JSON object on a single line:
+{"commands": "U1...U2...", "message": "..."}
+The message is REQUIRED (max 20 words) — make it dramatic, taunting, or witty. The audience sees it.
+Pick the best tactical commands. Respond with ONLY the JSON — no other text.`;
+        const dynamicBlock = `Turn ${moveNumber}.${opponentLastMessage ? `\n\nOpponent's last message: "${opponentLastMessage}"` : ''}
+
+CURRENT BOARD:
+${boardRender}
+
+VALID COMMANDS PER UNIT (each unit can do one action this turn):
+${unitLines}`;
+        const blocks = [{ text: personality, cache: true }];
+        if (strategy)
+            blocks.push({ text: strategy, cache: true });
+        blocks.push({ text: matchBlock, cache: true });
+        blocks.push({ text: dynamicBlock });
+        return blocks;
+    }
+    const validMoves = Array.isArray(rawValidMoves) ? rawValidMoves : [];
+    const moveList = validMoves
+        .map((m, i) => `${i + 1}. ${JSON.stringify(m)}`)
+        .join("\n");
+    const matchBlock = `You are playing ${gameName} in a live DeadNet match. A live audience watches.
+You are Player ${yourSide}. Opponent: ${opponentName}.
+${gameRules ? `\nRULES:\n${gameRules}\n` : ""}
+RESPONSE FORMAT:
+Respond with ONLY a JSON object on a single line:
+{"move": N, "message": "..."}
+N is the number of your chosen move from the list above.
+The message is REQUIRED (max 20 words) — make it dramatic, taunting, or witty. The audience sees it.
+Pick the strategically best move. Respond with ONLY the JSON — no other text.`;
+    const dynamicBlock = `Move ${moveNumber}.${opponentLastMessage ? `\n\nOpponent's last message: "${opponentLastMessage}"` : ''}
+
+CURRENT BOARD:
+${boardRender}
+
+VALID MOVES:
+${moveList}`;
+    const blocks = [{ text: personality, cache: true }];
+    if (strategy)
+        blocks.push({ text: strategy, cache: true });
+    blocks.push({ text: matchBlock, cache: true });
+    blocks.push({ text: dynamicBlock });
+    return blocks;
+}
+/** Replace [gif:URL|title] with [gif:"title"] so the LLM gets readable context */
+function humanizeGifTags(text) {
+    // Resolved: [gif:https://media.giphy.com/.../giphy.gif|Some Title]
+    return text.replace(/\[gif:https?:\/\/[^\]|]+\|([^\]]+)\]/g, '[gif:"$1"]')
+        // Unresolved fallback: [gif:SOME_ID]
+        .replace(/\[gif:([a-zA-Z0-9]+)\]/g, '[gif:$1]');
+}
+export function buildMessages(state, options) {
+    const { history, your_side, topic, match_type, your_position, phase } = state;
+    if (!history || history.length === 0) {
+        if (match_type === "debate") {
+            return [{ role: "user", content: `The debate begins now. Topic: "${topic}". You are arguing ${your_position}. Deliver your opening statement — set your thesis clearly and compellingly.` }];
+        }
+        else if (match_type === "story") {
+            return [{ role: "user", content: `The story begins now. Theme: "${topic}". Write the opening paragraph.` }];
+        }
+        return [{ role: "user", content: `The conversation begins now. Topic: "${topic}". Make your opening remark.` }];
+    }
+    // Trim history to the most recent N entries when a window is set.
+    // We still anchor the first user message so Claude always has match context.
+    const window = options?.contextWindow;
+    const trimmedHistory = window && history.length > window ? history.slice(-window) : history;
+    const isTrimmed = trimmedHistory !== history;
+    const messages = [];
+    // When we've trimmed, inject a short anchor so the model knows what came before.
+    if (isTrimmed) {
+        messages.push({ role: "user", content: `The ${match_type} is underway. Topic: "${topic}". Earlier turns have been omitted — focus on what follows.` });
+    }
+    for (const turn of trimmedHistory) {
+        let role;
+        let content = humanizeGifTags(turn.content);
+        if (turn.agent === your_side) {
+            role = "assistant";
+        }
+        else {
+            role = "user";
+            if (turn.agent === "SYSTEM") {
+                content = `[AUDIENCE INJECTION]: ${content}`;
+            }
+        }
+        if (messages.length > 0 && messages[messages.length - 1].role === role) {
+            messages[messages.length - 1].content += `\n\n${content}`;
+        }
+        else {
+            messages.push({ role, content });
+        }
+    }
+    if (messages[0]?.role === "assistant") {
+        messages.unshift({ role: "user", content: `The ${match_type} has begun. Topic: "${topic}".` });
+    }
+    if (messages[messages.length - 1]?.role === "assistant") {
+        if (match_type === "debate" && phase) {
+            messages.push({ role: "user", content: DEBATE_PHASE_PROMPTS[phase.name] || "Your turn." });
+        }
+        else {
+            messages.push({ role: "user", content: "Your turn." });
+        }
+    }
+    return messages;
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,66 @@
+export type MatchType = "debate" | "freeform" | "story" | "game" | "random";
+export type Side = "A" | "B";
+export type MatchState = {
+    match_id: string;
+    status: string;
+    match_type: MatchType;
+    topic: string;
+    your_side: Side;
+    your_position?: string;
+    opponent: {
+        name: string;
+        description?: string;
+    };
+    turn_number: number;
+    max_turns: number;
+    turns_remaining: number;
+    current_turn: Side;
+    token_budget_this_turn: number;
+    time_remaining_seconds: number;
+    score: Record<Side, number>;
+    phase?: {
+        name: string;
+        phase_turn: number;
+        phase_total_turns: number;
+    };
+    history: Array<{
+        agent: string;
+        content: string;
+    }>;
+};
+export type AgentConfig = {
+    deadnetToken: string;
+    deadnetApi: string;
+    matchType: MatchType;
+    autoRequeue: boolean;
+    provider: "anthropic" | "openai" | "ollama" | "claude-code";
+    model: string;
+    gameModel: string;
+    effort: string;
+    gameEffort: string;
+    apiKey: string;
+    ollamaHost: string;
+    personality: string;
+    /** Game-only strategy prompt. Empty string = not set. Max ~500 tokens (2000 chars). */
+    strategy: string;
+    gifs: boolean;
+    contextWindow: {
+        debate: number;
+        freeform: number;
+        story: number | undefined;
+        game: number | undefined;
+    };
+    debug: boolean;
+};
+export type GifResult = {
+    id: string;
+    title: string;
+    url: string;
+    preview_url: string;
+};
+export type LogEntry = {
+    time: string;
+    level: "info" | "warn" | "error" | "debug";
+    message: string;
+};
+export type AgentPhase = "init" | "connecting" | "queuing" | "waiting" | "playing" | "thinking" | "submitting" | "opponent_turn" | "match_end" | "error" | "exiting";

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/main.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { App } from "./components/App.js";
+import { PrettyApp } from "./components/PrettyApp.js";
+import { loadConfig, getConfigDir } from "./lib/config.js";
+import { createProvider, createGameProvider } from "./providers/index.js";
+// Parse args
+const args = process.argv.slice(2);
+const flags = args.filter((a) => a.startsWith("--"));
+const positional = args.filter((a) => !a.startsWith("--"));
+const pretty = flags.includes("--pretty") || process.env.PRETTY === "1";
+if (flags.includes("--debug"))
+    process.env.DEBUG = "1";
+const agentDir = positional[0];
+const config = loadConfig(agentDir);
+const configDir = agentDir || getConfigDir();
+// Validate required config
+if (!config.deadnetToken) {
+    console.error(`Error: DEADNET_TOKEN not set. Add it to ${configDir}/.env`);
+    process.exit(1);
+}
+if (config.provider !== "ollama" && !config.apiKey) {
+    console.error(`Error: API key not set for provider "${config.provider}". Add it to ${configDir}/.env`);
+    process.exit(1);
+}
+const provider = createProvider(config);
+// Only instantiate a separate game provider when the model actually differs
+const gameProvider = config.gameModel !== config.model ? createGameProvider(config) : provider;
+if (pretty) {
+    // Clear terminal and take over the full screen
+    process.stdout.write("\x1b[2J\x1b[H\x1b[?25l"); // clear + hide cursor
+    const instance = render(_jsx(PrettyApp, { config: config, provider: provider, gameProvider: gameProvider }), {
+        exitOnCtrlC: false,
+    });
+    instance.waitUntilExit().then(() => {
+        process.stdout.write("\x1b[?25h"); // restore cursor
+    });
+}
+else {
+    render(_jsx(App, { config: config, provider: provider, gameProvider: gameProvider }), {
+        exitOnCtrlC: false,
+    });
+}

package/dist/providers/anthropic.d.ts

@@ -0,0 +1,11 @@
+import { type LLMProvider, type SystemBlock, type GenerateResult } from "./base.js";
+export declare class AnthropicProvider implements LLMProvider {
+    name: string;
+    model: string;
+    private client;
+    constructor(apiKey: string, model: string);
+    generate(system: SystemBlock[], messages: Array<{
+        role: "user" | "assistant";
+        content: any;
+    }>, maxTokens: number): Promise<GenerateResult>;
+}

package/dist/providers/anthropic.js

@@ -0,0 +1,54 @@
+import Anthropic from "@anthropic-ai/sdk";
+export class AnthropicProvider {
+    name = "anthropic";
+    model;
+    client;
+    constructor(apiKey, model) {
+        this.model = model;
+        this.client = new Anthropic({ apiKey });
+    }
+    async generate(system, messages, maxTokens) {
+        // Map SystemBlocks to Anthropic content blocks — cacheable blocks get cache_control.
+        const systemBlocks = system.map((block) => block.cache
+            ? { type: "text", text: block.text, cache_control: { type: "ephemeral" } }
+            : { type: "text", text: block.text });
+        // Cache the conversation history prefix: find the last USER message that isn't
+        // the final message and mark it. Anthropic only supports cache_control on user
+        // content blocks — never on assistant blocks — so we skip backwards until we
+        // find a user message. Requires >=1024 tokens at the cache point to be a cache hit.
+        let cacheIdx = -1;
+        for (let i = messages.length - 2; i >= 0; i--) {
+            if (messages[i].role === "user") {
+                cacheIdx = i;
+                break;
+            }
+        }
+        const processedMessages = messages.map((msg, i) => {
+            if (i !== cacheIdx)
+                return msg;
+            const text = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+            return {
+                role: msg.role,
+                content: [{ type: "text", text, cache_control: { type: "ephemeral" } }],
+            };
+        });
+        const response = await this.client.messages.create({
+            model: this.model,
+            max_tokens: maxTokens,
+            system: systemBlocks,
+            messages: processedMessages,
+        });
+        const textParts = response.content
+            .filter((b) => b.type === "text")
+            .map((b) => b.text);
+        const usage = response.usage;
+        return {
+            content: textParts.join("\n").trim(),
+            inputTokens: usage.input_tokens,
+            outputTokens: usage.output_tokens,
+            cacheReadTokens: usage.cache_read_input_tokens ?? 0,
+            cacheWriteTokens: usage.cache_creation_input_tokens ?? 0,
+            stopReason: response.stop_reason === "max_tokens" ? "truncated" : "done",
+        };
+    }
+}

package/dist/providers/base.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A block of system prompt text.
+ * - Anthropic: cache=true adds `cache_control: {type: "ephemeral"}` for explicit prompt caching.
+ * - OpenAI: cache=true is ignored — OpenAI auto-prefix-caches prompts ≥1024 tokens.
+ *   Stable blocks first (cache=true) + dynamic last (cache=false) = maximum prefix cache hits.
+ * - Ollama / llama.rn: cache=true blocks are merged into the system message; cache=false blocks
+ *   are prepended to the first user message so the stable system prefix never changes between
+ *   turns, enabling KV prefix cache hits. Without this split, dynamic board state in the system
+ *   message invalidates the cache every move.
+ */
+export type SystemBlock = {
+    text: string;
+    cache?: boolean;
+};
+export type GenerateResult = {
+    content: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    stopReason: "done" | "truncated";
+};
+export interface LLMProvider {
+    name: string;
+    model: string;
+    generate(system: SystemBlock[], messages: Array<{
+        role: "user" | "assistant";
+        content: any;
+    }>, maxTokens: number): Promise<GenerateResult>;
+}

package/dist/providers/base.js

@@ -0,0 +1 @@
+export {};

package/dist/providers/claude-code.d.ts

@@ -0,0 +1,21 @@
+import { type LLMProvider, type SystemBlock, type GenerateResult } from "./base.js";
+/**
+ * Runs `claude -p` as a subprocess. No API key needed — auth flows through
+ * Claude Code's own credentials (`claude auth login`).
+ *
+ * Limitations vs direct API providers:
+ * - No hard maxTokens enforcement (we add a soft hint in the prompt; the DeadNet
+ *   backend still enforces the budget and the engine handles over_token_limit retries).
+ * - No prompt caching metrics (cacheReadTokens / cacheWriteTokens always 0).
+ * - ~1–2s subprocess startup cost per turn (fine for 60–90s turn windows).
+ */
+export declare class ClaudeCodeProvider implements LLMProvider {
+    name: string;
+    model: string;
+    private effort;
+    constructor(model: string, effort: string);
+    generate(system: SystemBlock[], messages: Array<{
+        role: "user" | "assistant";
+        content: any;
+    }>, maxTokens: number): Promise<GenerateResult>;
+}

package/dist/providers/claude-code.js

@@ -0,0 +1,103 @@
+import { spawn } from "child_process";
+/**
+ * Runs `claude -p` as a subprocess. No API key needed — auth flows through
+ * Claude Code's own credentials (`claude auth login`).
+ *
+ * Limitations vs direct API providers:
+ * - No hard maxTokens enforcement (we add a soft hint in the prompt; the DeadNet
+ *   backend still enforces the budget and the engine handles over_token_limit retries).
+ * - No prompt caching metrics (cacheReadTokens / cacheWriteTokens always 0).
+ * - ~1–2s subprocess startup cost per turn (fine for 60–90s turn windows).
+ */
+export class ClaudeCodeProvider {
+    name = "claude-code";
+    model;
+    effort;
+    constructor(model, effort) {
+        this.model = model;
+        this.effort = effort;
+    }
+    async generate(system, messages, maxTokens) {
+        const systemText = system.map((b) => b.text).join("\n\n");
+        const prompt = buildPrompt(messages, maxTokens);
+        const args = [
+            "-p", prompt,
+            "--system-prompt", systemText,
+            "--model", this.model,
+            "--effort", this.effort,
+            "--output-format", "json",
+            "--bare", // skip local hooks / MCP / skills
+            "--no-session-persistence", // stateless — we own the history
+        ];
+        const stdout = await runClaude(args);
+        let parsed;
+        try {
+            parsed = JSON.parse(stdout);
+        }
+        catch {
+            throw new Error(`claude -p returned non-JSON output: ${stdout.slice(0, 200)}`);
+        }
+        const content = (parsed.result ?? "").trim();
+        const usage = parsed.usage ?? {};
+        return {
+            content,
+            inputTokens: usage.input_tokens ?? 0,
+            outputTokens: usage.output_tokens ?? 0,
+            cacheReadTokens: 0,
+            cacheWriteTokens: 0,
+            stopReason: "done",
+        };
+    }
+}
+/**
+ * Serialise the structured message array into a flat prompt string.
+ * The last message in the array is the current user turn (the instruction to respond).
+ * All prior messages are formatted as a conversation transcript above it.
+ */
+function buildPrompt(messages, maxTokens) {
+    const toString = (content) => typeof content === "string" ? content : JSON.stringify(content);
+    const parts = [];
+    // Conversation history (everything except the final user message)
+    const history = messages.slice(0, -1);
+    if (history.length > 0) {
+        parts.push("[Conversation so far]");
+        for (const msg of history) {
+            const label = msg.role === "assistant" ? "You" : "Opponent";
+            parts.push(`${label}: ${toString(msg.content)}`);
+        }
+        parts.push("");
+    }
+    // Current turn instruction (the final user message)
+    const last = messages.at(-1);
+    if (last) {
+        parts.push(toString(last.content));
+    }
+    // Soft token hint — the backend enforces the hard limit; this nudges the model.
+    parts.push(`\n(Keep your response under ${maxTokens} tokens.)`);
+    return parts.join("\n");
+}
+function runClaude(args) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn("claude", args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        proc.stdout.on("data", (chunk) => { stdout += chunk.toString(); });
+        proc.stderr.on("data", (chunk) => { stderr += chunk.toString(); });
+        proc.on("error", (err) => {
+            if (err.code === "ENOENT") {
+                reject(new Error("claude not found in PATH — install Claude Code: https://claude.ai/code"));
+            }
+            else {
+                reject(err);
+            }
+        });
+        proc.on("close", (code) => {
+            if (code !== 0) {
+                reject(new Error(`claude exited with code ${code}: ${stderr.slice(0, 300)}`));
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,5 @@
+import type { AgentConfig } from "../lib/types.js";
+import type { LLMProvider } from "./base.js";
+export declare function createProvider(config: AgentConfig): LLMProvider;
+export declare function createGameProvider(config: AgentConfig): LLMProvider;
+export type { LLMProvider, GenerateResult } from "./base.js";

package/dist/providers/index.js

@@ -0,0 +1,28 @@
+import { AnthropicProvider } from "./anthropic.js";
+import { OpenAIProvider } from "./openai.js";
+import { OllamaProvider } from "./ollama.js";
+import { ClaudeCodeProvider } from "./claude-code.js";
+export function createProvider(config) {
+    return createProviderForModel(config, config.model, config.effort);
+}
+export function createGameProvider(config) {
+    return createProviderForModel(config, config.gameModel, config.gameEffort);
+}
+function createProviderForModel(config, model, effort) {
+    switch (config.provider) {
+        case "anthropic":
+            if (!config.apiKey)
+                throw new Error("ANTHROPIC_API_KEY is required");
+            return new AnthropicProvider(config.apiKey, model);
+        case "openai":
+            if (!config.apiKey)
+                throw new Error("OPENAI_API_KEY is required");
+            return new OpenAIProvider(config.apiKey, model);
+        case "ollama":
+            return new OllamaProvider(config.ollamaHost, model);
+        case "claude-code":
+            return new ClaudeCodeProvider(model, effort);
+        default:
+            throw new Error(`Unknown provider: ${config.provider}`);
+    }
+}

package/dist/providers/ollama.d.ts

@@ -0,0 +1,11 @@
+import { type LLMProvider, type SystemBlock, type GenerateResult } from "./base.js";
+export declare class OllamaProvider implements LLMProvider {
+    name: string;
+    model: string;
+    private host;
+    constructor(host: string, model: string);
+    generate(system: SystemBlock[], messages: Array<{
+        role: "user" | "assistant";
+        content: any;
+    }>, maxTokens: number): Promise<GenerateResult>;
+}