s-app-scoder-agent 0.0.0-stage → 0.4.0

package/dist/provider-anthropic.js

@@ -0,0 +1,332 @@
+import { LlmError, LLM_REQUEST_TIMEOUT_MS, combinedSignal } from "./llm.js";
+import { withRetry } from "./retry.js";
+// ---------------------------------------------------------------------------
+// Translation: OpenAI-style -> Anthropic
+// ---------------------------------------------------------------------------
+export function toAnthropicMessages(messages) {
+    const systemParts = [];
+    const out = [];
+    for (const m of messages) {
+        if (m.role === "system") {
+            if (m.content)
+                systemParts.push(m.content);
+            continue;
+        }
+        if (m.role === "tool") {
+            // Tool results become user tool_result blocks; consecutive tool results
+            // are merged into one user message (Anthropic requirement).
+            const block = {
+                type: "tool_result",
+                tool_use_id: m.tool_call_id ?? "",
+                content: m.content ?? "",
+            };
+            const last = out[out.length - 1];
+            if (last && last.role === "user" && Array.isArray(last.content)) {
+                last.content.push(block);
+            }
+            else {
+                out.push({ role: "user", content: [block] });
+            }
+            continue;
+        }
+        if (m.role === "assistant") {
+            const blocks = [];
+            if (m.content)
+                blocks.push({ type: "text", text: m.content });
+            for (const tc of m.tool_calls ?? []) {
+                let input;
+                try {
+                    input = tc.arguments ? JSON.parse(tc.arguments) : {};
+                }
+                catch {
+                    input = {};
+                }
+                blocks.push({ type: "tool_use", id: tc.id || `call_${tc.name}`, name: tc.name, input });
+            }
+            out.push({
+                role: "assistant",
+                content: blocks.length > 0 ? blocks : (m.content ?? ""),
+            });
+            continue;
+        }
+        // user
+        out.push({ role: "user", content: m.content ?? "" });
+    }
+    return { system: systemParts.join("\n\n") || undefined, messages: out };
+}
+// ---------------------------------------------------------------------------
+// Translation: Anthropic -> OpenAI-style ChatResult
+// ---------------------------------------------------------------------------
+export function fromAnthropicResponse(data) {
+    let text = "";
+    const toolCalls = [];
+    for (const block of data.content ?? []) {
+        if (block.type === "text") {
+            text = text ? `${text}\n${block.text ?? ""}` : (block.text ?? "");
+        }
+        else if (block.type === "tool_use") {
+            toolCalls.push({
+                id: block.id ?? "",
+                name: block.name ?? "",
+                arguments: JSON.stringify(block.input ?? {}),
+            });
+        }
+    }
+    const usage = {
+        prompt_tokens: data.usage?.input_tokens,
+        completion_tokens: data.usage?.output_tokens,
+    };
+    if (typeof data.usage?.cache_read_input_tokens === "number") {
+        usage.cached_tokens = data.usage.cache_read_input_tokens;
+    }
+    return {
+        message: {
+            role: "assistant",
+            content: text.length > 0 ? text : null,
+            tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+        },
+        usage,
+    };
+}
+// ---------------------------------------------------------------------------
+// AnthropicClient — same surface as LlmClient
+// ---------------------------------------------------------------------------
+const ANTHROPIC_VERSION = "2023-06-01";
+export class AnthropicClient {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    get model() {
+        return this.opts.model;
+    }
+    async chat(messages, tools, opts = {}) {
+        const url = `${this.opts.baseUrl.replace(/\/$/, "")}/messages`;
+        const { system, messages: translated } = toAnthropicMessages(messages);
+        const { signal, cleanup } = combinedSignal(opts.signal, LLM_REQUEST_TIMEOUT_MS);
+        const body = JSON.stringify({
+            model: this.opts.model,
+            max_tokens: this.opts.maxTokens,
+            temperature: this.opts.temperature,
+            system,
+            messages: translated,
+            tools: tools.length > 0
+                ? tools.map((t) => ({
+                    name: t.function.name,
+                    description: t.function.description,
+                    input_schema: t.function.parameters,
+                }))
+                : undefined,
+        });
+        let res;
+        try {
+            res = await withRetry(async () => {
+                const r = await fetch(url, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "x-api-key": this.opts.apiKey,
+                        "anthropic-version": ANTHROPIC_VERSION,
+                    },
+                    body,
+                    signal,
+                });
+                if (!r.ok)
+                    throw await toAnthropicError(r, url);
+                return r;
+            }, {}, (attempt, delay, reason) => console.error(`⚠  Anthropic request failed (${reason}), retrying in ${(delay / 1000).toFixed(1)}s (attempt ${attempt}/3)...`));
+        }
+        finally {
+            cleanup();
+        }
+        const data = (await res.json());
+        if (data.error) {
+            throw new LlmError(`Anthropic API error: ${data.error.message ?? "unknown"}`);
+        }
+        return fromAnthropicResponse(data);
+    }
+    /**
+     * Streaming: parse Anthropic SSE events (message_start, content_block_delta,
+     * message_delta, message_stop) and translate them to StreamChunks:
+     *  - text_delta            -> contentDelta
+     *  - tool_use + input_json_delta -> toolCallDelta accumulation
+     *  - message_delta stop_reason/usage -> final ChatResult
+     */
+    async *streamChat(messages, tools, opts = {}) {
+        const url = `${this.opts.baseUrl.replace(/\/$/, "")}/messages`;
+        const { system, messages: translated } = toAnthropicMessages(messages);
+        const { signal, cleanup } = combinedSignal(opts.signal, LLM_REQUEST_TIMEOUT_MS);
+        const body = JSON.stringify({
+            model: this.opts.model,
+            max_tokens: this.opts.maxTokens,
+            temperature: this.opts.temperature,
+            system,
+            messages: translated,
+            stream: true,
+            tools: tools.length > 0
+                ? tools.map((t) => ({
+                    name: t.function.name,
+                    description: t.function.description,
+                    input_schema: t.function.parameters,
+                }))
+                : undefined,
+        });
+        let res;
+        try {
+            res = await withRetry(async () => {
+                const r = await fetch(url, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        "x-api-key": this.opts.apiKey,
+                        "anthropic-version": ANTHROPIC_VERSION,
+                    },
+                    body,
+                    signal,
+                });
+                if (!r.ok)
+                    throw await toAnthropicError(r, url);
+                return r;
+            }, {}, (attempt, delay, reason) => console.error(`⚠  Anthropic stream request failed (${reason}), retrying in ${(delay / 1000).toFixed(1)}s...`));
+        }
+        catch (err) {
+            cleanup(); // don't leak the 120s request timer — it would hang the process
+            throw new LlmError(`Anthropic stream fetch error after retries at ${url}: ${err.message}`);
+        }
+        if (!res.body) {
+            throw new LlmError("Anthropic stream: response body is not readable");
+        }
+        // Accumulators — text content + tool_use blocks (by block index)
+        let text = "";
+        const toolBlocks = new Map();
+        let stopReason;
+        let usage;
+        let sawStop = false;
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        const handleEvent = (raw) => {
+            let ev;
+            try {
+                ev = JSON.parse(raw);
+            }
+            catch {
+                return null;
+            }
+            if (ev.type === "message_start") {
+                // Initial usage (input tokens) arrives on message_start
+                if (ev.message?.usage) {
+                    usage = {
+                        prompt_tokens: ev.message.usage.input_tokens,
+                        completion_tokens: ev.message.usage.output_tokens,
+                    };
+                    if (typeof ev.message.usage.cache_read_input_tokens === "number") {
+                        usage.cached_tokens = ev.message.usage.cache_read_input_tokens;
+                    }
+                }
+                return null;
+            }
+            if (ev.type === "content_block_start" && ev.content_block?.type === "tool_use") {
+                toolBlocks.set(ev.index ?? 0, {
+                    id: ev.content_block.id ?? "",
+                    name: ev.content_block.name ?? "",
+                    json: "",
+                });
+                return null;
+            }
+            if (ev.type === "content_block_delta") {
+                if (ev.delta?.type === "text_delta" && ev.delta.text) {
+                    text += ev.delta.text;
+                    return { contentDelta: ev.delta.text, done: false };
+                }
+                if (ev.delta?.type === "input_json_delta" && ev.delta.partial_json) {
+                    const block = toolBlocks.get(ev.index ?? 0);
+                    if (block)
+                        block.json += ev.delta.partial_json;
+                    return {
+                        toolCallDelta: { index: ev.index ?? 0, argumentsDelta: ev.delta.partial_json },
+                        done: false,
+                    };
+                }
+                return null;
+            }
+            if (ev.type === "message_delta") {
+                stopReason = ev.delta?.stop_reason ?? stopReason;
+                // Merge: message_delta usage only carries output_tokens
+                if (ev.usage) {
+                    usage = {
+                        ...usage,
+                        prompt_tokens: usage?.prompt_tokens ?? ev.usage.input_tokens,
+                        completion_tokens: ev.usage.output_tokens ?? usage?.completion_tokens,
+                    };
+                    if (usage?.cached_tokens === undefined && typeof ev.usage.cache_read_input_tokens === "number") {
+                        usage = { ...usage, cached_tokens: ev.usage.cache_read_input_tokens };
+                    }
+                }
+                return null;
+            }
+            if (ev.type === "message_stop") {
+                sawStop = true;
+                return null;
+            }
+            return null;
+        };
+        let finalResult;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const rawLine of lines) {
+                    const line = rawLine.trim();
+                    if (!line.startsWith("data:"))
+                        continue;
+                    const payload = line.slice(5).trim();
+                    if (!payload)
+                        continue;
+                    const chunk = handleEvent(payload);
+                    if (chunk)
+                        yield chunk;
+                }
+            }
+            if (sawStop) {
+                const toolCalls = [...toolBlocks.values()]
+                    .filter((b) => b.name)
+                    .map((b) => ({ id: b.id, name: b.name, arguments: b.json || "{}" }));
+                finalResult = {
+                    message: {
+                        role: "assistant",
+                        content: text.length > 0 ? text : null,
+                        stop_reason: stopReason,
+                        tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+                    },
+                    usage,
+                };
+            }
+        }
+        finally {
+            try {
+                reader.cancel();
+            }
+            catch { /* already released */ }
+            reader.releaseLock();
+            cleanup();
+        }
+        yield { done: true, final: finalResult };
+    }
+}
+async function toAnthropicError(res, url) {
+    let body = await res.text().catch(() => "");
+    body = body.replace(/sk-ant-[^\s,&\]]+/gi, "sk-ant-***REDACTED***");
+    const err = new LlmError(`Anthropic API error ${res.status} at ${url}: ${body.slice(0, 500)}`, res.status);
+    const retryAfterHeader = res.headers.get("retry-after");
+    if (retryAfterHeader != null && retryAfterHeader !== "") {
+        const sec = Number(retryAfterHeader);
+        if (Number.isFinite(sec) && sec > 0)
+            err.retryAfterMs = sec * 1000;
+    }
+    return err;
+}

