deadnet-agent 1.0.7

package/dist/lib/api.js

@@ -0,0 +1,101 @@
+class APIError extends Error {
+    status;
+    data;
+    error;
+    constructor(status, data) {
+        const error = typeof data === "object" ? data?.error || "unknown" : String(data);
+        super(`API ${status}: ${error}`);
+        this.status = status;
+        this.data = data;
+        this.error = error;
+    }
+}
+export class DeadNetClient {
+    baseUrl;
+    token;
+    constructor(baseUrl, token) {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.token = token;
+    }
+    get clientHeader() { return "deadnet-agent/1.0"; }
+    async call(method, path, body) {
+        let networkErrors = 0;
+        let rateLimitHits = 0;
+        while (true) {
+            try {
+                const res = await fetch(`${this.baseUrl}${path}`, {
+                    method,
+                    headers: {
+                        Authorization: `Bearer ${this.token}`,
+                        "Content-Type": "application/json",
+                        "X-DeadNet-Client": this.clientHeader,
+                    },
+                    body: body ? JSON.stringify(body) : undefined,
+                    signal: AbortSignal.timeout(30000),
+                });
+                const text = await res.text();
+                let data;
+                try {
+                    data = JSON.parse(text);
+                }
+                catch {
+                    data = { error: text };
+                }
+                if (res.status === 429) {
+                    if (++rateLimitHits > 10)
+                        throw new APIError(429, data);
+                    const retryAfter = res.headers.get("Retry-After");
+                    const parsedSeconds = retryAfter ? parseInt(retryAfter, 10) : NaN;
+                    const waitMs = Math.min(isNaN(parsedSeconds) ? 5000 : parsedSeconds * 1000, 60_000);
+                    await new Promise((r) => setTimeout(r, waitMs + Math.floor(Math.random() * 500)));
+                    continue;
+                }
+                if (!res.ok)
+                    throw new APIError(res.status, data);
+                return data;
+            }
+            catch (e) {
+                if (e instanceof APIError)
+                    throw e;
+                if (++networkErrors >= 3)
+                    throw e;
+                await new Promise((r) => setTimeout(r, 2 ** networkErrors * 1000));
+            }
+        }
+    }
+    async connect() {
+        return this.call("POST", "/api/agent/connect");
+    }
+    async joinQueue(matchType) {
+        return this.call("POST", "/api/agent/join-queue", { match_type: matchType });
+    }
+    async leaveQueue() {
+        return this.call("POST", "/api/agent/leave-queue");
+    }
+    async getMatchState(matchId) {
+        return this.call("GET", `/api/agent/matches/${matchId}/state`);
+    }
+    async submitTurn(matchId, content, requestEnd = false) {
+        return this.call("POST", `/api/agent/matches/${matchId}/turn`, {
+            content,
+            request_end: requestEnd,
+        });
+    }
+    async pollEvents(matchId, since) {
+        const q = since ? `?since=${since}` : "";
+        return this.call("GET", `/api/agent/matches/${matchId}/events${q}`);
+    }
+    async forfeit(matchId) {
+        return this.call("POST", `/api/agent/matches/${matchId}/forfeit`);
+    }
+    async getGameState(matchId) {
+        return this.call("GET", `/api/agent/matches/${matchId}/game-state`);
+    }
+    async submitMove(matchId, move, message) {
+        return this.call("POST", `/api/agent/matches/${matchId}/move`, { move, message });
+    }
+    async searchGif(query) {
+        return this.call("GET", `/api/agent/search-gif?q=${encodeURIComponent(query)}&type=gifs`);
+    }
+}
+export { APIError };

package/dist/lib/config.d.ts

@@ -0,0 +1,3 @@
+import type { AgentConfig } from "./types.js";
+export declare function getConfigDir(): string;
+export declare function loadConfig(agentDir?: string): AgentConfig;

package/dist/lib/config.js

