@vietor/easy-agent 0.3.1 → 0.4.1

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 { }
-        }
-    }
-}

package/dist/mcp/server.js

@@ -1,124 +0,0 @@
-import { MCPClient } from "./client.js";
-import { withTimeout } from "../util/async.js";
-const CONNECT_TIMEOUT = 30_000;
-function serverType(cfg) {
-    return "command" in cfg ? "stdio" : cfg.type;
-}
-function fixError(text) {
-    return text.startsWith("Error: ") ? text : `Error: ${text}`;
-}
-function extractContent(result) {
-    const parts = [];
-    for (const c of result.content) {
-        switch (c.type) {
-            case "text":
-                parts.push(c.text);
-                break;
-            case "image":
-                parts.push(`[image: ${c.mimeType}]`);
-                break;
-            case "audio":
-                parts.push(`[audio: ${c.mimeType}]`);
-                break;
-            case "resource": {
-                const r = c.resource;
-                parts.push("text" in r ? r.text : `[resource: ${r.uri}]`);
-                break;
-            }
-            default:
-                parts.push(`[${c.type}]`);
-        }
-    }
-    if (result.structuredContent) {
-        parts.push(`<structured>${JSON.stringify(result.structuredContent)}</structured>`);
-    }
-    return parts.join("\n");
-}
-export class MCPServers {
-    tools;
-    servers = new Map();
-    pending = new Set();
-    disposed = false;
-    errorBuffer = [];
-    onError;
-    constructor(tools) {
-        this.tools = tools;
-    }
-    report(msg) {
-        if (this.onError)
-            this.onError(msg);
-        else
-            this.errorBuffer.push(msg);
-    }
-    flushErrors() {
-        const buf = this.errorBuffer;
-        this.errorBuffer = [];
-        return buf;
-    }
-    async connect(mcpServers = {}) {
-        await Promise.all(Object.entries(mcpServers).map(async ([name, cfg]) => {
-            if (this.disposed)
-                return;
-            const type = serverType(cfg);
-            if (cfg.enabled === false) {
-                this.servers.set(name, { type, status: "disabled", tools: [] });
-                return;
-            }
-            this.servers.set(name, { type, status: "pending", tools: [] });
-            const client = new MCPClient(name, cfg);
-            this.pending.add(client);
-            try {
-                await withTimeout(client.connect(), CONNECT_TIMEOUT);
-                if (this.disposed) {
-                    client.kill();
-                    return;
-                }
-                const mcpTools = await withTimeout(client.listTools(), CONNECT_TIMEOUT);
-                if (this.disposed) {
-                    client.kill();
-                    return;
-                }
-                this.servers.set(name, { type, status: "online", client, tools: mcpTools.map((t) => t.name) });
-                for (const t of mcpTools)
-                    this.tools.register(this.adapt(name, client, t));
-            }
-            catch (e) {
-                client.kill();
-                if (!this.disposed) {
-                    this.servers.set(name, { type, status: "offline", tools: [] });
-                    const stderr = client.stderrTail();
-                    this.report(`MCP server "${name}" failed: ${e.message}${stderr ? `\n${stderr}` : ""}`);
-                }
-            }
-            finally {
-                this.pending.delete(client);
-            }
-        }));
-    }
-    adapt(server, client, tool) {
-        return {
-            name: `MCP__${server}__${tool.name}`,
-            description: tool.description ?? `${server} ${tool.name}`,
-            parameters: tool.inputSchema,
-            async execute(args, ctx) {
-                const result = await client.callTool(tool.name, args, ctx.signal);
-                const text = extractContent(result);
-                return result.isError
-                    ? { content: fixError(text), isError: true }
-                    : { content: text || "(no output)" };
-            },
-        };
-    }
-    list() {
-        return [...this.servers.entries()].map(([name, s]) => ({ name, type: s.type, status: s.status, tools: s.tools }));
-    }
-    kill() {
-        this.disposed = true;
-        for (const { client } of this.servers.values())
-            client?.kill();
-        for (const client of this.pending)
-            client.kill();
-        this.servers.clear();
-        this.pending.clear();
-    }
-}

package/dist/skills/loader.js

@@ -1,43 +0,0 @@
-import { existsSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { tryReadFileText } from "../util/fs.js";
-function parseSkillFile(skillName, skillFile) {
-    const content = tryReadFileText(skillFile);
-    if (!content)
-        return undefined;
-    const frontMatterRegex = /^---\r?\n([\s\S]*?)\r?\n---/;
-    const match = content.match(frontMatterRegex);
-    let name = null;
-    let description = "";
-    let prompt = content;
-    if (match) {
-        const yamlBody = match[1];
-        prompt = content.replace(match[0], "").trim();
-        const nameMatch = yamlBody.match(/^name:\s*(.+)$/m);
-        if (nameMatch)
-            name = nameMatch[1].trim();
-        const descMatch = yamlBody.match(/^description:\s*(.+)$/m);
-        if (descMatch)
-            description = descMatch[1].trim();
-    }
-    if (!name) {
-        name = skillName;
-    }
-    return { name, description, prompt };
-}
-export function tryLoadSkills(path) {
-    if (!existsSync(path))
-        return undefined;
-    const skills = [];
-    for (const entry of readdirSync(path, { withFileTypes: true })) {
-        if (!entry.isDirectory())
-            continue;
-        const skillFile = join(path, entry.name, "SKILL.md");
-        if (!existsSync(skillFile))
-            continue;
-        const skill = parseSkillFile(entry.name, skillFile);
-        if (skill && skill.prompt)
-            skills.push(skill);
-    }
-    return skills.length > 0 ? skills : undefined;
-}

package/dist/skills/types.js

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

package/dist/tools/ask_user.js

@@ -1,24 +0,0 @@
-const DESCRIPTION = [
-    "Ask the user a question and wait for their answer.",
-    "Use when a decision belongs to the user: multiple reasonable approaches, an irreversible or consequential action, or an ambiguous request. Present choices via options rather than prose.",
-    "options is an optional list of choices; the user may also type a custom answer.",
-    "Returns the user's answer as text; an empty string means the user skipped the question.",
-].join(" ");
-export const askUserTool = {
-    name: "AskUser",
-    description: DESCRIPTION,
-    parameters: {
-        type: "object",
-        properties: {
-            question: { type: "string", description: "The question to ask the user." },
-            options: { type: "array", items: { type: "string" }, description: "Optional list of choices." },
-        },
-        required: ["question"],
-    },
-    async execute(args, ctx) {
-        const question = args.question;
-        const options = Array.isArray(args.options) ? args.options : [];
-        return ctx.ask(question, options);
-    },
-    summaryArg: "question",
-};