package/dist/retry.js

@@ -0,0 +1,53 @@
+/**
+ * Retry with exponential backoff + jitter for transient failures.
+ */
+export class NonRetryableError extends Error {
+}
+/** HTTP statuses worth retrying (transient). */
+export function isRetryableStatus(status) {
+    return status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
+}
+/** Network-level errors worth retrying. */
+export function isRetryableNetworkError(err) {
+    const msg = String(err?.message ?? err ?? "");
+    return (/ECONNRESET|ETIMEDOUT|ECONNREFUSED|EAI_AGAIN|ENOTFOUND|socket hang up|network|fetch failed/i.test(msg));
+}
+function sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+}
+/**
+ * Run fn with retries. Retries on retryable HTTP statuses (thrown as errors
+ * carrying `.status`) and network errors. Client errors (4xx except 429)
+ * fail immediately via NonRetryableError semantics.
+ */
+export async function withRetry(fn, opts = {}, onRetry) {
+    const maxRetries = opts.maxRetries ?? 3;
+    const baseDelayMs = opts.baseDelayMs ?? 1000;
+    const maxDelayMs = opts.maxDelayMs ?? 30_000;
+    let lastErr;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            const status = err.status;
+            const retryable = (typeof status === "number" && isRetryableStatus(status)) ||
+                (!(err instanceof NonRetryableError) && isRetryableNetworkError(err));
+            // Client errors (except 429) — fail immediately
+            if (typeof status === "number" && status >= 400 && status < 500 && status !== 429) {
+                throw err;
+            }
+            if (!retryable || attempt === maxRetries) {
+                throw err;
+            }
+            // Respect Retry-After header if present (seconds)
+            const retryAfter = err.retryAfterMs;
+            const jitter = Math.floor(Math.random() * 500);
+            const delay = Math.min(retryAfter ?? baseDelayMs * 2 ** attempt + jitter, maxDelayMs);
+            onRetry?.(attempt + 1, delay, status ? `HTTP ${status}` : String(err.message).slice(0, 80));
+            await sleep(delay);
+        }
+    }
+    throw lastErr; // unreachable
+}

