@agent-smith/cli 0.0.71 → 0.0.81

package/dist/cmd/clicmds/aliases.js

@@ -13,12 +13,18 @@ function initCommandsFromAliases(program, aliases, features) {
                 });
                 allOptions.forEach(o => tcmd.addOption(o));
                 if (features.task[alias.name]?.variables) {
-                    features.task[alias.name].variables?.optional.forEach(v => {
-                        tcmd.option(`--${v} <value>`);
-                    });
-                    features.task[alias.name].variables?.required.forEach(v => {
-                        tcmd.requiredOption(`--${v} <value>`);
-                    });
+                    const rtv = features.task[alias.name].variables?.required;
+                    if (rtv) {
+                        for (const name of Object.keys(rtv)) {
+                            tcmd.option(`--${name} <value>`);
+                        }
+                    }
+                    const otv = features.task[alias.name].variables?.optional;
+                    if (otv) {
+                        for (const name of Object.keys(otv)) {
+                            tcmd.option(`--${name} <value>`);
+                        }
+                    }
                 }
                 break;
             case "action":

package/dist/cmd/clicmds/base.js

@@ -1,5 +1,4 @@
 import YAML from 'yaml';
-import { initAgent, taskBuilder } from "../../agent.js";
 import { dbPath } from "../../conf.js";
 import { readFeaturePaths, readFeaturesType } from "../../db/read.js";
 import { cleanupFeaturePaths, updateAliases, updateFeatures } from "../../db/write.js";
@@ -11,11 +10,8 @@ import { parseCommandArgs } from "../lib/options_parsers.js";
 import { deleteFileIfExists } from "../sys/delete_file.js";
 import { readTask } from "../sys/read_task.js";
 import { updateConfCmd } from "./update.js";
-import { initRemoteBackends } from "../backends.js";
+import { listBackends, setBackend } from "../../state/backends.js";
 function initBaseCommands(program) {
-    program.command("ping")
-        .description("ping inference servers")
-        .action(async (...args) => { console.log("Found working inference server(s):", await initAgent(initRemoteBackends())); });
     program.command("exit")
         .description("exit the cli")
         .action(() => process.exit(0));
@@ -37,6 +33,17 @@ function initBaseCommands(program) {
         const ca = parseCommandArgs(args);
         await showModelsCmd(ca.args);
     });
