@vietor/easy-agent 0.3.1 → 0.4.2

package/dist/core/agent.js

@@ -1,134 +0,0 @@
-import { withAbort } from "../util/async.js";
-const STALL_THRESHOLD = 3;
-const MAX_TURNS = 50;
-const COMPACT_PROMPT = "Summarize this conversation into a concise context summary. Preserve the user's goal, decisions made, files touched, and current progress. Write the summary in the same language the user used in the conversation. Begin your reply with \"Summary of conversation so far:\".";
-export class Agent {
-    llm;
-    conversation;
-    tools;
-    ask;
-    constructor(llm, conversation, tools, ask) {
-        this.llm = llm;
-        this.conversation = conversation;
-        this.tools = tools;
-        this.ask = ask;
-    }
-    get contextTokens() {
-        return this.conversation.getEstimatedTokens();
-    }
-    clear() {
-        this.conversation.clear();
-    }
-    export() {
-        return this.conversation.export();
-    }
-    async compact(signal) {
-        const history = this.conversation.toLLM().slice(1);
-        if (history.length === 0)
-            return;
-        const request = [
-            ...history,
-            { role: "user", content: COMPACT_PROMPT },
-        ];
-        const msg = await this.llm.chat({ messages: request, tools: [], signal });
-        this.conversation.compact(msg.content || "");
-    }
-    async run(userInput, onEvent, signal) {
-        await this.runTurn({ role: "user", content: userInput }, onEvent, signal);
-    }
-    async runSkill(skill, onEvent, signal) {
-        await this.runTurn({ role: "skill", name: skill.name, content: skill.prompt }, onEvent, signal);
-    }
-    async runTurn(msg, onEvent, signal) {
-        this.conversation.add(msg);
-        this.conversation.createSnapshot();
-        try {
-            await this.loop(onEvent, signal);
-        }
-        finally {
-            this.conversation.clearSnapshot();
-        }
-    }
-    async loop(onEvent, signal) {
-        await withAbort(async (aborted) => {
-            let lastSig = "";
-            let stall = 0;
-            let turns = 0;
-            while (true) {
-                let msg;
-                try {
-                    msg = await this.llm.chat({
-                        messages: this.conversation.toLLM(),
-                        tools: this.tools.schemas(),
-                        onDelta: (text) => onEvent?.({ type: "delta", text }),
-                        onRetry: (attempt, max) => onEvent?.({ type: "retry", attempt, max }),
-                        onUsage: (promptTokens, completionTokens) => onEvent?.({ type: "usage", promptTokens, completionTokens }),
-                        signal,
-                    });
-                }
-                catch (e) {
-                    if (aborted())
-                        return;
-                    onEvent?.({ type: "error", text: e.message });
-                    return;
-                }
-                this.conversation.add(msg);
-                if (!msg.tool_calls?.length)
-                    return;
-                if (aborted())
-                    return;
-                const sig = msg.tool_calls
-                    .map((c) => `${c.function.name}:${c.function.arguments}`)
-                    .join("|");
-                stall = sig === lastSig ? stall + 1 : 1;
-                lastSig = sig;
-                if (stall >= STALL_THRESHOLD) {
-                    onEvent?.({ type: "error", text: "agent stalled: repeated identical tool calls" });
-                    return;
-                }
-                if (++turns >= MAX_TURNS) {
-                    onEvent?.({ type: "error", text: `agent exceeded max turns (${MAX_TURNS})` });
-                    return;
-                }
-                const results = await Promise.all(msg.tool_calls.map(async (call) => {
-                    let args = {};
-                    let argsError = "";
-                    if (call.function.arguments) {
-                        try {
-                            args = JSON.parse(call.function.arguments);
-                        }
-                        catch (e) {
-                            argsError = `Error: invalid arguments: ${e.message}`;
-                        }
-                    }
-                    const summary = this.tools.summarize(call.function.name, args);
-                    onEvent?.({ type: "tool_start", id: call.id, name: call.function.name, summary });
-                    if (aborted())
-                        return null;
-                    const ctx = { signal, ask: this.ask };
-                    const result = argsError
-                        ? { content: argsError, isError: true }
-                        : await this.tools.execute(call.function.name, args, ctx);
-                    if (aborted())
-                        return null;
-                    onEvent?.({ type: "tool_end", id: call.id, result: result.content, isError: result.isError });
-                    return { id: call.id, content: result.content };
-                }));
-                if (aborted())
-                    return;
-                for (const r of results) {
-                    if (r)
-                        this.conversation.add({ role: "tool", tool_call_id: r.id, content: r.content });
-                }
-                if (aborted())
-                    return;
-            }
-        }, {
-            signal,
-            onAbort: () => {
-                this.conversation.restoreFromSnapshot();
-                onEvent?.({ type: "interrupted" });
-            },
-        });
-    }
-}