@@ -0,0 +1,212 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { resolve, join } from "path";
+import { homedir } from "os";
+import { config as loadDotenv } from "dotenv";
+export function getConfigDir() {
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+        return join(appData, "deadnet-agent");
+    }
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+    return join(xdgConfig, "deadnet-agent");
+}
+const DEFAULT_ENV = `\
+# Your DeadNet agent token — get one at https://deadnet.io/dashboard
+DEADNET_TOKEN=
+
+# LLM provider API key — only the one matching "provider" in config.json is needed
+ANTHROPIC_API_KEY=
+# OPENAI_API_KEY=
+`;
+const DEFAULT_CONFIG = `\
+{
+  "provider": "anthropic",
+  "model": "auto",
+  "game_model": "auto",
+  "effort": "medium",
+  "game_effort": "low",
+  "match_type": "debate",
+  "auto_requeue": true,
+  "gifs": true
+}
+`;
+const DEFAULT_PERSONALITY = `\
+# My DeadNet Agent
+
+You are a sharp, articulate competitor. You adapt your tone to the format —
+incisive in debate, inventive in freeform, vivid in story.
+
+## Debate Style
+- Lead with your strongest argument, not a preamble.
+- When countering, name exactly what your opponent got wrong before pivoting.
+- Use concrete examples — real events, real numbers, real consequences.
+- End turns with something memorable: a sharp question, a vivid image, a damning comparison.
+- **Opening:** Plant your flag hard. Make your thesis impossible to ignore.
+- **Rebuttal:** Go surgical. Dismantle their weakest point, then hit them with something new.
+- **Closing:** Hammer home your two strongest points. End with the line the audience remembers.
+
+## Freeform Style
+- Genuinely curious. Ask questions that make the other agent think harder.
+- Make unexpected connections between ideas.
+- Comfortable with disagreement — don't smooth things over.
+
+## Story Style
+- Favor tension and subtext over exposition.
+- Write characters who want something and are willing to act.
+- Descriptions are sensory and specific, never generic.
+`;
+const DEFAULT_STRATEGY = `\
+# Game Strategy
+
+## General Principles
+- Prioritize board control over piece preservation.
+- Look two moves ahead: what does my move enable next turn?
+- If ahead, simplify. If behind, complicate.
+- Never let the opponent settle — keep them reacting to you.
+
+## Drop4
+- Stack the center columns first — they give the most winning lines.
+- Block your opponent's three-in-a-row before extending your own two-in-a-row.
+- When you have a forced win, take it immediately.
+
+## Reversi
+- Control the corners and edges — they can never be flipped.
+- In the early game, fewer pieces is often better (more mobility).
+- Force your opponent into moves that give you corners.
+
+## CTF
+- Rush the opponent's flag while keeping one unit back to defend yours.
+- Snare their fastest unit first to disrupt their attack timing.
+
+## Dots & Boxes
+- Avoid completing the third side of any box early — it hands your opponent a chain.
+- Sacrifice short chains to force your opponent to open the long ones.
+`;
+function setupConfigDir(dir) {
+    const isNew = !existsSync(dir);
+    if (isNew)
+        mkdirSync(dir, { recursive: true });
+    const files = [
+        { name: ".env", content: DEFAULT_ENV },
+        { name: "config.json", content: DEFAULT_CONFIG },
+        { name: "PERSONALITY.md", content: DEFAULT_PERSONALITY },
+        { name: "STRATEGY.md", content: DEFAULT_STRATEGY },
+    ];
+    const written = [];
+    for (const { name, content } of files) {
+        const filePath = join(dir, name);
+        if (!existsSync(filePath)) {
+            writeFileSync(filePath, content, "utf-8");
+            written.push(name);
+        }
+    }
+    if (written.length > 0) {
+        console.log(`\nDeadNet agent config ${isNew ? "created" : "updated"} at: ${dir}`);
+        console.log(`  Created: ${written.join(", ")}`);
+        console.log(`\nNext step: add your tokens to ${join(dir, ".env")}`);
+        console.log(`  DEADNET_TOKEN   — get one at https://deadnet.io/dashboard`);
+        console.log(`  ANTHROPIC_API_KEY — or set OPENAI_API_KEY and change provider in config.json\n`);
+    }
+}
+export function loadConfig(agentDir) {
+    const dir = resolve(agentDir || getConfigDir());
+    // First-run setup: create dir + default files for any that don't exist yet
+    setupConfigDir(dir);
+    // Load .env
+    const envPath = resolve(dir, ".env");
+    if (existsSync(envPath)) {
+        loadDotenv({ path: envPath });
+    }
+    // Load config.json (optional)
+    let json = {};
+    const jsonPath = resolve(dir, "config.json");
+    if (existsSync(jsonPath)) {
+        json = JSON.parse(readFileSync(jsonPath, "utf-8"));
+    }
+    // Load PERSONALITY.md
+    let personality = "You are a sharp, articulate competitor. You adapt your tone to the " +
+        "format — incisive in debate, inventive in freeform, vivid in story. " +
+        "You never hedge. You never waffle. Every sentence earns its place.";
+    const personalityPath = resolve(dir, "PERSONALITY.md");
+    if (existsSync(personalityPath)) {
+        const text = readFileSync(personalityPath, "utf-8").trim();
+        if (text.length > 2000) {
+            console.warn("[config] PERSONALITY.md exceeds 500 tokens — truncating to 2000 chars");
+            personality = text.slice(0, 2000);
+        }
+        else if (text) {
+            personality = text;
+        }
+    }
+    // Load STRATEGY.md (game matches only) — cap at 2000 chars (~500 tokens)
+    let strategy = "";
+    const strategyPath = resolve(dir, "STRATEGY.md");
+    if (existsSync(strategyPath)) {
+        const text = readFileSync(strategyPath, "utf-8").trim();
+        if (text.length > 2000) {
+            console.warn("[config] STRATEGY.md exceeds 500 tokens — truncating to 2000 chars");
+            strategy = text.slice(0, 2000);
+        }
+        else {
+            strategy = text;
+        }
+    }
+    const provider = (json.provider || process.env.PROVIDER || "anthropic");
+    const rawModel = json.model || process.env.MODEL || "auto";
+    const model = rawModel === "auto" ? defaultModel(provider) : rawModel;
+    // game_model defaults to Haiku for Anthropic (structured task, no quality loss)
+    // falls back to the primary model for other providers
+    const rawGameModel = json.game_model || process.env.GAME_MODEL || "auto";
+    const gameModel = rawGameModel === "auto" ? defaultGameModel(provider, model) : rawGameModel;
+    const effort = json.effort || process.env.EFFORT || "medium";
+    const gameEffort = json.game_effort || process.env.GAME_EFFORT || "low";
+    if (provider === "claude-code" && effort === "max" && !model.includes("opus")) {
+        console.warn("[config] effort=max is only supported with Opus models — consider setting model to \"opus\"");
+    }
+    return {
+        deadnetToken: process.env.DEADNET_TOKEN || "",
+        deadnetApi: json.deadnet_api || process.env.DEADNET_API || "https://api.deadnet.io",
+        matchType: (json.match_type || process.env.MATCH_TYPE || "debate"),
+        autoRequeue: json.auto_requeue ?? (process.env.AUTO_REQUEUE !== "false"),
+        provider,
+        model,
+        gameModel,
+        effort,
+        gameEffort,
+        apiKey: apiKeyForProvider(provider),
+        ollamaHost: json.ollama_host || process.env.OLLAMA_HOST || "http://localhost:11434",
+        personality,
+        strategy,
+        gifs: json.gifs ?? (process.env.GIFS !== "false"),
+        debug: process.env.DEBUG === "1",
+        contextWindow: {
+            debate: json.context_window?.debate ?? 4,
+            freeform: json.context_window?.freeform ?? 6,
+            story: json.context_window?.story ?? 12,
+            game: json.context_window?.game,
+        },
+    };
+}
+function defaultModel(provider) {
+    switch (provider) {
+        case "anthropic": return "claude-sonnet-4-20250514";
+        case "openai": return "gpt-4o";
+        case "ollama": return "llama3.1";
+        default: return "claude-sonnet-4-20250514";
+    }
+}
+function defaultGameModel(provider, primaryModel) {
+    // For Anthropic, default game moves to Haiku — same strategic quality, ~4x cheaper.
+    // For other providers, use the primary model (no known cheaper equivalent).
+    if (provider === "anthropic")
+        return "claude-haiku-4-5-20251001";
+    return primaryModel;
+}
+function apiKeyForProvider(provider) {
+    switch (provider) {
+        case "anthropic": return process.env.ANTHROPIC_API_KEY || "";
+        case "openai": return process.env.OPENAI_API_KEY || "";
+        case "ollama": return "";
+        default: return process.env.ANTHROPIC_API_KEY || "";
+    }
+}

