@agent-smith/cli 0.0.70 → 0.0.80

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

@@ -1,112 +1,49 @@
+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, initAgent, taskBuilder } from "../../../agent.js";
 import { query } from "../../../cli.js";
 import { readClipboard } from "../../../cmd/sys/clipboard.js";
-import { readTool } from "../../../db/read.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 { executeAction } from "../actions/cmd.js";
-import { parseCommandArgs, parseTaskConfigOptions } from "../options_parsers.js";
+import { parseCommandArgs } from "../options_parsers.js";
 import { runtimeDataError, runtimeWarning } from "../user_msgs.js";
 import { formatStats, processOutput, readPromptFile } from "../utils.js";
-import { executeWorkflow } from "../workflows/cmd.js";
-import { configureTaskModel, mergeInferParams } from "./conf.js";
-import { McpClient } from "../mcp.js";
-import { openTaskSpec } from "./utils.js";
-async function executeTask(name, payload, options, quiet, expert) {
-    await initAgent();
-    if (options.debug) {
-        console.log("Payload:", payload);
-        console.log("Task options:", options);
-    }
-    const taskFileSpec = openTaskSpec(name);
-    const opts = payload?.inferParams ? { ...options, ...payload.inferParams } : options;
-    const conf = parseTaskConfigOptions(opts);
-    if (options.debug) {
-        console.log("conf:", conf);
-    }
-    conf.inferParams = mergeInferParams(conf.inferParams, taskFileSpec.inferParams ?? {});
-    const model = configureTaskModel(conf, taskFileSpec);
-    if (options?.ctx) {
-        model.ctx = options.ctx;
-    }
-    const taskSpec = taskFileSpec;
-    let vars = {};
-    taskSpec.variables?.optional?.forEach(k => {
-        if (k in options) {
-            vars[k] = options[k];
-        }
-    });
-    taskSpec.variables?.required?.forEach(k => {
-        if (k in options) {
-            vars[k] = options[k];
-        }
-    });
-    const mcpServers = new Array();
-    if (taskFileSpec?.mcp) {
-        taskSpec.tools = [];
-        for (const [servername, tool] of Object.entries(taskFileSpec.mcp)) {
-            const mcp = new McpClient(servername, tool.command, tool.args, tool?.tools ?? null);
-            mcpServers.push(mcp);
-            await mcp.start();
-            const tools = await mcp.extractTools();
-            tools.forEach(t => taskSpec.tools?.push(t));
-        }
-    }
-    if (taskSpec.toolsList) {
-        if (!taskSpec?.tools) {
-            taskSpec.tools = [];
-        }
-        for (const toolName of taskSpec.toolsList) {
-            const { found, tool, type } = readTool(toolName);
-            if (!found) {
-                throw new Error(`tool ${toolName} not found for task ${taskSpec.name}`);
-            }
-            const lmTool = {
-                ...tool,
-                execute: async (params) => {
-                    switch (type) {
-                        case "action":
-                            const res = await executeAction(toolName, params, options, true);
-                            return res;
-                        case "task":
-                            conf.quiet = !options?.debug;
-                            const tres = await executeTask(name, params, options, true);
-                            return tres.answer.text;
-                        case "workflow":
-                            const wres = await executeWorkflow(toolName, params, options);
-                            return wres;
-                        default:
-                            throw new Error(`unknown tool execution function type: ${type} for ${toolName}`);
-                    }
-                }
-            };
-            taskSpec.tools.push(lmTool);
-        }
-        delete taskSpec.toolsList;
-    }
-    ;
-    const task = taskBuilder.init(taskSpec);
+import { readTask } from "./read.js";
+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;
     }
-    if (options.debug) {
+    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;
@@ -119,89 +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,
+        debug: options?.debug ?? false,
         onToolCall: onToolCall,
+        onToolCallEnd: onToolCallEnd,
         ...conf,
     };
