multiarena 0.1.0

package/dist/persistence/session.d.ts

@@ -0,0 +1,17 @@
+export interface SavedSession {
+    id: string;
+    timestamp: string;
+    models: Array<{
+        name: string;
+        messages: Array<{
+            role: string;
+            content: string;
+            tool_call_id?: string;
+        }>;
+        buffer: string;
+    }>;
+    lastTarget: "broadcast" | string;
+}
+export declare function saveSession(session: SavedSession): void;
+export declare function loadSession(id: string): SavedSession | null;
+export declare function listSessions(): SavedSession[];

package/dist/persistence/session.js

@@ -0,0 +1,27 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+const SESSIONS_DIR = path.join(os.homedir(), ".arena", "sessions");
+export function saveSession(session) {
+    fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+    const filePath = path.join(SESSIONS_DIR, `${session.id}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(session, null, 2));
+}
+export function loadSession(id) {
+    const filePath = path.join(SESSIONS_DIR, `${id}.json`);
+    if (!fs.existsSync(filePath))
+        return null;
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+export function listSessions() {
+    if (!fs.existsSync(SESSIONS_DIR))
+        return [];
+    return fs
+        .readdirSync(SESSIONS_DIR)
+        .filter((f) => f.endsWith(".json"))
+        .map((f) => {
+        const data = JSON.parse(fs.readFileSync(path.join(SESSIONS_DIR, f), "utf-8"));
+        return data;
+    })
+        .sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+}

package/dist/provider/adapters/anthropic.d.ts

@@ -0,0 +1,11 @@
+import { Provider } from "../provider.js";
+import { ChatRequest, StreamEvent } from "../types.js";
+export declare class AnthropicProvider implements Provider {
+    private client;
+    private activeController;
+    constructor(apiKey: string);
+    chat(request: ChatRequest): AsyncGenerator<StreamEvent>;
+    abort(): void;
+    private convertMessages;
+    private convertTools;
+}

package/dist/provider/adapters/anthropic.js

@@ -0,0 +1,146 @@
+import Anthropic from "@anthropic-ai/sdk";
+const DEFAULT_MODEL = "claude-sonnet-4-20250514";
+const DEFAULT_MAX_TOKENS = 4096;
+const DEFAULT_TIMEOUT_MS = 120_000;
+export class AnthropicProvider {
+    client;
+    activeController = null;
+    constructor(apiKey) {
+        this.client = new Anthropic({ apiKey, timeout: DEFAULT_TIMEOUT_MS, maxRetries: 2 });
+    }
+    async *chat(request) {
+        const abortController = new AbortController();
+        this.activeController = abortController;
+        let inputTokens = 0;
+        let outputTokens = 0;
+        try {
+            const stream = this.client.messages.stream({
+                model: request.model || DEFAULT_MODEL,
+                max_tokens: DEFAULT_MAX_TOKENS,
+                system: request.system,
+                messages: this.convertMessages(request.messages),
+                tools: this.convertTools(request.tools),
+            }, { signal: abortController.signal });
+            for await (const event of stream) {
+                switch (event.type) {
+                    case "message_start":
+                        inputTokens = event.message.usage.input_tokens;
+                        break;
+                    case "content_block_delta":
+                        if (event.delta.type === "text_delta") {
+                            yield { type: "text", content: event.delta.text };
+                        }
+                        break;
+                    case "content_block_stop": {
+                        // The type definition for RawContentBlockStopEvent is incomplete in SDK v0.30.0;
+                        // the actual API response includes a `content_block` field.
+                        const block = event.content_block;
+                        if (block?.type === "tool_use") {
+                            yield {
+                                type: "tool_call",
+                                id: block.id,
+                                name: block.name,
+                                args: JSON.stringify(block.input),
+                            };
+                        }
+                        break;
+                    }
+                    case "message_delta":
+                        outputTokens = event.usage.output_tokens;
+                        break;
+                    case "message_stop":
+                        yield {
+                            type: "done",
+                            usage: { input: inputTokens, output: outputTokens },
+                        };
+                        break;
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                (error.name === "AbortError" || error.name === "APIUserAbortError")) {
+                return; // Aborted silently
+            }
+            yield {
+                type: "error",
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+        finally {
+            this.activeController = null;
+        }
+    }
+    abort() {
+        this.activeController?.abort();
+    }
+    // ── Message conversion ──────────────────────────────────────────────
+    convertMessages(messages) {
+        const result = [];
+        for (const msg of messages) {
+            switch (msg.role) {
+                case "user":
+                    result.push({ role: "user", content: msg.content });
+                    break;
+                case "assistant": {
+                    const content = [];
+                    if (msg.content) {
+                        content.push({ type: "text", text: msg.content });
+                    }
+                    if (msg.tool_calls) {
+                        for (const tc of msg.tool_calls) {
+                            content.push({
+                                type: "tool_use",
+                                id: tc.id,
+                                name: tc.name,
+                                input: tc.arguments ? safeJsonParse(tc.arguments) : {},
+                            });
+                        }
+                    }
+                    // If no tool_calls and content is plain text, use the string form directly
+                    if (content.length === 1 && content[0].type === "text") {
+                        result.push({ role: "assistant", content: msg.content });
+                    }
+                    else {
+                        result.push({ role: "assistant", content });
+                    }
+                    break;
+                }
+                case "tool":
+                    result.push({
+                        role: "user",
+                        content: [
+                            {
+                                type: "tool_result",
+                                tool_use_id: msg.tool_call_id || "",
+                                content: msg.content,
+                            },
+                        ],
+                    });
+                    break;
+            }
+        }
+        return result;
+    }
+    // ── Tool conversion ─────────────────────────────────────────────────
+    convertTools(tools) {
+        if (!tools || tools.length === 0)
+            return undefined;
+        return tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            input_schema: {
+                ...t.parameters,
+                type: "object",
+            },
+        }));
+    }
+}
+function safeJsonParse(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}

package/dist/provider/adapters/google.d.ts

@@ -0,0 +1,11 @@
+import { Provider } from "../provider.js";
+import { ChatRequest, StreamEvent } from "../types.js";
+export declare class GoogleProvider implements Provider {
+    private genAI;
+    private aborted;
+    constructor(apiKey: string);
+    chat(request: ChatRequest): AsyncGenerator<StreamEvent>;
+    abort(): void;
+    private convertMessages;
+    private convertTools;
+}

package/dist/provider/adapters/google.js

@@ -0,0 +1,177 @@
+import { GoogleGenerativeAI } from "@google/generative-ai";
+const DEFAULT_MODEL = "gemini-2.5-flash";
+const DEFAULT_TIMEOUT_MS = 120_000;
+export class GoogleProvider {
+    genAI;
+    aborted = false;
+    constructor(apiKey) {
+        this.genAI = new GoogleGenerativeAI(apiKey);
+    }
+    async *chat(request) {
+        this.aborted = false;
+        const maxAttempts = 2;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            try {
+                const model = this.genAI.getGenerativeModel({
+                    model: request.model || DEFAULT_MODEL,
+                    systemInstruction: request.system,
+                    tools: this.convertTools(request.tools),
+                });
+                const contents = this.convertMessages(request.messages);
+                const result = await model.generateContentStream({ contents }, { timeout: DEFAULT_TIMEOUT_MS });
+                let textOffset = 0;
+                let fnCallCount = 0;
+                for await (const chunk of result.stream) {
+                    if (this.aborted)
+                        return;
+                    // Yield new text
+                    const fullText = chunk.text();
+                    if (fullText && fullText.length > textOffset) {
+                        const delta = fullText.slice(textOffset);
+                        textOffset = fullText.length;
+                        if (delta) {
+                            yield { type: "text", content: delta };
+                        }
+                    }
+                    // Yield new function calls
+                    const fnCalls = chunk.functionCalls?.();
+                    if (fnCalls) {
+                        for (let i = fnCallCount; i < fnCalls.length; i++) {
+                            const fc = fnCalls[i];
+                            yield {
+                                type: "tool_call",
+                                id: `${fc.name}_${i}`,
+                                name: fc.name,
+                                args: JSON.stringify(fc.args),
+                            };
+                        }
+                        fnCallCount = fnCalls.length;
+                    }
+                }
+                // Try to get usage metadata from the completed response
+                let usage = { input: 0, output: 0 };
+                try {
+                    const response = await result.response;
+                    const metadata = response.usageMetadata;
+                    if (metadata) {
+                        usage = {
+                            input: metadata.promptTokenCount ?? 0,
+                            output: metadata.candidatesTokenCount ?? 0,
+                        };
+                    }
+                }
+                catch {
+                    // usageMetadata may not be available in all SDK versions
+                }
+                yield { type: "done", usage };
+                return; // success — exit retry loop
+            }
+            catch (error) {
+                if (this.aborted)
+                    return;
+                if (attempt < maxAttempts - 1 && isRetryableError(error)) {
+                    await new Promise((r) => setTimeout(r, 1000));
+                    continue;
+                }
+                yield {
+                    type: "error",
+                    message: error instanceof Error ? error.message : String(error),
+                };
+                return;
+            }
+        }
+    }
+    abort() {
+        this.aborted = true;
+    }
+    // ── Message conversion ──────────────────────────────────────────────
+    convertMessages(messages) {
+        const result = [];
+        for (const msg of messages) {
+            switch (msg.role) {
+                case "user":
+                    result.push({
+                        role: "user",
+                        parts: [{ text: msg.content }],
+                    });
+                    break;
+                case "assistant": {
+                    const parts = [];
+                    if (msg.content) {
+                        parts.push({ text: msg.content });
+                    }
+                    if (msg.tool_calls) {
+                        for (const tc of msg.tool_calls) {
+                            parts.push({
+                                functionCall: {
+                                    name: tc.name,
+                                    args: safeJsonParse(tc.arguments),
+                                },
+                            });
+                        }
+                    }
+                    result.push({ role: "model", parts });
+                    break;
+                }
+                case "tool": {
+                    const toolCall = findToolCall(messages, msg.tool_call_id);
+                    result.push({
+                        role: "function",
+                        parts: [
+                            {
+                                functionResponse: {
+                                    name: toolCall?.name ?? "",
+                                    response: { content: msg.content },
+                                },
+                            },
+                        ],
+                    });
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+    // ── Tool conversion ─────────────────────────────────────────────────
+    convertTools(tools) {
+        if (!tools || tools.length === 0)
+            return undefined;
+        return [
+            {
+                functionDeclarations: tools.map((t) => ({
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.parameters,
+                })),
+            },
+        ];
+    }
+}
+function safeJsonParse(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function findToolCall(messages, toolCallId) {
+    if (!toolCallId)
+        return undefined;
+    for (const msg of messages) {
+        if (msg.tool_calls) {
+            const found = msg.tool_calls.find((tc) => tc.id === toolCallId);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+function isRetryableError(error) {
+    if (!(error instanceof Error))
+        return false;
+    if (error.name === "TypeError" && error.message.includes("fetch"))
+        return true;
+    const msg = error.message;
+    return /(429|500|502|503|504)/.test(msg);
+}

package/dist/provider/adapters/ollama.d.ts

@@ -0,0 +1,11 @@
+import { Provider } from "../provider.js";
+import { ChatRequest, StreamEvent } from "../types.js";
+export declare class OllamaProvider implements Provider {
+    private baseURL;
+    private activeController;
+    constructor(baseURL: string);
+    chat(request: ChatRequest): AsyncGenerator<StreamEvent>;
+    abort(): void;
+    private convertMessages;
+    private convertTools;
+}

package/dist/provider/adapters/ollama.js

@@ -0,0 +1,147 @@
+const DEFAULT_MODEL = "llama3";
+const DEFAULT_TIMEOUT_MS = 120_000;
+export class OllamaProvider {
+    baseURL;
+    activeController = null;
+    constructor(baseURL) {
+        this.baseURL = baseURL;
+    }
+    async *chat(request) {
+        const controller = new AbortController();
+        this.activeController = controller;
+        const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT_MS);
+        try {
+            const body = {
+                model: request.model || DEFAULT_MODEL,
+                messages: this.convertMessages(request.messages),
+                stream: true,
+            };
+            if (request.tools && request.tools.length > 0) {
+                body.tools = this.convertTools(request.tools);
+            }
+            const response = await fetch(`${this.baseURL}/api/chat`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const text = await response.text();
+                yield { type: "error", message: `Ollama error (${response.status}): ${text}` };
+                return;
+            }
+            const reader = response.body?.getReader();
+            if (!reader) {
+                yield { type: "error", message: "No response body from Ollama" };
+                return;
+            }
+            const decoder = new TextDecoder();
+            let lineBuffer = "";
+            let inputTokens = 0;
+            let outputTokens = 0;
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                lineBuffer += decoder.decode(value, { stream: true });
+                const lines = lineBuffer.split("\n");
+                lineBuffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    let chunk;
+                    try {
+                        chunk = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (chunk.message) {
+                        const msg = chunk.message;
+                        if (msg.content) {
+                            yield { type: "text", content: msg.content };
+                        }
+                        if (msg.tool_calls) {
+                            for (const tc of msg.tool_calls) {
+                                const id = `call_${tc.function.name}_${Math.random().toString(36).slice(2, 8)}`;
+                                yield {
+                                    type: "tool_call",
+                                    id,
+                                    name: tc.function.name,
+                                    args: JSON.stringify(tc.function.arguments),
+                                };
+                            }
+                        }
+                    }
+                    if (chunk.done) {
+                        inputTokens = chunk.prompt_eval_count ?? 0;
+                        outputTokens = chunk.eval_count ?? 0;
+                    }
+                }
+            }
+            yield { type: "done", usage: { input: inputTokens, output: outputTokens } };
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError") {
+                return;
+            }
+            yield {
+                type: "error",
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+        finally {
+            clearTimeout(timeoutId);
+            this.activeController = null;
+        }
+    }
+    abort() {
+        this.activeController?.abort();
+    }
+    convertMessages(messages) {
+        return messages.map((msg) => {
+            switch (msg.role) {
+                case "user":
+                    return { role: "user", content: msg.content };
+                case "assistant": {
+                    const result = { role: "assistant", content: msg.content || "" };
+                    if (msg.tool_calls && msg.tool_calls.length > 0) {
+                        result.tool_calls = msg.tool_calls.map((tc) => ({
+                            function: {
+                                name: tc.name,
+                                arguments: safeJsonParse(tc.arguments),
+                            },
+                        }));
+                    }
+                    return result;
+                }
+                case "tool":
+                    return {
+                        role: "tool",
+                        content: msg.content,
+                        tool_call_id: msg.tool_call_id || "",
+                    };
+                default:
+                    return { role: "user", content: msg.content };
+            }
+        });
+    }
+    convertTools(tools) {
+        return tools.map((t) => ({
+            type: "function",
+            function: {
+                name: t.name,
+                description: t.description,
+                parameters: t.parameters,
+            },
+        }));
+    }
+}
+function safeJsonParse(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}

package/dist/provider/adapters/openai.d.ts

@@ -0,0 +1,11 @@
+import { Provider } from "../provider.js";
+import { ChatRequest, StreamEvent } from "../types.js";
+export declare class OpenAIProvider implements Provider {
+    private client;
+    private activeController;
+    constructor(apiKey: string, baseURL?: string);
+    chat(request: ChatRequest): AsyncGenerator<StreamEvent>;
+    abort(): void;
+    private convertMessages;
+    private convertTools;
+}