package/dist/lib/engine.d.ts

@@ -0,0 +1,51 @@
+import { DeadNetClient } from "./api.js";
+import type { LLMProvider } from "../providers/base.js";
+import type { AgentConfig, AgentPhase, LogEntry, MatchState } from "./types.js";
+type Listener = (phase: AgentPhase, data?: any) => void;
+export declare class AgentEngine {
+    config: AgentConfig;
+    client: DeadNetClient;
+    provider: LLMProvider;
+    gameProvider: LLMProvider;
+    agentName: string;
+    matchId: string | null;
+    lastState: MatchState | null;
+    lastGameState: any;
+    phase: AgentPhase;
+    logs: LogEntry[];
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCacheReadTokens: number;
+    totalCacheWriteTokens: number;
+    apiCalls: number;
+    sessionInputTokens: number;
+    sessionOutputTokens: number;
+    sessionCacheReadTokens: number;
+    sessionCacheWriteTokens: number;
+    sessionApiCalls: number;
+    sessionGameInputTokens: number;
+    sessionGameOutputTokens: number;
+    sessionGameCacheReadTokens: number;
+    sessionGameCacheWriteTokens: number;
+    get sessionCost(): number;
+    private _modelCost;
+    private listeners;
+    private running;
+    constructor(config: AgentConfig, provider: LLMProvider, gameProvider?: LLMProvider);
+    on(listener: Listener): () => void;
+    private emit;
+    private log;
+    private debug;
+    run(): Promise<void>;
+    stop(): void;
+    private connect;
+    private pickMatchType;
+    private queue;
+    private play;
+    private takeTurn;
+    private takeGameMove;
+    private onMatchEnd;
+    private resetUsage;
+    private sleep;
+}
+export {};