@agent-smith/core 0.0.1

package/dist/agents/read.js

@@ -0,0 +1,241 @@
+import path from "path";
+import { compile, serializeGrammar } from "@intrinsicai/gbnfgen";
+import { readSkillsFromList, readTool } from "../db/read.js";
+import { executeAction } from "../actions/cmd.js";
+import { McpClient } from "../mcp.js";
+import { executeWorkflow } from "../workflows/cmd.js";
+import { executeAgent } from "./cmd.js";
+import { openAgentSpec } from "../utils/io.js";
+import { applyFilePlaceholders } from "./files.js";
+//import { confirmToolUsage } from "../tools.js";
+async function readAgent(name, payload, options) {
+    /*console.log("Read Agent", name);
+    console.log("Payload:", payload);
+    console.log("Options:", options);*/
+    const { agentSpec, agentPath } = openAgentSpec(name);
+    //console.log("Agent vars:", agentSpec?.variables);
+    const agentDir = path.dirname(agentPath);
+    if (!options?.backend && agentSpec?.backend) {
+        options.backend = agentSpec.backend;
+    }
+    let ip = {};
+    if (!options?.isToolCall) {
+        if (options?.params) {
+            ip = options.params;
+        }
+        else if (agentSpec?.inferParams) {
+            ip = agentSpec.inferParams;
+        }
+    }
+    else {
+        if (options?.propagateInferParams) {
+            if (options?.params) {
+                ip = options.params;
+            }
+        }
+        else if (agentSpec?.inferParams) {
+            ip = agentSpec.inferParams;
+        }
+    }
+    // vars
+    let vars = {};
+    if (agentSpec?.variables?.optional) {
+        for (const k of Object.keys(agentSpec.variables.optional)) {
+            if (k in payload) {
+                vars[k] = payload[k];
+                vars[k] = payload[k];
+                delete payload[k];
+            }
+            else if (options?.variables) {
+                if (k in options.variables) {
+                    vars[k] = options.variables[k];
+                }
+            }
+            else {
+                // workflow takes variables in options
+                if (k in options) {
+                    vars[k] = options[k];
+                    delete options[k];
+                }
+            }
+        }
+    }
+    if (agentSpec?.variables?.required) {
+        for (const k of Object.keys(agentSpec.variables.required)) {
+            //console.log("TASK V required:", Object.keys(agentSpec.variables.required), "/", k in options, "/", k in payload);
+            if (k in payload) {
+                vars[k] = payload[k];
+                vars[k] = payload[k];
+                delete payload[k];
+            }
+            else if (options?.variables) {
+                if (k in options.variables) {
+                    vars[k] = options.variables[k];
+                }
+            }
+            else {
+                // workflow takes variables in options
+                if (k in options) {
+                    vars[k] = options[k];
+                    delete options[k];
+                }
+            }
+        }
+    }
+    //console.log("END VARS", vars);
+    const mcpServers = new Array();
+    if (!agentSpec?.tools) {
+        agentSpec.tools = [];
+    }
+    const mcpServersArgs = {};
+    if (options?.mcpArgs) {
+        (options.mcpArgs).forEach(v => {
+            const s = v.split(":");
+            if (s.length < 2) {
+                throw new Error(`Malformed mcp option ${v}: use --mcp servername:arg1,arg2`);
+            }
+            const sn = s[0];
+            const sa = s[1];
+            const _margs = sa.split(",");
+            mcpServersArgs[sn] = _margs;
+        });
+        if (options?.debug) {
+            console.log("Opening", options.mcpArgs.length, "server(s)");
+        }
+    }
+    // mcp tools
+    if (agentSpec?.mcp) {
+        for (const [servername, tool] of Object.entries(agentSpec.mcp)) {
+            //console.log("MCP TOOL:", tool)
+            const authorizedTools = new Array();
+            const askUserTools = new Array();
+            if (tool?.tools) {
+                tool.tools.forEach(t => {
+                    let tn = t;
+                    if (t.endsWith("?")) {
+                        tn = t.slice(0, -1);
+                        askUserTools.push(tn);
+                    }
+                    authorizedTools.push(tn);
+                });
+            }
+            const margs = tool.arguments;
+            if (servername in mcpServersArgs) {
+                margs.push(...mcpServersArgs[servername]);
+            }
+            const mcp = new McpClient(servername, tool.command, tool.arguments, authorizedTools.length > 0 ? authorizedTools : null, askUserTools.length > 0 ? askUserTools : null);
+            //console.log("MCP", mcp);
+            mcpServers.push(mcp);
+            /*await mcp.start();
+            const tools = await mcp.extractTools();
+            tools.forEach(t => agentSpec.tools?.push(t))*/
+        }
+    }
+    // tools
+    //console.log("AGENT SPECS", agent.name, agentSpec);
+    if (agentSpec?.skills) {
+        // skills text
+        const sks = readSkillsFromList(agentSpec.skills);
+        const skLines = new Array();
+        for (const s of Object.values(sks)) {
+            if (!s?.variables) {
+                throw new Error(`no variables in skill feature ${s.name}`);
+            }
+            const vars = s.variables;
+            skLines.push("- **" + vars.name + "**: " + vars.description);
+        }
+        const skt = skLines.join("\n");
+        if (agentSpec.prompt.includes("{skills}")) {
+            agentSpec.prompt = agentSpec.prompt.replace("{skills}", skt);
+        }
+        if (agentSpec?.template?.system) {
+            if (agentSpec.template.system.includes("{skills}")) {
+                agentSpec.template.system = agentSpec.template.system.replace("{skills}", skt);
+            }
+        }
+        // load skill
+        //if (agentSpec?.skills) {
+        if (!agentSpec?.toolsList) {
+            agentSpec.toolsList = [];
+        }
+        agentSpec.toolsList.push("load-skill");
+        /*} else {
+            throw new Error(`loading skill: no skills defined in agent`)
+        }*/
+    }
+    //console.log("ATL", agentSpec.toolsList);
+    if (agentSpec?.toolsList) {
+        for (const rawToolName of agentSpec.toolsList) {
+            let toolName = rawToolName;
+            let autoRunTool = true;
+            if (rawToolName.endsWith("?")) {
+                autoRunTool = false;
+                toolName = rawToolName.slice(0, -1);
+            }
+            const { found, tool } = readTool(toolName);
+            if (!found) {
+                throw new Error(`tool ${toolName} not found for agent ${agentSpec.name}`);
+            }
+            //console.log("Tool found:", toolName, tool);
+            const quiet = !options?.debug;
+            const lmTool = {
+                ...tool,
+                execute: async (params) => {
+                    //console.log("EXEC TOOL:", type, toolName, params);
+                    let toolOpts = { ...options };
+                    if (params?.toolOptions) {
+                        toolOpts = params.toolOptions;
+                        //console.log("EXECTOOL CALLER", toolOpts?.caller)
+                        delete params.toolOptions;
+                    }
+                    toolOpts.isToolCall = true;
+                    switch (tool.type) {
+                        case "action":
+                            const res = await executeAction(toolName, params, toolOpts, quiet);
+                            return res;
+                        case "agent":
+                            const agres = await executeAgent(toolName, params, toolOpts);
+                            //console.log("WFTRESP", tres.answer.text);
+                            if (agres?.text) {
+                                return agres.text;
+                            }
+                            return agres;
+                        case "workflow":
+                            const wres = await executeWorkflow(toolName, params, toolOpts);
+                            return wres;
+                        default:
+                            throw new Error(`unknown tool execution function type: ${tool.type} for ${toolName}`);
+                    }
+                }
+            };
+            if (!autoRunTool) {
+                if (!options?.confirmToolUsage) {
+                    throw new Error("provide a tool usage confirm function");
+                }
+                lmTool.canRun = options.confirmToolUsage;
+            }
+            agentSpec.tools.push(lmTool);
+        }
+        delete agentSpec.toolsList;
+    }
+    ;
+    //console.log("AS TOOLS", agentSpec.name, agentSpec.tools);
+    if (options?.isChatMode) {
+        agentSpec.prompt = "{prompt}";
+    }
+    //console.log("TASK SPEC:", JSON.stringify(agentSpec, null, "  "));
+    if (!options?.baseDir) {
+        options.baseDir = agentDir;
+    }
+    applyFilePlaceholders(agentSpec, options.baseDir);
+    //task.addTools(agentSpec.tools);
+    //console.log("TASK TOOLS", task.agent.tools);
+    // check for grammars
+    if (agentSpec?.inferParams?.tsGrammar) {
+        //console.log("TSG");
+        agentSpec.inferParams.grammar = serializeGrammar(await compile(agentSpec.inferParams.tsGrammar, "Grammar"));
+    }
+    //console.log("AS END", agentSpec);
+    return { agentSpec, vars, mcpServers, agentDir };
+}
+export { readAgent };