+    program.command("backend <name>")
+        .description("set the default backend")
+        .action(async (...args) => {
+        const ca = parseCommandArgs(args);
+        await setBackend(ca.args[0]);
+    });
+    program.command("backends")
+        .description("list the available backends")
+        .action(async (...args) => {
+        await listBackends();
+    });
     program.command("update")
         .description("update the available features: run this after adding a new feature")
         .action(async (...args) => {
@@ -89,7 +96,6 @@ async function _readTaskCmd(args) {
     if (!res.found) {
         throw new Error(`Task ${args[0]}, ${path} not found`);
     }
-    const ts = taskBuilder.readFromYaml(res.ymlTask);
-    console.log(YAML.stringify(ts));
+    console.log(YAML.stringify(res.ymlTask));
 }
 export { initBaseCommands };

package/dist/cmd/cmds.js

@@ -1,30 +1,10 @@
-import { input } from "@inquirer/prompts";
-import { toRaw } from "@vue/reactivity";
 import { Command } from "commander";
-import { brain } from "../agent.js";
-import { query } from "../cli.js";
 import { readAliases, readFeatures } from "../db/read.js";
-import { chatInferenceParams } from "../state/chat.js";
-import { isChatMode, runMode } from "../state/state.js";
 import { initCommandsFromAliases } from "./clicmds/aliases.js";
 import { initBaseCommands } from "./clicmds/base.js";
 import { initUserCmds } from "./clicmds/cmds.js";
 const program = new Command();
 async function chat(program) {
-    const data = { message: '>', default: "" };
-    const prompt = await input(data);
-    if (prompt == "/q") {
-        isChatMode.value = false;
-        if (runMode.value == "cmd") {
-            process.exit(0);
-        }
-        else {
-            await query(program);
-        }
-    }
-    await brain.ex.think(prompt, toRaw(chatInferenceParams));
-    console.log();
-    await chat(program);
 }
 async function buildCmds() {
     initBaseCommands(program);

package/dist/cmd/lib/actions/cmd.d.ts

@@ -1,7 +1,6 @@
-import { AgentTask } from "@agent-smith/jobs";
-import { FeatureType } from "../../../interfaces.js";
+import { FeatureExecutor } from "../../../interfaces.js";
 declare function executeAction(name: string, payload: Record<string, any>, options: Record<string, any>, quiet?: boolean): Promise<any>;
 declare function executeActionCmd(name: string, aargs: Array<any>, quiet?: boolean): Promise<any>;
-declare function systemAction(path: string): AgentTask<FeatureType, Array<string>, any>;
-declare function pythonAction(path: string): AgentTask<FeatureType, Array<string>>;
+declare function systemAction(path: string): FeatureExecutor<Array<string>, any>;
+declare function pythonAction(path: string): FeatureExecutor<Array<string>>;
 export { executeAction, executeActionCmd, systemAction, pythonAction, };

package/dist/cmd/lib/actions/cmd.js

@@ -1,4 +1,3 @@
-import { useAgentTask } from "@agent-smith/jobs";
 import { getFeatureSpec } from '../../../state/features.js';
 import { readYmlFile } from "../../sys/read_yml_file.js";
 import { execute } from "../../sys/execute.js";
@@ -10,7 +9,7 @@ import { readClipboard } from "../../sys/clipboard.js";
 import { processOutput, readPromptFile } from "../utils.js";
 import { parseCommandArgs } from "../options_parsers.js";
 async function executeAction(name, payload, options, quiet = false) {
-    let act;
+    let run;
     const { found, path, ext } = getFeatureSpec(name, "action");
     if (!found) {
         throw new Error(`Action ${name} not found at ${path}`);
@@ -18,18 +17,22 @@ async function executeAction(name, payload, options, quiet = false) {
     switch (ext) {
         case "js":
             const mjsa = await import(path);
-            act = createJsAction(mjsa.action);
+            run = createJsAction(mjsa.action);
             break;
         case "yml":
-            act = systemAction(path);
+            run = systemAction(path);
             break;
         case "py":
-            act = pythonAction(path);
+            run = pythonAction(path);
             break;
         default:
             throw new Error(`Action ext ${ext} not implemented`);
     }
-    const res = await act.run(payload, options);
+    let _pl = payload;
+    if (payload?.args) {
+        _pl = payload.args;
+    }
+    const res = await run(_pl, options);
     if (!quiet) {
         if (res) {
             console.log(res);
@@ -53,71 +56,52 @@ async function executeActionCmd(name, aargs, quiet = false) {
     return await executeAction(name, params, options, quiet);
 }
 function systemAction(path) {
-    const action = useAgentTask({
-        id: "system_action",
-        title: "",
-        run: async (params) => {
-            let runArgs = new Array();
-            if (params?.args) {
-                runArgs = params.args;
-            }
-            else {
-                try {
-                    runArgs = Object.values(params);
-                }
-                catch (e) {
-                    throw new Error(`wrong system action args: ${e}`);
-                }
-            }
-            const actionSpec = readYmlFile(path);
-            if (!actionSpec.found) {
-                runtimeError("System action yml file", path, "not found");
-            }
-            if (!actionSpec.data?.args) {
-                actionSpec.data.args = [];
-            }
-            const out = await execute(actionSpec.data.cmd, [...actionSpec.data.args, ...runArgs]);
-            return out.trim();
+    const run = async (params) => {
+        let runArgs = params;
+        const actionSpec = readYmlFile(path);
+        if (!actionSpec.found) {
+            runtimeError("System action yml file", path, "not found");
+        }
+        if (!actionSpec.data?.args) {
+            actionSpec.data.args = [];
         }
-    });
-    return action;
+        const out = await execute(actionSpec.data.cmd, [...actionSpec.data.args, ...runArgs]);
+        return out.trim();
+    };
+    return run;
 }
 function pythonAction(path) {
-    const action = useAgentTask({
-        id: "python_action",
-        title: "",
-        run: async (params) => {
-            let runArgs = new Array();
-            if (params?.args) {
-                runArgs = params.args;
-            }
-            else {
-                try {
-                    runArgs = Object.values(params);
-                }
-                catch (e) {
-                    throw new Error(`wrong python action args: ${e}`);
-                }
+    const run = async (params) => {
+        let runArgs = new Array();
+        if (params?.args) {
+            runArgs = params.args;
+        }
+        else {
+            try {
+                runArgs = Object.values(params);
             }
-            const { data, error } = await runPyScript(pyShell, "python3", path, runArgs);
-            if (error) {
-                throw new Error(`python error: ${error}`);
+            catch (e) {
+                throw new Error(`wrong python action args: ${e}`);
             }
-            let txt = data[0];
-            if (data.length > 1) {
-                txt = data.join("\n");
+        }
+        const { data, error } = await runPyScript(pyShell, "python3", path, runArgs);
+        if (error) {
+            throw new Error(`python error: ${error}`);
+        }
+        let txt = data[0];
+        if (data.length > 1) {
+            txt = data.join("\n");
+        }
+        let final = txt;
+        if (txt.startsWith("{") || txt.startsWith("[")) {
+            try {
+                final = JSON.parse(txt);
             }
-            let final = txt;
-            if (txt.startsWith("{") || txt.startsWith("[")) {
-                try {
-                    final = JSON.parse(txt);
-                }
-                catch (e) {
-                }
+            catch (e) {
             }
-            return final;
         }
-    });
-    return action;
+        return final;
+    };
+    return run;
 }
 export { executeAction, executeActionCmd, systemAction, pythonAction, };

package/dist/cmd/lib/actions/read.d.ts

@@ -1,4 +1,3 @@
-import { FeatureType } from "../../../interfaces.js";
-import { AgentTask } from "@agent-smith/jobs";
-declare function createJsAction(action: CallableFunction): AgentTask<FeatureType, any, any>;
+import { FeatureExecutor } from "../../../interfaces.js";
+declare function createJsAction(action: CallableFunction): FeatureExecutor;
 export { createJsAction };

package/dist/cmd/lib/actions/read.js

@@ -1,18 +1,13 @@
-import { useAgentTask } from "@agent-smith/jobs";
 function createJsAction(action) {
-    const task = useAgentTask({
-        id: "",
-        title: "",
-        run: async (args, options) => {
-            try {
-                const res = await action(args, options);
-                return res;
-            }
-            catch (e) {
-                throw new Error(`executing action:${e}`);
-            }
+    const run = async (args, options) => {
+        try {
+            const res = await action(args, options);
+            return res;
         }
-    });
-    return task;
+        catch (e) {
+            throw new Error(`executing action:${e}`);
+        }
+    };
+    return run;
 }
 export { createJsAction };

package/dist/cmd/lib/adaptaters/cmd.d.ts

@@ -1,2 +1,2 @@
-declare function executeAdaptater(name: string, argsOrParams: Record<string, any> | Array<any>, options: Record<string, any>): Promise<any>;
+declare function executeAdaptater(name: string, params: any, options: Record<string, any>): Promise<any>;
 export { executeAdaptater, };

package/dist/cmd/lib/adaptaters/cmd.js

@@ -1,16 +1,19 @@
 import { getFeatureSpec } from "../../../state/features.js";
 import { createJsAction } from "../actions/read.js";
-async function executeAdaptater(name, argsOrParams, options) {
+async function executeAdaptater(name, params, options) {
+    if (params?.args) {
+        params = params.args;
+    }
     const { found, path } = getFeatureSpec(name, "adaptater");
     if (!found) {
         throw new Error(`adaptater ${name} not found`);
     }
-    let act;
+    let run;
     const jsa = await import(path);
-    act = createJsAction(jsa.action);
+    run = createJsAction(jsa.action);
     let res;
     try {
-        res = await act.run(argsOrParams, options);
+        res = await run(params, options);
     }
     catch (e) {
         throw new Error(`adaptater ${name}: ${e}`);

package/dist/cmd/lib/mcp.d.ts

@@ -1,15 +1,15 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { LmTaskToolSpec } from "@agent-smith/lmtask/dist/interfaces.js";
+import { ToolSpec } from "@locallm/types/dist/tools";
 declare class McpClient {
     name: string;
     transport: StdioClientTransport;
     client: Client;
     authorizedTools: Array<string> | null;
-    tools: Record<string, LmTaskToolSpec>;
+    tools: Record<string, ToolSpec>;
     constructor(servername: string, command: string, args: Array<string>, authorizedTools?: Array<string> | null);
     start(): Promise<void>;
     stop(): Promise<void>;
-    extractTools(): Promise<Array<LmTaskToolSpec>>;
+    extractTools(): Promise<Array<ToolSpec>>;
 }
 export { McpClient, };

package/dist/cmd/lib/options_parsers.js

@@ -1,9 +1,9 @@
 function parseCommandArgs(args) {
+    args.pop();
     const res = {
         args: new Array(),
         options: {},
     };
-    args.pop();
     res.options = args.pop();
     res.args = Array.isArray(args[0]) ? args[0] : args;
     return res;

package/dist/cmd/lib/tasks/cmd.d.ts

@@ -1,5 +1,4 @@
-import { LmTaskOutput } from "@agent-smith/lmtask";
-import { LmExpert } from "@agent-smith/brain";
-declare function executeTask(name: string, payload: Record<string, any>, options: Record<string, any>, quiet?: boolean, expert?: LmExpert): Promise<LmTaskOutput>;
-declare function executeTaskCmd(name: string, targs?: Array<any>): Promise<LmTaskOutput>;
+import { TaskOutput } from "@agent-smith/task";
+declare function executeTask(name: string, payload: Record<string, any>, options: Record<string, any>, quiet?: boolean): Promise<TaskOutput>;
+declare function executeTaskCmd(name: string, targs?: Array<any>): Promise<TaskOutput>;
 export { executeTask, executeTaskCmd };

package/dist/cmd/lib/tasks/cmd.js

@@ -1,19 +1,27 @@
+import { Agent } from "@agent-smith/agent";
+import { useTemplateForModel } from "@agent-smith/tfm";
 import { input } from "@inquirer/prompts";
 import { compile, serializeGrammar } from "@intrinsicai/gbnfgen";
-import color from "ansi-colors";
+import { default as color, default as colors } from "ansi-colors";
+import { PromptTemplate } from "modprompt";
 import ora from 'ora';
-import { brain } from "../../../agent.js";
 import { query } from "../../../cli.js";
 import { readClipboard } from "../../../cmd/sys/clipboard.js";
 import { usePerfTimer } from "../../../main.js";
+import { backend } from "../../../state/backends.js";
 import { isChatMode, runMode } from "../../../state/state.js";
 import { program } from "../../cmds.js";
 import { parseCommandArgs } from "../options_parsers.js";
 import { runtimeDataError, runtimeWarning } from "../user_msgs.js";
 import { formatStats, processOutput, readPromptFile } from "../utils.js";
 import { readTask } from "./read.js";
-async function executeTask(name, payload, options, quiet, expert) {
-    const { task, model, conf, vars, mcpServers } = await readTask(name, payload, options);
+const tfm = useTemplateForModel();
+async function executeTask(name, payload, options, quiet) {
+    const agent = new Agent(backend.value);
+    if (options?.debug) {
+        console.log("Agent:", colors.bold(agent.lm.name), "( " + agent.lm.providerType + " backend type)");
+    }
+    const { task, model, conf, vars, mcpServers } = await readTask(name, payload, options, agent);
     if (model?.inferParams?.tsGrammar) {
         model.inferParams.grammar = serializeGrammar(await compile(model.inferParams.tsGrammar, "Grammar"));
         delete model.inferParams.tsGrammar;
@@ -21,15 +29,21 @@ async function executeTask(name, payload, options, quiet, expert) {
     if (options?.debug) {
         console.log("Task model:", model);
     }
-    const ex = expert ?? brain.getOrCreateExpertForModel(model.name, model.template);
-    if (!ex) {
-        throw new Error("No expert found for model " + model.name);
-    }
-    ex.checkStatus();
-    let i = 0;
     let c = false;
-    const hasThink = ex.template?.tags?.think;
-    const hasTools = ex.template?.tags?.toolCall;
+    const useTemplates = agent.lm.providerType !== "openai";
+    let hasThink = false;
+    let tpl = null;
+    if (useTemplates) {
+        if ((!task.def.model?.template)) {
+            const gt = tfm.guess(task.def.model.name);
+            if (gt == "none") {
+                throw new Error(`Unable to guess the template for ${task.def.model}: please provide a template in the taskDef definition`);
+            }
+            task.def.model.template = gt;
+        }
+        tpl = new PromptTemplate(task.def.model.template);
+        hasThink = tpl.tags?.think ? true : false;
+    }
     const printToken = (t) => {
         if (options?.tokens === true) {
             let txt = t;
@@ -42,90 +56,99 @@ async function executeTask(name, payload, options, quiet, expert) {
             process.stdout.write(t);
         }
     };
-    let processToken = printToken;
-    if ((hasThink || hasTools) && !options?.debug) {
-        let continueWrite = true;
-        let skipNextEmptyLinesToken = false;
-        const spinner = ora("Thinking ...");
-        const ts = "Thinking";
-        const te = color.dim("tokens");
-        const formatTokenCount = (i) => {
-            return `${ts} ${color.bold(i.toString())} ${te}`;
-        };
-        const perfTimer = usePerfTimer(false);
-        let i = 0;
-        processToken = (t) => {
-            if (i == 0) {
-                perfTimer.start();
-            }
-            spinner.text = formatTokenCount(i);
-            if (!options?.verbose) {
-                if (hasThink) {
-                    if (t == ex.template.tags.think?.start) {
-                        spinner.start();
-                        continueWrite = false;
-                        return;
-                    }
-                    else if (t == ex.template.tags.think?.end) {
-                        continueWrite = true;
-                        skipNextEmptyLinesToken = true;
-                        let msg = color.dim("Thinking:") + ` ${i} ${color.dim("tokens")}`;
-                        msg = msg + " " + color.dim(perfTimer.time());
-                        spinner.info(msg);
-                        return;
-                    }
+    const hasTools = options?.tools;
+    let continueWrite = true;
+    let skipNextEmptyLinesToken = false;
+    const spinner = ora("Thinking ...");
+    const ts = "Thinking";
+    const te = color.dim("tokens");
+    const formatTokenCount = (i) => {
+        return `${ts} ${color.bold(i.toString())} ${te}`;
+    };
+    const perfTimer = usePerfTimer(false);
+    let i = 0;
+    const processToken = (t) => {
+        if (i == 0) {
+            perfTimer.start();
+        }
+        spinner.text = formatTokenCount(i);
+        if (!options?.verbose && !options?.debug) {
+            if (hasThink && tpl) {
+                if (t == tpl.tags.think?.start) {
+                    spinner.start();
+                    continueWrite = false;
+                    return;
+                }
+                else if (t == tpl.tags.think?.end) {
+                    continueWrite = true;
+                    skipNextEmptyLinesToken = true;
+                    let msg = color.dim("Thinking:") + ` ${i} ${color.dim("tokens")}`;
+                    msg = msg + " " + color.dim(perfTimer.time());
+                    spinner.info(msg);
+                    return;
                 }
             }
-            else {
-                if (t == ex.template.tags.think?.end) {
+        }
+        else {
+            if (tpl) {
+                if (t == tpl.tags.think?.end) {
                     let msg = color.dim("Thinking:") + ` ${i} ${color.dim("tokens")}`;
                     msg = msg + " " + color.dim(perfTimer.time());
                     console.log(msg);
                 }
             }
-            if (hasTools) {
-                if (t == ex.template.tags.toolCall?.start) {
-                    continueWrite = false;
-                    return;
-                }
-                else if (t == ex.template.tags.toolCall?.end) {
-                    if (options?.verbose === true) {
-                        skipNextEmptyLinesToken = true;
-                        continueWrite = true;
-                    }
-                    return;
+        }
+        if (hasTools && tpl) {
+            if (t == tpl.tags.toolCall?.start) {
+                continueWrite = false;
+                return;
+            }
+            else if (t == tpl.tags.toolCall?.end) {
+                if (options?.verbose === true) {
+                    skipNextEmptyLinesToken = true;
+                    continueWrite = true;
                 }
+                return;
             }
-            if (continueWrite) {
-                if (skipNextEmptyLinesToken) {
-                    if (t == "\n\n") {
-                        skipNextEmptyLinesToken = false;
-                        return;
-                    }
+        }
+        if (continueWrite) {
+            if (skipNextEmptyLinesToken) {
+                if (t == "\n\n") {
+                    skipNextEmptyLinesToken = false;
+                    return;
                 }
-                printToken(t);
             }
-            ++i;
-        };
-    }
+            printToken(t);
+        }
+        ++i;
+    };
+    const spinnerInit = (name) => ora(`Executing ${name} tool ...`);
+    let tcspinner;
     const onToolCall = (tc) => {
         console.log("⚒️ ", color.bold(name), "=>", `${color.yellowBright(tc.name)}`, tc.arguments);
+        tcspinner = spinnerInit(tc.name);
+        tcspinner.start();
+    };
+    const onToolCallEnd = (tr) => {
+        tcspinner.stop();
     };
     if (options?.onToken) {
-        ex.backend.setOnToken(options.onToken);
+        task.agent.lm.onToken = options.onToken;
     }
     else {
-        ex.backend.setOnToken(processToken);
+        task.agent.lm.onToken = processToken;
+    }
+    if (!conf?.inferParams) {
+        conf.inferParams = {};
     }
     conf.inferParams.stream = true;
     const tconf = {
-        expert: ex,
         model: model,
         debug: options?.debug ?? false,
         onToolCall: onToolCall,
+        onToolCallEnd: onToolCallEnd,
         ...conf,
     };
-    tconf.expert = ex;
     let out;
     try {
         out = await task.run({ prompt: payload.prompt, ...vars }, tconf);
@@ -151,12 +174,15 @@ async function executeTask(name, payload, options, quiet, expert) {
             }
         }
         else {
-            await executeTask(name, { ...vars, prompt: prompt }, options, quiet, ex);
+            await executeTask(name, { ...vars, prompt: prompt }, options, quiet);
         }
     }
     if (options?.debug === true || options?.verbose === true) {
         try {
             console.log("\n", formatStats(out.answer.stats));
+            if (options?.debug === true) {
+                console.log(out.answer.stats);
+            }
         }
         catch (e) {
             runtimeWarning("Error formating stats:", `${e}`);

package/dist/cmd/lib/tasks/read.d.ts

@@ -1,11 +1,10 @@
-import { LmTaskInput, LmTaskOutput, ModelSpec } from "../../../../../lmtask/dist/main.js";
+import { Agent } from "@agent-smith/agent";
+import { ModelSpec, Task, TaskConf } from "@agent-smith/task";
 import { McpClient } from "../mcp.js";
-import { AgentTask } from "@agent-smith/jobs/dist/interfaces.js";
-import { FeatureType, LmTaskConfig } from "../../../interfaces.js";
-declare function readTask(name: string, payload: Record<string, any>, options: Record<string, any>): Promise<{
-    task: AgentTask<FeatureType, LmTaskInput, LmTaskOutput, Record<string, any>>;
+declare function readTask(name: string, payload: Record<string, any>, options: Record<string, any>, agent: Agent): Promise<{
+    task: Task;
     model: ModelSpec;
-    conf: LmTaskConfig;
+    conf: TaskConf;
     vars: Record<string, any>;
     mcpServers: Array<McpClient>;
 }>;