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

package/dist/llm.js

@@ -0,0 +1,266 @@
+/**
+ * Minimal OpenAI-compatible chat-completions client with function calling
+ * and optional SSE streaming.
+ */
+import { withRetry } from "./retry.js";
+export class LlmError extends Error {
+    status;
+    retryAfterMs;
+    constructor(message, status, retryAfterMs) {
+        super(message);
+        this.name = "LlmError";
+        if (status !== undefined)
+            this.status = status;
+        if (retryAfterMs !== undefined)
+            this.retryAfterMs = retryAfterMs;
+    }
+}
+/** Build an LlmError from a failed Response, carrying status + Retry-After. */
+async function toLlmError(res, url) {
+    let body = await res.text().catch(() => "");
+    // Redact Bearer token and raw key patterns to avoid leaking secrets in logs/errors
+    body = body.replace(/Bearer\s+[^\s,&\]]+/gi, "Bearer ***REDACTED***");
+    body = body.replace(/sk-[A-Za-z0-9_-]{8,}/g, "sk-***REDACTED***");
+    const err = new LlmError(`LLM API error ${res.status} at ${url}: ${body.slice(0, 500)}`, res.status);
+    // Only honor a REAL Retry-After value: Number("") === 0 would zero the backoff
+    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;
+}
+// ---------------------------------------------------------------------------
+// Request timeout / abort helpers
+// ---------------------------------------------------------------------------
+/** Default per-request timeout for LLM calls (a hung connection must not block the agent forever). */
+export const LLM_REQUEST_TIMEOUT_MS = 120_000;
+/**
+ * Combine an external signal with a request timeout.
+ * Returns a derived signal plus a cleanup fn (removes listeners).
+ * Works on Node >= 18 (no AbortSignal.any dependency).
+ */
+export function combinedSignal(external, timeoutMs) {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(new DOMException("LLM request timed out", "TimeoutError")), timeoutMs);
+    const onExternal = () => ac.abort(new DOMException("aborted", "AbortError"));
+    if (external) {
+        if (external.aborted)
+            ac.abort(external.reason);
+        else
+            external.addEventListener("abort", onExternal, { once: true });
+    }
+    return {
+        signal: ac.signal,
+        cleanup: () => {
+            clearTimeout(timer);
+            external?.removeEventListener("abort", onExternal);
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// SSE parsing helpers
+// ---------------------------------------------------------------------------
+const SSE_PREFIX = "data: ";
+const SSE_DONE = "[DONE]";
+/** Parse SSE chunks from an OpenAI-compatible stream. */
+function parseSSELine(line) {
+    if (!line.startsWith(SSE_PREFIX))
+        return null;
+    const data = line.slice(SSE_PREFIX.length);
+    if (data === SSE_DONE)
+        return null; // [DONE] signals end
+    return data;
+}
+// ---------------------------------------------------------------------------
+// LlmClient
+// ---------------------------------------------------------------------------
+export class LlmClient {
+    opts;
+    streamEnabled;
+    constructor(opts) {
+        this.opts = opts;
+        this.streamEnabled = opts.stream !== false; // default true
+    }
+    get model() {
+        return this.opts.model;
+    }
+    // ── Non-streaming ──────────────────────────────────────────────────────────
+    async chat(messages, tools, opts = {}) {
+        const url = `${this.opts.baseUrl.replace(/\/$/, "")}/chat/completions`;
+        const { signal, cleanup } = combinedSignal(opts.signal, LLM_REQUEST_TIMEOUT_MS);
+        const body = JSON.stringify({
+            model: this.opts.model,
+            messages,
+            tools: tools.length > 0 ? tools : undefined,
+            temperature: this.opts.temperature,
+            max_tokens: this.opts.maxTokens,
+            stream: false,
+        });
+        let res;
+        try {
+            res = await withRetry(async () => {
+                const r = await fetch(url, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json", Authorization: `Bearer ${this.opts.apiKey}` },
+                    body,
+                    signal,
+                });
+                if (!r.ok)
+                    throw await toLlmError(r, url);
+                return r;
+            }, {}, (attempt, delay, reason) => console.error(`⚠  LLM request failed (${reason}), retrying in ${(delay / 1000).toFixed(1)}s (attempt ${attempt}/3)...`));
+        }
+        finally {
+            cleanup();
+        }
+        const data = (await res.json());
+        const choice = data.choices?.[0]?.message;
+        if (!choice)
+            throw new LlmError("LLM API returned no message in response");
+        return {
+            message: {
+                role: "assistant",
+                content: choice.content ?? null,
+                stop_reason: choice.stop_reason ?? (choice.content ? "stop" : undefined),
+                tool_calls: choice.tool_calls?.map((tc) => ({
+                    id: tc.id ?? "",
+                    name: tc.function?.name ?? "",
+                    arguments: tc.function?.arguments ?? "",
+                })),
+            },
+            usage: data.usage,
+        };
+    }
+    // ── Streaming ───────────────────────────────────────────────────────────────
+    /**
+     * Stream chat completions, yielding incremental chunks.
+     * Falls back to non-streaming on stream-related errors.
+     */
+    async *streamChat(messages, tools, opts = {}) {
+        const url = `${this.opts.baseUrl.replace(/\/$/, "")}/chat/completions`;
+        const { signal, cleanup } = combinedSignal(opts.signal, LLM_REQUEST_TIMEOUT_MS);
+        const bodyStr = JSON.stringify({
+            model: this.opts.model,
+            messages,
+            tools: tools.length > 0 ? tools : undefined,
+            temperature: this.opts.temperature,
+            max_tokens: this.opts.maxTokens,
+            stream: true,
+        });
+        let res;
+        try {
+            res = await withRetry(async () => {
+                const r = await fetch(url, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json", Authorization: `Bearer ${this.opts.apiKey}` },
+                    body: bodyStr,
+                    signal,
+                });
+                if (!r.ok)
+                    throw await toLlmError(r, url);
+                return r;
+            }, {}, (attempt, delay, reason) => console.error(`⚠  LLM 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(`Stream fetch error after retries at ${url}: ${err.message}`);
+        }
+        if (!res.body) {
+            throw new LlmError("Response body is not readable (not a streaming response)");
+        }
+        // Accumulators for tool_calls across chunks
+        const accumulatedToolCalls = [];
+        let finalResult;
+        const reader = res.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                // Process complete lines
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? ""; // keep incomplete line in buffer
+                for (const rawLine of lines) {
+                    const json = parseSSELine(rawLine);
+                    if (!json)
+                        continue;
+                    let chunkData;
+                    try {
+                        chunkData = JSON.parse(json);
+                    }
+                    catch {
+                        continue; // skip malformed JSON lines
+                    }
+                    const choice = chunkData.choices?.[0];
+                    if (!choice)
+                        continue;
+                    const delta = choice.delta;
+                    // Text content delta
+                    if (delta?.content != null && delta.content.length > 0) {
+                        yield { contentDelta: delta.content, done: false };
+                    }
+                    // Tool call deltas
+                    if (delta?.tool_calls) {
+                        for (const tc of delta.tool_calls) {
+                            const idx = tc.index ?? 0;
+                            if (!accumulatedToolCalls[idx]) {
+                                accumulatedToolCalls[idx] = { arguments: "" };
+                            }
+                            if (tc.id)
+                                accumulatedToolCalls[idx].id = tc.id;
+                            if (tc.function?.name)
+                                accumulatedToolCalls[idx].name = tc.function.name;
+                            if (tc.function?.arguments) {
+                                accumulatedToolCalls[idx].arguments += tc.function.arguments;
+                            }
+                            yield {
+                                toolCallDelta: {
+                                    index: idx,
+                                    id: tc.id,
+                                    name: tc.function?.name,
+                                    argumentsDelta: tc.function?.arguments,
+                                },
+                                done: false,
+                            };
+                        }
+                    }
+                    // Final chunk
+                    if (choice.finish_reason) {
+                        // Collect final tool_calls
+                        const toolCalls = accumulatedToolCalls
+                            .filter((tc) => tc.name)
+                            .map((tc) => ({
+                            id: tc.id ?? "",
+                            name: tc.name ?? "",
+                            arguments: tc.arguments,
+                        }));
+                        finalResult = {
+                            message: {
+                                role: "assistant",
+                                content: null,
+                                stop_reason: choice.finish_reason,
+                                tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+                            },
+                            usage: chunkData.usage,
+                        };
+                    }
+                }
+            }
+        }
+        finally {
+            // Cancel the body (frees the socket) and clear the request timeout
+            try {
+                reader.cancel();
+            }
+            catch { /* already released */ }
+            reader.releaseLock();
+            cleanup();
+        }
+        yield { done: true, final: finalResult };
+    }
+}

package/dist/logger.js

@@ -0,0 +1,78 @@
+/**
+ * Structured JSONL session logging.
+ * One JSON object per line — parseable with jq or any log consumer.
+ * Never crashes the agent: write failures are swallowed after one warning.
+ */
+import { mkdirSync, appendFileSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+export class JsonlLogger {
+    filePath;
+    warned = false;
+    constructor(path) {
+        this.filePath = path;
+    }
+    /**
+     * Create a logger for a session.
+     * logFile: true    -> <workdir>/.scoder/logs/<sessionId>.jsonl
+     *          string  -> that exact path
+     *          false/undefined -> disabled (no-op)
+     */
+    static forSession(workdir, sessionId, logFile) {
+        if (logFile === undefined || logFile === false || logFile === null) {
+            return new JsonlLogger(null);
+        }
+        const path = typeof logFile === "string" && logFile.length > 0
+            ? resolve(logFile)
+            : resolve(workdir, ".scoder/logs", `${sessionId}.jsonl`);
+        try {
+            mkdirSync(dirname(path), { recursive: true });
+            return new JsonlLogger(path);
+        }
+        catch (err) {
+            console.error(`⚠  logging disabled (cannot create log dir): ${err.message}`);
+            return new JsonlLogger(null);
+        }
+    }
+    get enabled() {
+        return this.filePath !== null;
+    }
+    /** Read a session's JSONL log file, returning parsed events (or null if missing/unreadable). */
+    static read(workdir, sessionId) {
+        const path = resolve(workdir, ".scoder/logs", `${sessionId}.jsonl`);
+        let content;
+        try {
+            content = readFileSync(path, "utf8");
+        }
+        catch {
+            return null;
+        }
+        const events = [];
+        for (const line of content.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                events.push(JSON.parse(line));
+            }
+            catch {
+                // skip malformed lines
+            }
+        }
+        return events;
+    }
+    /** Append one event. Never throws. */
+    log(event) {
+        if (!this.filePath)
+            return;
+        try {
+            const line = JSON.stringify({ ts: new Date().toISOString(), ...event });
+            appendFileSync(this.filePath, line + "\n", "utf8");
+        }
+        catch (err) {
+            if (!this.warned) {
+                this.warned = true;
+                console.error(`⚠  log write failed (${err.message}) — disabling session log`);
+            }
+            this.filePath = null;
+        }
+    }
+}

package/dist/mcp.js

@@ -0,0 +1,189 @@
+/**
+ * Minimal MCP (Model Context Protocol) client for stdio servers.
+ *
+ * Implements JSON-RPC 2.0 over stdin/stdout with line-delimited messages.
+ * Connects to configured stdio servers, exposes their tools as
+ * `mcp__<server>__<tool>` prefixed names in the agent's tool registry.
+ */
+import { spawn } from "node:child_process";
+import { CLIENT_NAME, getVersion } from "./version.js";
+export const MCP_TOOL_PREFIX = "mcp__";
+export function mcpToolKey(serverName, toolName) {
+    return `${MCP_TOOL_PREFIX}${serverName}__${toolName}`;
+}
+/** Expand {env:VAR} references in config env values. */
+function expandEnv(env) {
+    const out = {};
+    for (const [k, v] of Object.entries(env ?? {})) {
+        out[k] = v.replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, n) => process.env[n] ?? "");
+    }
+    return out;
+}
+// ── JSON-RPC stdio connection ─────────────────────────────────────────────────
+export class McpConnection {
+    name;
+    cfg;
+    proc = null;
+    nextId = 1;
+    pending = new Map();
+    buf = "";
+    constructor(name, cfg) {
+        this.name = name;
+        this.cfg = cfg;
+    }
+    get alive() {
+        return this.proc !== null && this.proc.exitCode === null;
+    }
+    async connect(timeoutMs = 15_000) {
+        const p = spawn(this.cfg.command, this.cfg.args ?? [], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: { ...process.env, ...expandEnv(this.cfg.env) },
+        });
+        this.proc = p;
+        p.stderr?.on("data", () => { });
+        p.on("error", (e) => this.drain(new Error(`spawn: ${e.message}`)));
+        p.on("exit", () => this.drain(new Error("process exited")));
+        p.stdout?.on("data", (c) => this.onChunk(c));
+        // MCP handshake: initialize + notifications/initialized
+        await this.rpc("initialize", {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: { name: CLIENT_NAME, version: getVersion() },
+        }, timeoutMs);
+        this.send({ jsonrpc: "2.0", method: "notifications/initialized" });
+    }
+    async listTools(timeoutMs = 120_000) {
+        const res = await this.rpc("tools/list", {}, timeoutMs);
+        return (res.tools ?? []).filter((t) => typeof t.name === "string");
+    }
+    async callTool(name, args, timeoutMs = 120_000) {
+        const res = await this.rpc("tools/call", { name, arguments: args }, timeoutMs);
+        const isErr = res.isError === true;
+        const parts = (res.content ?? []).map((c) => c.text ?? "").filter(Boolean);
+        return { ok: !isErr, output: parts.join("\n") || "(empty result)" };
+    }
+    kill() {
+        this.drain(new Error("disconnected"));
+        if (this.proc) {
+            try {
+                this.proc.kill();
+            }
+            catch { /* already dead */ }
+            this.proc = null;
+        }
+    }
+    // ── internals ─────────────────────────────────────────────────────────────
+    send(msg) {
+        if (!this.proc?.stdin?.writable)
+            return;
+        try {
+            this.proc.stdin.write(JSON.stringify(msg) + "\n");
+        }
+        catch { /* ignore */ }
+    }
+    async rpc(method, params, timeoutMs) {
+        if (!this.alive)
+            throw new Error(`MCP server "${this.name}" not connected`);
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`MCP "${method}" timed out after ${(timeoutMs / 1000).toFixed(0)}s`));
+            }, timeoutMs);
+            this.pending.set(id, {
+                resolve: (v) => { clearTimeout(timer); resolve(v); },
+                reject: (e) => { clearTimeout(timer); reject(e); },
+            });
+            this.send({ jsonrpc: "2.0", id, method, params });
+        });
+    }
+    onChunk(chunk) {
+        this.buf += chunk.toString("utf8");
+        let i;
+        while ((i = this.buf.indexOf("\n")) !== -1) {
+            const line = this.buf.slice(0, i).trim();
+            this.buf = this.buf.slice(i + 1);
+            if (!line)
+                continue;
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (msg.id === undefined)
+                continue;
+            const pending = this.pending.get(msg.id);
+            if (!pending)
+                continue;
+            this.pending.delete(msg.id);
+            if (msg.error)
+                pending.reject(new Error(`${msg.error.code}: ${msg.error.message}`));
+            else
+                pending.resolve(msg.result ?? {});
+        }
+    }
+    drain(err) {
+        for (const [, p] of this.pending)
+            p.reject(err);
+        this.pending.clear();
+    }
+}
+export class McpManager {
+    configs;
+    conns = new Map();
+    tools = new Map();
+    constructor(configs) {
+        this.configs = configs;
+    }
+    /** Connect all servers; skip failures with a warning. Returns discovered tool count. */
+    async connectAll() {
+        await Promise.allSettled(Object.entries(this.configs).map(async ([name, cfg]) => {
+            const conn = new McpConnection(name, cfg);
+            await conn.connect();
+            const defs = await conn.listTools();
+            for (const def of defs) {
+                const key = mcpToolKey(name, def.name);
+                if (this.tools.has(key))
+                    throw new Error(`Duplicate MCP tool: ${key}`);
+                this.tools.set(key, { conn, serverName: name, toolName: def.name, def });
+            }
+            this.conns.set(name, conn);
+        })).then((results) => {
+            results.forEach((r, i) => {
+                const name = Object.keys(this.configs)[i];
+                if (r.status === "rejected") {
+                    console.error(`⚠  MCP server "${name}" unavailable: ${String(r.reason?.message).slice(0, 160)}`);
+                }
+                else {
+                    const n = [...this.tools.values()].filter((t) => t.serverName === name).length;
+                    console.error(`✓ MCP "${name}" connected — ${n} tool${n === 1 ? "" : "s"}`);
+                }
+            });
+        });
+        return this.tools.size;
+    }
+    hasTool(name) {
+        return this.tools.has(name);
+    }
+    getTool(name) {
+        return this.tools.get(name);
+    }
+    /** Convert all discovered MCP tools to OpenAI function-calling specs. */
+    toToolSpecs() {
+        return [...this.tools.values()].map(({ conn: _, serverName, toolName, def }) => ({
+            type: "function",
+            function: {
+                name: mcpToolKey(serverName, toolName),
+                description: def.description ?? `MCP tool "${toolName}" from server "${serverName}"`,
+                parameters: def.inputSchema ?? { type: "object", properties: {} },
+            },
+        }));
+    }
+    killAll() {
+        for (const c of this.conns.values())
+            c.kill();
+        this.conns.clear();
+    }
+}