package/dist/agents/useagent.d.ts

@@ -0,0 +1,13 @@
+import { Agent } from "@agent-smith/agent";
+import type { AgentInferenceOptions, AgentSettings, InferenceResult } from "@agent-smith/types";
+declare const useAgentExecutor: (name: string, payload: {
+    prompt: string;
+} & Record<string, any>, options: AgentInferenceOptions) => Promise<{
+    agent: Agent;
+    vars: Record<string, any>;
+    mcpServers: import("../mcp.js").McpClient[];
+    agentDir: string;
+    settings: AgentSettings;
+    execute: () => Promise<InferenceResult>;
+}>;
+export { useAgentExecutor };

package/dist/agents/useagent.js

@@ -0,0 +1,395 @@
+import { Agent } from "@agent-smith/agent";
+import { compile, serializeGrammar } from "@intrinsicai/gbnfgen";
+import { backend, backends, listBackends } from "../state/backends.js";
+import { initAgentSettings, isAgentSettingsInitialized, agentSettings } from "../state/tasks.js";
+import { processOutput } from "../utils/io.js";
+import { usePerfTimer } from "../utils/perf.js";
+import { runtimeDataError, runtimeError } from "../utils/user_msgs.js";
+import { readAgent } from "./read.js";
+import { toRaw } from "@vue/reactivity";
+import { readAllSkills } from "../db/read.js";
+import { default as fm } from "front-matter";
+import { readFile } from "../utils/sys/read.js";
+const useAgentExecutor = async (name, payload, options) => {
+    const localOptions = Object.assign({}, options);
+    // skill loader
+    if (payload.prompt.includes("%")) {
+        const skills = readAllSkills();
+        for (const [k, v] of Object.entries(skills)) {
+            //console.log("S", k, payload.prompt.includes("%" + k));
+            if (payload.prompt.includes("%" + k)) {
+                const fc = readFile(v.path);
+                const data = fm(fc);
+                payload.prompt = payload.prompt.replace("%" + k, data.body);
+                if (localOptions?.debug) {
+                    console.log(`loading skill ${k} in prompt`);
+                }
+                break;
+            }
+        }
+    }
+    const { agentSpec, vars, mcpServers, agentDir } = await readAgent(name, payload, localOptions);
+    if (!isAgentSettingsInitialized.value) {
+        initAgentSettings();
+    }
+    const hasSettings = Object.keys(agentSettings).includes(name);
+    let settings = {};
+    // backend
+    let backendName = "";
+    if (hasSettings) {
+        settings = agentSettings[name];
+    }
+    //console.log("EA OPTS", localOptions);
+    if (!localOptions?.isToolCall) {
+        if (localOptions?.backend) {
+            //console.log("BK from options", localOptions.backend);
+            backendName = localOptions.backend;
+        }
+        else if (settings?.backend) {
+            //console.log("BK from settings", settings.backend);
+            backendName = settings.backend;
+        }
+        else if (agentSpec?.backend) {
+            //console.log("BK from spec", agentSpec.backend);
+            backendName = agentSpec.backend;
+        }
+        else {
+            // fallback to default backend
+            if (!backend.value?.name) {
+                const m = `${name} agent executor: no default backend set`;
+                console.error(m);
+                throw new Error(m);
+            }
+            //console.log("BK from default", backend.value.name);
+            // use default backend
+            backendName = backend.value.name;
+        }
+    }
+    else {
+        if (localOptions?.propagateModel) {
+            if (!localOptions?.backend) {
+                const m = `${name} agent executor: set a backend in options if propagateModel is false`;
+                console.error(m);
+                throw new Error(m);
+            }
+            backendName = localOptions.backend;
+        }
+        else {
+            if (agentSpec?.backend) {
+                backendName = agentSpec.backend;
+            }
+            else {
+                // if not specified use the default backend
+                if (!backend.value) {
+                    const m = `${name} agent executor: no default backend or agent spec backend specified for propagateModel false.`;
+                    console.error(m, "Default backend:", toRaw(backend), "Backends:", toRaw(backends));
+                    throw new Error(m);
+                }
+                backendName = backend.value.name;
+            }
+        }
+        if (localOptions?.system) {
+            // in context agent
+            if (!agentSpec?.template) {
+                agentSpec.template = { system: localOptions.system };
+            }
+            else {
+                agentSpec.template.system = localOptions.system;
+            }
+        }
+    }
+    if (agentSpec?.template?.system) {
+        localOptions.system = agentSpec.template.system;
+    }
+    if (!(backendName in backends)) {
+        const bks = await listBackends(false);
+        runtimeDataError(`The backend ${backendName} is not registered in config. Available backends:\n`, bks);
+        throw new Error();
+    }
+    /*if (localOptions?.debug) {
+        console.log("Agent executor:", name, "backend:", backendName);
+    }*/
+    if (backendName.length == 0) {
+        throw new Error(`${name} agent executor: no backend set in options`);
+    }
+    // check setting for backend    
+    const agent = new Agent({
+        name: name,
+        lm: backends[backendName],
+    }, agentSpec);
+    //console.log("AGENT BK", backends[backendName], "\nagb:", agent.lm.name)
+    if (!localOptions?.model) {
+        if (hasSettings) {
+            if (settings?.model) {
+                localOptions.model = settings.model;
+            }
+        }
+    }
+    const execute = async () => {
+        //console.log("EXEC AGENT OPTS", localOptions);
+        if (localOptions?.verbosity?.mcp && mcpServers.length > 0) {
+            console.log("Starting", mcpServers.length, "mcp servers");
+        }
+        for (const mcp of mcpServers) {
+            await mcp.start();
+            const _tools = await mcp.extractTools(localOptions);
+            _tools.forEach(t => agentSpec.tools?.push(t));
+            if (localOptions?.verbosity?.mcp) {
+                console.log("MCP start", mcp.name);
+            }
+        }
+        //console.log("TASKCONF IP", conf.inferParams);
+        if (!localOptions?.params) {
+            localOptions.params = {};
+        }
+        let applySettings = hasSettings;
+        if (localOptions?.isToolCall) {
+            if (!localOptions?.propagateInferParams) {
+                applySettings = false;
+            }
+        }
+        if (applySettings) {
+            if (settings?.max_tokens && !localOptions?.params?.max_tokens) {
+                localOptions.params.max_tokens = settings.max_tokens;
+            }
+            if (settings?.top_k && !localOptions?.params?.top_k) {
+                localOptions.params.top_k = settings.top_k;
+            }
+            if (settings?.top_p && !localOptions?.params?.top_p) {
+                localOptions.params.top_p = settings.top_p;
+            }
+            if (settings?.min_p && !localOptions?.params?.min_p) {
+                localOptions.params.min_p = settings.min_p;
+            }
+            if (settings?.temperature && !localOptions?.params?.temperature) {
+                localOptions.params.temperature = settings.temperature;
+            }
+            if (settings?.repeat_penalty && !localOptions?.params?.repeat_penalty) {
+                localOptions.params.repeat_penalty = settings.repeat_penalty;
+            }
+            if (settings?.presence_penalty && !localOptions?.params?.presence_penalty) {
+                localOptions.params.presence_penalty = settings.presence_penalty;
+            }
+            if (settings?.frequency_penalty && !localOptions?.params?.frequency_penalty) {
+                localOptions.params.frequency_penalty = settings.frequency_penalty;
+            }
+            if (settings?.chat_template_kwargs && !localOptions?.params?.chat_template_kwargs) {
+                localOptions.params.chat_template_kwargs = settings.chat_template_kwargs;
+            }
+        }
+        //console.log("TASK MODEL", model);
+        // check for grammars
+        if (localOptions.params?.tsGrammar) {
+            //console.log("TSG");
+            localOptions.params.grammar = serializeGrammar(await compile(localOptions.params.tsGrammar, "Grammar"));
+            delete localOptions.params.tsGrammar;
+        }
+        let c = false;
+        /*if (localOptions?.verbosity?.task) {
+            console.log("Task model:", localOptions.model);
+            console.log("Task vars:", vars);
+        }*/
+        let emittedTokens = 0;
+        let emittedThinkingTokens = 0;
+        const printToken = (t, dim = false) => {
+            if (dim === true) {
+                process.stdout.write(`\x1b[2m${t}\x1b[0m`);
+            }
+            else {
+                if (localOptions?.showTokens === true) {
+                    let txt = t;
+                    txt = c ? t : `\x1b[100m${t}\x1b[0m`;
+                    process.stdout.write(txt);
+                    c = !c;
+                }
+                else {
+                    /*if (formatMode.value == "markdown") {
+                        fullTxt += t;
+                        process.stdout.write('\u001Bc\u001B[3J');
+                        process.stdout.write(marked.parse(fullTxt) as string);*/
+                    //} else {
+                    process.stdout.write(t);
+                    //}
+                }
+            }
+        };
+        const perfTimer = usePerfTimer(false);
+        //const spinner = ora({ text: "Thinking ...", discardStdin: false });
+        let abort = localOptions?.abort ? localOptions.abort : new AbortController();
+        const abortTicker = setInterval(() => {
+            //console.log("ABS", abort.signal.aborted);
+            if (abort.signal.aborted) {
+                agent.lm.abort();
+                abort = new AbortController();
+                return;
+            }
+        }, 200);
+        const processToken = (t) => {
+            if (emittedTokens == 0) {
+                perfTimer.start();
+            }
+            printToken(t);
+            ++emittedTokens;
+        };
+        localOptions.params.stream = true;
+        if (!localOptions?.onToken) {
+            localOptions.onToken = processToken;
+        }
+        localOptions.baseDir = agentDir;
+        localOptions.variables = vars;
+        if (!localOptions?.tools) {
+            localOptions.tools = agentSpec.tools;
+        }
+        let out;
+        //console.log("CLI EXEC AGENT", payload.prompt, "\nOPTS", localOptions)
+        try {
+            out = await agent.run(payload.prompt, localOptions);
+        }
+        catch (e) {
+            //console.log("ERR CATCH", e);
+            const errMsg = `${e}`;
+            if (errMsg.includes("502 Bad Gateway")) {
+                clearInterval(abortTicker);
+                const msg = "The server answered with a 502 Bad Gateway error. It might be down or misconfigured. Check your inference server.";
+                const err = msg + "\n" + errMsg;
+                if ((localOptions?.onError)) {
+                    console.error(err, name);
+                    localOptions.onError(err, name);
+                }
+                else {
+                    runtimeError(msg);
+                    if (localOptions?.nocli) {
+                        throw new Error(err);
+                    }
+                }
+                return {};
+            }
+            else if (errMsg.includes("404 Not Found")) {
+                clearInterval(abortTicker);
+                const msg = "The server answered with a 404 Not Found error. That might mean that the model you are requesting does not exist on the server.";
+                const err = msg + "\n" + errMsg;
+                if ((localOptions?.onError)) {
+                    console.error(err, name);
+                    localOptions.onError(err, name);
+                }
+                else {
+                    runtimeError(msg);
+                    if (localOptions?.nocli) {
+                        throw new Error(err);
+                    }
+                }
+                return {};
+            }
+            else if (errMsg.includes("400 Bad Request")) {
+                clearInterval(abortTicker);
+                const msg = "The server answered with a 400 Bad Request error. That might mean that:\n- The model you are requesting does not exist on the server\n- A parameter is wrong or missing in your request\n- The request size exceeds the available context window size";
+                const err = msg + "\n" + errMsg;
+                if ((localOptions?.onError)) {
+                    console.error(err, name);
+                    localOptions.onError(err, name);
+                }
+                else {
+                    runtimeError();
+                    if (localOptions?.nocli) {
+                        throw new Error(err);
+                    }
+                }
+                return {};
+            }
+            else if (errMsg.includes("fetch failed")) {
+                clearInterval(abortTicker);
+                const msg = "The server is not responding. Check if your inference backend is running.";
+                const err = msg + "\n" + errMsg;
+                if ((localOptions?.onError)) {
+                    console.error(err, name);
+                    localOptions.onError(err, name);
+                }
+                else {
+                    runtimeError(msg);
+                    if (localOptions?.nocli) {
+                        throw new Error(err);
+                    }
+                }
+                //@ts-ignore
+                return;
+            }
+            else if (e instanceof DOMException && e.name === 'AbortError') {
+                if (localOptions?.debug || localOptions?.verbose) {
+                    console.warn("\n*** The request was canceled by the user ***");
+                }
+                clearInterval(abortTicker);
+                /*if ((localOptions?.onError)) {
+                    localOptions.onError(errMsg, name);
+                } else {*/
+                return {};
+                // }
+            }
+            else {
+                throw new Error(errMsg);
+            }
+        }
+        clearInterval(abortTicker);
+        //console.log("END TASK", out);
+        if (!localOptions?.isToolCall) {
+            if (!out.text.endsWith("\n")) {
+                console.log();
+            }
+        }
+        //console.log("END", name, "ISCM", isChatMode.value, "isTC", localOptions?.isToolCall)
+        /*if (!isChatMode.value || localOptions?.isToolCall) {
+            // close mcp connections
+            if (localOptions?.debug && mcpServers.length > 0) {
+                console.log("Closing", mcpServers.length, "mcp server(s)")
+            }
+            mcpServers.forEach((s) => {
+                s.stop();
+                if (localOptions?.debug) {
+                    console.log("MCP stop", s.name);
+                }
+            });
+        }*/
+        await processOutput(out);
+        // chat mode
+        //console.log("CLI CONF IP", initialInferParams);
+        /*if (!localOptions?.isToolCall && isChatMode.value) {
+            if (task.def.tools) {
+                localOptions.tools = task.def.tools
+            }
+            if (task.def.shots) {
+                localOptions.history = localOptions?.history ? [...localOptions.history, ...task.def.shots] : task.def.shots;
+            }
+            if (task.def.template?.system) {
+                localOptions.system = task.def.template.system
+            }
+            if (task.def.template?.assistant) {
+                localOptions.assistant = task.def.template.assistant
+            }
+            setChatInferenceParams(initialInferParams);
+            //await chat(program, localOptions, agent, mcpServers);
+        }*/
+        /*if (localOptions?.verbosity?.stats) {
+            try {
+                console.log(emittedTokens.toString(), color.dim("tokens"), out.stats.tokensPerSecond, color.dim("tps"));
+            } catch (e) {
+                runtimeWarning("Error formating stats:", `${e}`)
+            }
+        }*/
+        /*if (localOptions?.backend || settings?.backend) {
+            //console.log("SET BACK AGENT BACKEND TO", backend.value);
+            // set back the default backend
+            agent.lm = backend.value!;
+        }*/
+        //console.log("TASK OUT", out);
+        //console.log("TASK A", agent);
+        return out;
+    };
+    return {
+        agent,
+        vars,
+        mcpServers,
+        agentDir,
+        settings,
+        execute,
+    };
+};
+export { useAgentExecutor };

package/dist/conf.d.ts

@@ -0,0 +1,14 @@
+import { type ConfigFile } from "@agent-smith/types";
+declare function getConfigPath(appName: string, filename: string): {
+    confDir: string;
+    dbPath: string;
+};
+declare const confDir: string, dbPath: string;
+declare function updateConfigFile(conf: ConfigFile, cfp?: string): string;
+declare function createConfigFileIfNotExists(cfp?: string): string;
+declare function processConfPath(confPath: string): Promise<{
+    paths: Array<string>;
+    pf: string;
+    dd: string;
+}>;
+export { confDir, createConfigFileIfNotExists, dbPath, getConfigPath, processConfPath, updateConfigFile };