package/dist/core/conversation.js

@@ -1,82 +0,0 @@
-function estimateTokens(text) {
-    if (!text)
-        return 0;
-    const cjk = (text.match(/[一-龥぀-ヿ가-힯]/g) || []).length;
-    const wordChars = (text.match(/[a-zA-Z0-9']/g) || []).length;
-    const words = (text.match(/[a-zA-Z0-9']+/g) || []).length;
-    const rest = text.length - cjk - wordChars;
-    return Math.ceil(cjk * 1.6 + words * 1.3 + rest * 0.3);
-}
-function messageText(msg) {
-    const parts = [];
-    if (typeof msg.content === "string")
-        parts.push(msg.content);
-    else if (Array.isArray(msg.content)) {
-        for (const p of msg.content) {
-            if (p.type === "text")
-                parts.push(p.text);
-        }
-    }
-    if ("tool_calls" in msg && msg.tool_calls) {
-        for (const tc of msg.tool_calls) {
-            if (tc.function?.name)
-                parts.push(tc.function.name);
-            if (tc.function?.arguments)
-                parts.push(tc.function.arguments);
-        }
-    }
-    return parts.join(" ");
-}
-export class Conversation {
-    system;
-    systemEstimateTokens;
-    messages = [];
-    estimatedTokens = 0;
-    messagesSnapshot;
-    estimatedTokensSnapshot = 0;
-    constructor(system) {
-        this.system = system;
-        this.systemEstimateTokens = estimateTokens(system);
-        this.messages.push({ role: "system", content: system });
-        this.estimatedTokens = this.systemEstimateTokens;
-    }
-    getEstimatedTokens() {
-        return this.estimatedTokens;
-    }
-    add(msg) {
-        this.messages.push(msg);
-        this.estimatedTokens += estimateTokens(messageText(msg));
-    }
-    toLLM() {
-        return this.messages.map((m) => (m.role === "skill" ? { role: "user", name: m.name, content: m.content } : m));
-    }
-    export() {
-        return this.messages.slice(1);
-    }
-    clear() {
-        this.messages = [{ role: "system", content: this.system }];
-        this.estimatedTokens = this.systemEstimateTokens;
-    }
-    compact(summary) {
-        this.messages = [
-            { role: "system", content: this.system },
-            { role: "assistant", content: summary },
-        ];
-        this.estimatedTokens = this.systemEstimateTokens + estimateTokens(summary);
-    }
-    createSnapshot() {
-        this.messagesSnapshot = this.messages.slice();
-        this.estimatedTokensSnapshot = this.estimatedTokens;
-    }
-    restoreFromSnapshot() {
-        const snap = this.messagesSnapshot;
-        if (snap) {
-            this.messages = snap.slice();
-            this.estimatedTokens = this.estimatedTokensSnapshot;
-        }
-    }
-    clearSnapshot() {
-        this.messagesSnapshot = undefined;
-        this.estimatedTokensSnapshot = 0;
-    }
-}

package/dist/core/logstore.js

@@ -1,49 +0,0 @@
-export class LogStore {
-    entries = [];
-    version = 0;
-    listeners = new Set();
-    getSnapshot = () => this.version;
-    subscribe = (listener) => {
-        this.listeners.add(listener);
-        return () => this.listeners.delete(listener);
-    };
-    get all() {
-        return this.entries;
-    }
-    append(entry) {
-        this.entries.push(entry);
-        this.version++;
-        this.emit();
-    }
-    setResult(id, result, isError) {
-        for (let i = this.entries.length - 1; i >= 0; i--) {
-            const entry = this.entries[i];
-            if (entry.kind === "tool" && entry.id === id && entry.result === null) {
-                this.entries[i] = { ...entry, result, isError };
-                this.version++;
-                this.emit();
-                return;
-            }
-        }
-    }
-    setAnswer(id, answer) {
-        for (let i = this.entries.length - 1; i >= 0; i--) {
-            const entry = this.entries[i];
-            if (entry.kind === "question" && entry.id === id && entry.answer === null) {
-                this.entries[i] = { ...entry, answer };
-                this.version++;
-                this.emit();
-                return;
-            }
-        }
-    }
-    clear() {
-        this.entries = [];
-        this.version++;
-        this.emit();
-    }
-    emit() {
-        for (const listener of this.listeners)
-            listener();
-    }
-}

package/dist/core/session.js

@@ -1,181 +0,0 @@
-import { Agent } from "./agent.js";
-import { Conversation } from "./conversation.js";
-import { LogStore } from "./logstore.js";
-export class Session {
-    agent;
-    mcp;
-    commands;
-    log = new LogStore();
-    callbacks;
-    streamingText = "";
-    elapsed = 0;
-    abortController = null;
-    timer;
-    startTime = 0;
-    pendingQuestions = new Map();
-    questionSeq = 0;
-    getSnapshot = () => this.log.getSnapshot();
-    subscribe = (listener) => this.log.subscribe(listener);
-    get logEntries() {
-        return this.log.all;
-    }
-    constructor(llm, systemPrompt, tools, commands, mcp) {
-        const conversation = new Conversation(systemPrompt);
-        this.agent = new Agent(llm, conversation, tools, (q, o) => this.ask(q, o));
-        this.commands = commands;
-        this.mcp = mcp;
-        mcp.onError = (msg) => this.appendLog({ kind: "error", text: msg });
-        for (const msg of mcp.flushErrors())
-            this.appendLog({ kind: "error", text: msg });
-    }
-    dispose() {
-        this.mcp.kill();
-    }
-    setCallbacks(cb) {
-        this.callbacks = cb;
-    }
-    get contextTokens() {
-        return this.agent.contextTokens;
-    }
-    appendLog(entry) {
-        this.log.append(entry);
-    }
-    clearLog() {
-        this.log.clear();
-    }
-    clear() {
-        this.agent.clear();
-        this.clearLog();
-    }
-    export() {
-        return this.agent.export();
-    }
-    async compact() {
-        const ctrl = new AbortController();
-        this.abortController = ctrl;
-        try {
-            await this.agent.compact(ctrl.signal);
-            return true;
-        }
-        catch (e) {
-            if (ctrl.signal.aborted)
-                return false;
-            throw e;
-        }
-        finally {
-            this.abortController = null;
-        }
-    }
-    abort() {
-        this.abortController?.abort();
-        for (const id of this.pendingQuestions.keys()) {
-            this.log.setAnswer(id, "");
-            this.pendingQuestions.get(id)?.("");
-        }
-        this.pendingQuestions.clear();
-    }
-    ask(text, options) {
-        const id = `q${++this.questionSeq}`;
-        this.appendLog({ kind: "question", id, text, options, answer: null });
-        return new Promise((resolve) => {
-            this.pendingQuestions.set(id, resolve);
-        });
-    }
-    submitAnswer(id, answer) {
-        this.log.setAnswer(id, answer);
-        const resolve = this.pendingQuestions.get(id);
-        if (resolve) {
-            this.pendingQuestions.delete(id);
-            resolve(answer);
-        }
-    }
-    get commandSchemas() {
-        return this.commands.schemas();
-    }
-    isCommand(name) {
-        return this.commands.exists(name);
-    }
-    async executeCommand(name, host) {
-        await this.commands.execute(name, { session: this, mcp: this.mcp }, {
-            exit: host.exit,
-            info: (t) => this.appendLog({ kind: "system", text: t }),
-            error: (t) => this.appendLog({ kind: "error", text: t }),
-            thinking: (on) => host.setRunning(on),
-            runSkill: (s) => this.startSkill(s),
-        });
-    }
-    async startPrompt(text) {
-        this.appendLog({ kind: "user", text });
-        await this.run((signal) => this.agent.run(text, this.makeHandler(), signal));
-    }
-    async startSkill(skill) {
-        this.appendLog({ kind: "skill", name: skill.name });
-        await this.run((signal) => this.agent.runSkill(skill, this.makeHandler(), signal));
-    }
-    async run(runFn) {
-        this.streamingText = "";
-        this.elapsed = 0;
-        this.startTime = Date.now();
-        this.abortController = new AbortController();
-        this.callbacks?.onElapsedChange?.(0);
-        this.callbacks?.onUsageChange?.(0, 0);
-        this.callbacks?.onRunStateChange?.(true);
-        this.timer = setInterval(() => {
-            this.elapsed = Math.floor((Date.now() - this.startTime) / 1000);
-            this.callbacks?.onElapsedChange?.(this.elapsed);
-        }, 1000);
-        try {
-            await runFn(this.abortController.signal);
-            this.flushStreaming();
-        }
-        catch (e) {
-            this.flushStreaming();
-            this.appendLog({ kind: "error", text: e.message });
-        }
-        finally {
-            clearInterval(this.timer);
-            this.timer = undefined;
-            this.abortController = null;
-            this.callbacks?.onRunStateChange?.(false);
-        }
-    }
-    makeHandler() {
-        return (e) => {
-            switch (e.type) {
-                case "delta":
-                    this.streamingText += e.text;
-                    this.callbacks?.onStreaming?.(this.streamingText);
-                    break;
-                case "tool_start":
-                    this.flushStreaming();
-                    this.appendLog({ kind: "tool", id: e.id, name: e.name, summary: e.summary, result: null });
-                    break;
-                case "retry":
-                    this.streamingText = "";
-                    this.appendLog({ kind: "retry", attempt: e.attempt, max: e.max });
-                    break;
-                case "tool_end":
-                    this.log.setResult(e.id, e.result, e.isError);
-                    break;
-                case "error":
-                    this.flushStreaming();
-                    this.appendLog({ kind: "error", text: e.text });
-                    break;
-                case "interrupted":
-                    this.flushStreaming();
-                    this.appendLog({ kind: "interrupted" });
-                    break;
-                case "usage":
-                    this.callbacks?.onUsageChange?.(e.promptTokens, e.completionTokens);
-                    break;
-            }
-        };
-    }
-    flushStreaming() {
-        if (this.streamingText) {
-            this.appendLog({ kind: "assistant", text: this.streamingText });
-            this.streamingText = "";
-            this.callbacks?.onStreaming?.("");
-        }
-    }
-}

package/dist/llm/client.js

@@ -1,80 +0,0 @@
-import OpenAI, { APIConnectionError, APIError } from "openai";
-import { withRetry } from "../util/async.js";
-const MAX_RETRIES = 3;
-export class LLMClient {
-    client;
-    model;
-    constructor(config) {
-        this.client = new OpenAI({
-            apiKey: config.apiKey,
-            baseURL: config.baseUrl || undefined,
-            maxRetries: 0,
-        });
-        this.model = config.model;
-    }
-    async chat(opts) {
-        return withRetry(() => this.streamOnce(opts.messages, opts.tools, opts.onDelta, opts.onUsage, opts.signal), {
-            retries: MAX_RETRIES,
-            retryable: (e) => {
-                if (e instanceof APIConnectionError)
-                    return true;
-                if (e instanceof APIError && e.status)
-                    return e.status === 429 || e.status >= 500;
-                return false;
-            },
-            backoff: (attempt) => 1000 * 2 ** attempt,
-            onRetry: opts.onRetry,
-            signal: opts.signal,
-        });
-    }
-    async streamOnce(messages, tools, onDelta, onUsage, signal) {
-        let content = "";
-        const calls = new Map();
-        const stream = await this.client.chat.completions.create({
-            model: this.model,
-            messages,
-            tools,
-            stream: true,
-            stream_options: { include_usage: true },
-        }, { signal });
-        for await (const chunk of stream) {
-            if (chunk.usage) {
-                onUsage?.(chunk.usage.prompt_tokens ?? 0, chunk.usage.completion_tokens ?? 0);
-            }
-            const delta = chunk.choices[0]?.delta;
-            if (!delta)
-                continue;
-            if (delta.content) {
-                content += delta.content;
-                onDelta?.(delta.content);
-            }
-            if (delta.tool_calls) {
-                for (const tc of delta.tool_calls) {
-                    let acc = calls.get(tc.index);
-                    if (!acc) {
-                        acc = { id: tc.id ?? "", name: "", arguments: "" };
-                        calls.set(tc.index, acc);
-                    }
-                    if (tc.function?.name)
-                        acc.name += tc.function.name;
-                    if (tc.function?.arguments)
-                        acc.arguments += tc.function.arguments;
-                }
-            }
-        }
-        const message = {
-            role: "assistant",
-            content: content || null,
-        };
-        if (calls.size) {
-            message.tool_calls = [...calls.entries()]
-                .sort((a, b) => a[0] - b[0])
-                .map(([, acc]) => ({
-                id: acc.id,
-                type: "function",
-                function: { name: acc.name, arguments: acc.arguments },
-            }));
-        }
-        return message;
-    }
-}

package/dist/llm/types.js

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

package/dist/mcp/client.js

@@ -1,81 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { getPackageInfo } from "../util/package.js";
-function getClientInfo() {
-    const pkginfo = getPackageInfo();
-    return { name: pkginfo.name, version: pkginfo.version };
-}
-const STDERR_MAX_LINES = 20;
-export class MCPClient {
-    name;
-    client = new Client(getClientInfo(), { capabilities: {} });
-    transport;
-    connectReject;
-    stderrBuf = [];
-    constructor(name, config) {
-        this.name = name;
-        if ("command" in config) {
-            const t = new StdioClientTransport({ ...config, stderr: "pipe" });
-            this.transport = t;
-            t.stderr?.on("data", (chunk) => {
-                for (const line of chunk.toString("utf8").split(/\r?\n/)) {
-                    if (!line)
-                        continue;
-                    this.stderrBuf.push(line);
-                    if (this.stderrBuf.length > STDERR_MAX_LINES)
-                        this.stderrBuf.shift();
-                }
-            });
-        }
-        else {
-            const opts = { requestInit: { headers: config.headers } };
-            const url = new URL(config.url);
-            this.transport =
-                config.type === "sse"
-                    ? new SSEClientTransport(url, opts)
-                    : new StreamableHTTPClientTransport(url, opts);
-        }
-    }
-    stderrTail() {
-        return this.stderrBuf.join("\n");
-    }
-    async connect() {
-        return new Promise((resolve, reject) => {
-            this.connectReject = reject;
-            this.client
-                .connect(this.transport)
-                .then(resolve, reject)
-                .finally(() => {
-                this.connectReject = undefined;
-            });
-        });
-    }
-    async listTools() {
-        return this.client.listTools().then((r) => r.tools);
-    }
-    async callTool(name, args, signal) {
-        return this.client.callTool({ name, arguments: args }, undefined, { signal });
-    }
-    kill() {
-        this.connectReject?.(new Error("aborted"));
-        this.connectReject = undefined;
-        this.client.close().catch(() => { });
-        if (this.transport instanceof StdioClientTransport) {
-            const pid = this.transport.pid;
-            if (!pid)
-                return;
-            try {
-                if (process.platform === "win32") {
-                    spawnSync("taskkill", ["/PID", String(pid), "/T", "/F"], { windowsHide: true });
-                }
-                else {
-                    process.kill(pid, "SIGTERM");
-                }
-            }
-            catch { }
-        }
-    }
-}