-    tconf.expert = ex;
     let out;
     try {
         out = await task.run({ prompt: payload.prompt, ...vars }, tconf);
@@ -227,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/conf.js

@@ -58,20 +58,25 @@ function configureTaskModel(itConf, taskSpec) {
         const m = readModel(modelName);
         if (m.found) {
             model = m.modelData;
-            model.template = m.modelData.template;
+            model.template = templateName ?? m.modelData.template;
             found = true;
         }
     }
     if (!found) {
-        const gt = tfm.guess(modelName);
-        if (gt == "none") {
-            throw new Error(`Unable to guess the template for ${modelName}: please provide a template name: m="modelname/templatename"`);
+        if (templateName && modelName) {
+            model = { name: modelName, template: templateName };
+        }
+        else {
+            const gt = tfm.guess(modelName);
+            if (gt == "none") {
+                throw new Error(`Unable to guess the template for ${modelName}: please provide a template name: --tpl templatename`);
+            }
+            const m = {
+                name: modelName,
+                template: gt
+            };
+            model = m;
         }
-        const m = {
-            name: modelName,
-            template: gt
-        };
-        model = m;
     }
     model.inferParams = ip;
     if (!model?.ctx || !isModelFromTaskFile) {

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

@@ -0,0 +1,11 @@
+import { Agent } from "@agent-smith/agent";
+import { ModelSpec, Task, TaskConf } from "@agent-smith/task";
+import { McpClient } from "../mcp.js";
+declare function readTask(name: string, payload: Record<string, any>, options: Record<string, any>, agent: Agent): Promise<{
+    task: Task;
+    model: ModelSpec;
+    conf: TaskConf;
+    vars: Record<string, any>;
+    mcpServers: Array<McpClient>;
+}>;
+export { readTask };

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

@@ -0,0 +1,93 @@
+import { Task } from "@agent-smith/task";
+import { compile, serializeGrammar } from "@intrinsicai/gbnfgen";
+import { readTool } from "../../../db/read.js";
+import { executeAction } from "../actions/cmd.js";
+import { McpClient } from "../mcp.js";
+import { parseTaskConfigOptions } from "../options_parsers.js";
+import { executeWorkflow } from "../workflows/cmd.js";
+import { executeTask } from "./cmd.js";
+import { configureTaskModel, mergeInferParams } from "./conf.js";
+import { openTaskSpec } from "./utils.js";
+async function readTask(name, payload, options, agent) {
+    if (options?.debug) {
+        console.log("Payload:", payload);
+        console.log("Task options:", options);
+    }
+    const taskFileSpec = openTaskSpec(name);
+    const opts = payload?.inferParams ? { ...options, ...payload.inferParams } : options;
+    const conf = parseTaskConfigOptions(opts);
+    if (options?.debug) {
+        console.log("conf:", conf);
+    }
+    conf.inferParams = mergeInferParams(conf.inferParams, taskFileSpec.inferParams ?? {});
+    const model = configureTaskModel(conf, taskFileSpec);
+    if (options?.ctx) {
+        model.ctx = options.ctx;
+    }
+    const taskSpec = taskFileSpec;
+    let vars = {};
+    if (taskSpec.variables?.optional) {
+        for (const k of Object.keys(taskSpec.variables.optional)) {
+            if (k in options) {
+                vars[k] = options[k];
+            }
+        }
+    }
+    if (taskSpec.variables?.required) {
+        for (const k of Object.keys(taskSpec.variables.required)) {
+            if (k in options) {
+                vars[k] = options[k];
+            }
+        }
+    }
+    const mcpServers = new Array();
+    if (!taskSpec?.tools) {
+        taskSpec.tools = [];
+    }
+    if (taskFileSpec?.mcp) {
+        for (const [servername, tool] of Object.entries(taskFileSpec.mcp)) {
+            const mcp = new McpClient(servername, tool.command, tool.args, tool?.tools ?? null);
+            mcpServers.push(mcp);
+            await mcp.start();
+            const tools = await mcp.extractTools();
+            tools.forEach(t => taskSpec.tools?.push(t));
+        }
+    }
+    if (taskSpec.toolsList) {
+        for (const toolName of taskSpec.toolsList) {
+            const { found, tool, type } = readTool(toolName);
+            if (!found) {
+                throw new Error(`tool ${toolName} not found for task ${taskSpec.name}`);
+            }
+            const lmTool = {
+                ...tool,
+                execute: async (params) => {
+                    switch (type) {
+                        case "action":
+                            const res = await executeAction(toolName, params, options, true);
+                            return res;
+                        case "task":
+                            conf.quiet = !options?.debug;
+                            const tres = await executeTask(name, params, options, true);
+                            return tres.answer.text;
+                        case "workflow":
+                            const wres = await executeWorkflow(toolName, params, options);
+                            return wres;
+                        default:
+                            throw new Error(`unknown tool execution function type: ${type} for ${toolName}`);
+                    }
+                }
+            };
+            taskSpec.tools.push(lmTool);
+        }
+        delete taskSpec.toolsList;
+    }
+    ;
+    const task = new Task(agent, taskSpec);
+    if (model?.inferParams?.tsGrammar) {
+        model.inferParams.grammar = serializeGrammar(await compile(model.inferParams.tsGrammar, "Grammar"));
+        delete model.inferParams.tsGrammar;
+    }
+    return { task, model, conf, vars, mcpServers };
+}
+export { readTask };

package/dist/cmd/lib/tools.js

@@ -42,7 +42,7 @@ function _extractYamlToolDoc(filePath, name) {
     if (!found) {
         return { found: false, tspec: {} };
     }
-    if (!data.tool) {
+    if (!data?.tool) {
         return { found: false, tspec: {} };
     }
     data.tool.name = name;
@@ -78,7 +78,7 @@ function extractTaskToolDocAndVariables(name, ext, dirPath) {
     if (!found) {
         throw new Error(`extractTaskToolDocAndVariables: file ${fp} not found`);
     }
-    if (data.tool) {
+    if (data?.tool) {
         data.tool.name = name;
         tspec = data.tool;
         res.toolDoc = JSON.stringify(tspec, null, "  ");

package/dist/cmd/lib/utils.js

@@ -1,9 +1,11 @@
-import { marked } from "../../agent.js";
 import { formatMode, initFilepaths, outputMode, promptfilePath } from "../../state/state.js";
 import { writeToClipboard } from "../sys/clipboard.js";
 import { readFile } from "../sys/read.js";
 import { splitThinking } from "../../utils/text.js";
 import { runtimeError } from "./user_msgs.js";
+import { marked } from 'marked';
+import { markedTerminal } from "marked-terminal";
+marked.use(markedTerminal());
 function readPromptFile() {
     initFilepaths();
     return readFile(promptfilePath.value);

package/dist/cmd/lib/workflows/cmd.js

@@ -3,6 +3,7 @@ import { executeAdaptater } from "../adaptaters/cmd.js";
 import { parseCommandArgs } from "../options_parsers.js";
 import { executeTask } from "../tasks/cmd.js";
 import { readWorkflow } from "./read.js";
+import colors from "ansi-colors";
 async function executeWorkflow(name, params, options) {
     const { workflow, found } = await readWorkflow(name);
     if (!found) {
@@ -15,11 +16,11 @@ async function executeWorkflow(name, params, options) {
         console.log("Running workflow", name, stepNames.length, "steps");
     }
     let i = 0;
-    const finalTaskIndex = stepNames.length + 1;
+    const finalTaskIndex = stepNames.length - 1;
     let taskRes = params;
     for (const [name, step] of Object.entries(workflow)) {
         if (isDebug || isVerbose) {
-            console.log(`${i + 1}: ${step.type} ${name}`);
+            console.log(i + 1, name, colors.dim(step.type));
         }
         switch (step.type) {
             case "task":
@@ -35,7 +36,7 @@ async function executeWorkflow(name, params, options) {
                 try {
                     const ares = await executeAction(name, taskRes, options, true);
                     if (typeof ares == "string") {
-                        taskRes = { payload: ares };
+                        taskRes = { args: ares };
                     }
                     else {
                         taskRes = ares;
@@ -52,11 +53,14 @@ async function executeWorkflow(name, params, options) {
                 try {
                     const ares = await executeAdaptater(name, taskRes, options);
                     if (typeof ares == "string") {
-                        taskRes = { payload: ares };
+                        taskRes = { args: ares };
                     }
                     else {
                         taskRes = ares;
                     }
+                    if (i == finalTaskIndex) {
+                        console.log(taskRes);
+                    }
                 }
                 catch (e) {
                     throw new Error(`workflow adaptater ${i + 1}: ${e}`);
@@ -72,7 +76,6 @@ async function executeWorkflow(name, params, options) {
 }
 async function executeWorkflowCmd(name, wargs) {
     const { args, options } = parseCommandArgs(wargs);
-    const params = { args: args };
-    return await executeWorkflow(name, params, options);
+    return await executeWorkflow(name, { args: args }, options);
 }
 export { executeWorkflow, executeWorkflowCmd, };

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

@@ -1,7 +1,6 @@
-import { AgentTask } from "@agent-smith/jobs";
-import { FeatureType } from '../../../interfaces.js';
+import { WorkflowStep } from '../../../interfaces.js';
 declare function readWorkflow(name: string): Promise<{
     found: boolean;
-    workflow: Record<string, AgentTask<FeatureType, any, any, Record<string, any>>>;
+    workflow: Record<string, WorkflowStep>;
 }>;
-export { readWorkflow, };
+export { readWorkflow };

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

@@ -1,6 +1,8 @@
-import YAML from 'yaml';
+import { Agent } from '@agent-smith/agent';
+import { Task } from '@agent-smith/task';
 import { default as fs } from "fs";
-import { taskBuilder } from '../../../agent.js';
+import YAML from 'yaml';
+import { backend } from '../../../state/backends.js';
 import { getFeatureSpec } from '../../../state/features.js';
 import { readTask } from "../../sys/read_task.js";
 import { pythonAction, systemAction } from '../actions/cmd.js';
@@ -26,24 +28,36 @@ async function _createWorkflowFromSpec(spec) {
                 case "js":
                     const { action } = await import(path);
                     const at = action;
-                    at.type = "action";
-                    steps[name] = at;
+                    const wf = {
+                        type: "action",
+                        run: at,
+                    };
+                    steps[name] = wf;
                     break;
                 case "mjs":
                     const mjsa = await import(path);
                     const act = createJsAction(mjsa.action);
-                    act.type = "action";
-                    steps[name] = act;
+                    const wf2 = {
+                        type: "action",
+                        run: act,
+                    };
+                    steps[name] = wf2;
                     break;
                 case "yml":
                     const _t1 = systemAction(path);
-                    _t1.type = "action";
-                    steps[name] = _t1;
+                    const wf3 = {
+                        type: "action",
+                        run: _t1,
+                    };
+                    steps[name] = wf3;
                     break;
                 case "py":
                     const _t = pythonAction(path);
-                    _t.type = "action";
-                    steps[name] = _t;
+                    const wf4 = {
+                        type: "action",
+                        run: _t,
+                    };
+                    steps[name] = wf4;
                     break;
                 default:
                     throw new Error(`Unknown feature extension ${ext}`);
@@ -56,8 +70,11 @@ async function _createWorkflowFromSpec(spec) {
             }
             const jsa = await import(path);
             const act = createJsAction(jsa.action);
-            act.type = "adaptater";
-            steps[name] = act;
+            const wf = {
+                type: "adaptater",
+                run: act,
+            };
+            steps[name] = wf;
         }
         else {
             const { found, path } = getFeatureSpec(name, "task");
@@ -68,8 +85,13 @@ async function _createWorkflowFromSpec(spec) {
             if (!res.found) {
                 throw new Error(`Unable to read task ${name} ${path}`);
             }
-            const tsk = taskBuilder.fromYaml(res.ymlTask, "task");
-            steps[name] = tsk;
+            const agent = new Agent(backend.value);
+            const tsk = Task.fromYaml(agent, res.ymlTask);
+            const wf = {
+                type: "task",
+                run: tsk.run,
+            };
+            steps[name] = wf;
         }
     }
     return steps;
@@ -112,4 +134,4 @@ async function readWorkflow(name) {
     }
     return { found: true, workflow: wf };
 }
-export { readWorkflow, };
+export { readWorkflow };