package/dist/session.js

@@ -0,0 +1,143 @@
+/**
+ * Session persistence: save agent state (messages, steps, build) to
+ * <workdir>/.scoder/sessions/<id>.json after every step so runs can be resumed.
+ */
+import { mkdirSync, writeFileSync, renameSync, readFileSync, readdirSync, existsSync, rmSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+const SESSIONS_DIR = ".scoder/sessions";
+export function newSessionId(now = new Date()) {
+    const pad = (n) => String(n).padStart(2, "0");
+    const y = now.getFullYear();
+    const mo = pad(now.getMonth() + 1);
+    const d = pad(now.getDate());
+    const h = pad(now.getHours());
+    const mi = pad(now.getMinutes());
+    const s = pad(now.getSeconds());
+    const rand = Math.floor(Math.random() * 0xffff).toString(16).padStart(4, "0");
+    return `${y}${mo}${d}-${h}${mi}${s}-${rand}`;
+}
+function sessionsDir(workdir) {
+    return resolve(workdir, SESSIONS_DIR);
+}
+/** Atomic write: write to .tmp then rename. */
+function atomicWrite(path, content) {
+    const tmp = `${path}.tmp`;
+    writeFileSync(tmp, content, "utf8");
+    renameSync(tmp, path);
+}
+export class SessionStore {
+    id;
+    filePath;
+    enabled;
+    _workdir;
+    constructor(workdir, enabled, id = newSessionId()) {
+        this.id = id;
+        this._workdir = workdir;
+        this.enabled = enabled;
+        this.filePath = join(sessionsDir(workdir), `${id}.json`);
+    }
+    save(data, createdAt) {
+        if (!this.enabled)
+            return;
+        try {
+            mkdirSync(sessionsDir(this._workdir), { recursive: true });
+            const now = new Date().toISOString();
+            const full = {
+                ...data,
+                id: this.id,
+                createdAt: createdAt ?? now,
+                updatedAt: now,
+            };
+            atomicWrite(this.filePath, JSON.stringify(full, null, 2));
+        }
+        catch (err) {
+            // Never crash the agent because of a logging/persistence failure
+            console.error(`⚠  session save failed: ${err.message}`);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Load / list / prune
+// ---------------------------------------------------------------------------
+export function loadSession(workdir, id) {
+    const path = join(sessionsDir(workdir), `${id}.json`);
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function listSessions(workdir) {
+    const dir = sessionsDir(workdir);
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const f of readdirSync(dir).sort().reverse()) {
+        if (!f.endsWith(".json"))
+            continue;
+        try {
+            const s = JSON.parse(readFileSync(join(dir, f), "utf8"));
+            out.push({
+                id: s.id,
+                task: (s.task ?? "").slice(0, 60),
+                steps: s.steps ?? 0,
+                updatedAt: s.updatedAt ?? "",
+            });
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    return out;
+}
+/**
+ * Delete session files older than `days` (default 7).
+ * Completed sessions (lastBuild.success === true) are removed; sessions that
+ * did NOT finish successfully are kept longer — they may still be worth
+ * resuming. Returns count removed.
+ */
+export function pruneSessions(workdir, days = 7) {
+    const dir = sessionsDir(workdir);
+    if (!existsSync(dir))
+        return 0;
+    const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+    let removed = 0;
+    for (const f of readdirSync(dir)) {
+        if (!f.endsWith(".json"))
+            continue;
+        const full = join(dir, f);
+        try {
+            const st = statSync(full);
+            if (st.mtimeMs >= cutoff)
+                continue;
+            const s = JSON.parse(readFileSync(full, "utf8"));
+            const completed = s.lastBuild?.success === true;
+            if (completed) {
+                rmSync(full);
+                removed++;
+            }
+        }
+        catch {
+            // malformed JSON — prune it (unreadable session is worthless)
+            try {
+                rmSync(full);
+                removed++;
+            }
+            catch { /* ignore */ }
+        }
+    }
+    return removed;
+}
+/** Resolve "last" or an explicit id to a SessionFile, or null. */
+export function resolveSessionId(workdir, idOrLast) {
+    if (idOrLast === "last") {
+        const all = listSessions(workdir);
+        if (all.length === 0)
+            return null;
+        return loadSession(workdir, all[0].id);
+    }
+    return loadSession(workdir, idOrLast);
+}