@agent-smith/cli 0.0.63 → 0.0.65

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

@@ -6,28 +6,73 @@ import { runPyScript } from "../../sys/run_python.js";
 import { pyShell } from "../../../state/state.js";
 import { createJsAction } from "./read.js";
 import { runtimeError } from "../../../utils/user_msgs.js";
+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;
+    const { found, path, ext } = getFeatureSpec(name, "action");
+    if (!found) {
+        throw new Error(`Action ${name} not found at ${path}`);
+    }
+    switch (ext) {
+        case "js":
+            const mjsa = await import(path);
+            act = createJsAction(mjsa.action);
+            break;
+        case "yml":
+            act = systemAction(path);
+            break;
+        case "py":
+            act = pythonAction(path);
+            break;
+        default:
+            throw new Error(`Action ext ${ext} not implemented`);
+    }
+    const res = await act.run(payload, options);
+    if (!quiet) {
+        if (res) {
+            console.log(res);
+        }
+    }
+    await processOutput(res);
+    return res;
+}
+async function executeActionCmd(name, aargs, quiet = false) {
+    const { args, options } = parseCommandArgs(aargs);
+    const params = { args: args };
+    if (options?.clipBoardInput) {
+        params.args.push(await readClipboard());
+    }
+    else if (options?.inputFile) {
+        params.args.push(readPromptFile());
+    }
+    if (options?.debug) {
+        console.log("Action", name, "params", params);
+    }
+    return await executeAction(name, params, options, quiet);
+}
 function systemAction(path) {
     const action = useAgentTask({
         id: "system_action",
         title: "",
-        run: async (args) => {
+        run: async (params) => {
             let runArgs = new Array();
-            if (!Array.isArray(args)) {
+            if (params?.args) {
+                runArgs = params.args;
+            }
+            else {
                 try {
-                    runArgs = Object.values(args);
+                    runArgs = Object.values(params);
                 }
                 catch (e) {
                     throw new Error(`wrong system action args: ${e}`);
                 }
             }
-            else {
-                runArgs = args;
-            }
             const actionSpec = readYmlFile(path);
             if (!actionSpec.found) {
                 runtimeError("System action yml file", path, "not found");
             }
-            console.log("Yml action", JSON.stringify(actionSpec.data, null, "  "));
             if (!actionSpec.data?.args) {
                 actionSpec.data.args = [];
             }
@@ -41,8 +86,20 @@ function pythonAction(path) {
     const action = useAgentTask({
         id: "python_action",
         title: "",
-        run: async (args) => {
-            const { data, error } = await runPyScript(pyShell, "python3", path, args);
+        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 { data, error } = await runPyScript(pyShell, "python3", path, runArgs);
             if (error) {
                 throw new Error(`python error: ${error}`);
             }
@@ -63,44 +120,4 @@ function pythonAction(path) {
     });
     return action;
 }
-async function executeActionCmd(args = [], options = {}, quiet = false) {
-    const isWorkflow = !Array.isArray(args);
-    let name;
-    if (!isWorkflow) {
-        name = args.shift();
-    }
-    else {
-        if (!args.name) {
-            throw new Error("Provide an action name param");
-        }
-        name = args.name;
-        delete args.name;
-    }
-    const { found, path, ext } = getFeatureSpec(name, "action");
-    if (!found) {
-        throw new Error(`Action ${name} not found at ${path}`);
-    }
-    let act;
-    switch (ext) {
-        case "js":
-            const mjsa = await import(path);
-            act = createJsAction(mjsa.action);
-            break;
-        case "yml":
-            act = systemAction(path);
-            break;
-        case "py":
-            act = pythonAction(path);
-            break;
-        default:
-            throw new Error(`Action ext ${ext} not implemented`);
-    }
-    const res = await act.run(args, options);
-    if (!quiet) {
-        if (res) {
-            console.log(res);
-        }
-    }
-    return res;
-}
-export { executeActionCmd, systemAction, pythonAction };
+export { executeAction, executeActionCmd, systemAction, pythonAction, };

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

@@ -3,9 +3,9 @@ function createJsAction(action) {
     const task = useAgentTask({
         id: "",
         title: "",
-        run: async (args) => {
+        run: async (args, options) => {
             try {
-                const res = await action(args);
+                const res = await action(args, options);
                 return res;
             }
             catch (e) {

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

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

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

@@ -1,18 +1,6 @@
 import { getFeatureSpec } from "../../../state/features.js";
 import { createJsAction } from "../actions/read.js";
-async function executeAdaptaterCmd(args = [], options = {}) {
-    const isWorkflow = !Array.isArray(args);
-    let name;
-    if (!isWorkflow) {
-        name = args.shift();
-    }
-    else {
-        if (!args.name) {
-            throw new Error("provide an adaptater name param");
-        }
-        name = args.name;
-        delete args.name;
-    }
+async function executeAdaptater(name, argsOrParams, options) {
     const { found, path } = getFeatureSpec(name, "adaptater");
     if (!found) {
         throw new Error(`adaptater ${name} not found`);
@@ -22,7 +10,7 @@ async function executeAdaptaterCmd(args = [], options = {}) {
     act = createJsAction(jsa.action);
     let res;
     try {
-        res = await act.run(args, options);
+        res = await act.run(argsOrParams, options);
     }
     catch (e) {
         throw new Error(`adaptater ${name}: ${e}`);
@@ -32,4 +20,4 @@ async function executeAdaptaterCmd(args = [], options = {}) {
     }
     return res;
 }
-export { executeAdaptaterCmd, };
+export { executeAdaptater, };

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

@@ -1,3 +1,3 @@
-declare function showModelsCmd(args: Array<string>, options: any): Promise<void>;
+declare function showModelsCmd(args: Array<string>): Promise<void>;
 declare function updateAllModels(): void;
 export { updateAllModels, showModelsCmd, };

package/dist/cmd/lib/models.js

@@ -3,19 +3,21 @@ import { readModelfiles, readModels } from "../../db/read.js";
 import { readModelsFile } from "../sys/read_modelfile.js";
 import { updateModels as dbUpdateModels } from "../../db/write.js";
 import color from "ansi-colors";
-async function showModelsCmd(args, options) {
+async function showModelsCmd(args) {
     let models = readModels();
     models.sort((a, b) => a.name.localeCompare(b.name));
+    let foundModels = new Array();
     if (args.length > 0) {
         args.forEach((a) => {
-            models = models.filter((m) => m.shortname.includes(a) || m.name.includes(a));
+            const fm = models.filter((m) => m.shortname.includes(a) || m.name.includes(a));
+            foundModels.push(...fm);
         });
     }
-    models.forEach((model) => {
+    else {
+        foundModels = models;
+    }
+    foundModels.forEach((model) => {
         const ips = model.data.inferParams;
-        if (!ips?.max_tokens) {
-            throw new Error(`no max tokens in ${model.shortname}`);
-        }
         const mt = ips.max_tokens;
         delete ips.max_tokens;
         const vip = Object.keys(ips).length > 0 ? JSON.stringify(ips) : "";

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

@@ -0,0 +1,7 @@
+import { LmTaskConfig } from "../../interfaces.js";
+declare function parseCommandArgs(args: Array<any>): {
+    args: Array<any>;
+    options: Record<string, any>;
+};
+declare function parseTaskConfigOptions(options: Record<string, any>): LmTaskConfig;
+export { parseCommandArgs, parseTaskConfigOptions, };

package/dist/cmd/lib/options_parsers.js

@@ -0,0 +1,41 @@
+function parseCommandArgs(args) {
+    const res = {
+        args: new Array(),
+        options: {},
+    };
+    args.pop();
+    res.options = args.pop();
+    res.args = Array.isArray(args[0]) ? args[0] : args;
+    return res;
+}
+function parseTaskConfigOptions(options) {
+    const conf = { inferParams: {}, modelname: "", templateName: "" };
+    const optionsInferParams = {};
+    if (options?.temperature) {
+        optionsInferParams.temperature = options.temperature;
+    }
+    if (options?.top_k !== undefined) {
+        optionsInferParams.top_k = options.top_k;
+    }
+    if (options?.top_p !== undefined) {
+        optionsInferParams.top_p = options.top_p;
+    }
+    if (options?.min_p !== undefined) {
+        optionsInferParams.min_p = options.min_p;
+    }
+    if (options?.max_tokens !== undefined) {
+        optionsInferParams.max_tokens = options.max_tokens;
+    }
+    if (options?.repeat_penalty !== undefined) {
+        optionsInferParams.repeat_penalty = options.repeat_penalty;
+    }
+    if (options?.model !== undefined) {
+        conf.modelname = options.model;
+    }
+    if (options?.template !== undefined) {
+        conf.templateName = options.template;
+    }
+    conf.inferParams = optionsInferParams;
+    return conf;
+}
+export { parseCommandArgs, parseTaskConfigOptions, };

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

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

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

@@ -1,57 +1,62 @@
 import { compile, serializeGrammar } from "@intrinsicai/gbnfgen";
+import color from "ansi-colors";
 import ora from 'ora';
 import { brain, initAgent, taskBuilder } from "../../../agent.js";
+import { readClipboard } from "../../../cmd/sys/clipboard.js";
 import { readTool } from "../../../db/read.js";
-import { isChatMode, isDebug, isQuiet, isShowTokens, isVerbose } from "../../../state/state.js";
-import { parseArgs } from "../../../utils/args.js";
-import { executeActionCmd, } from "../actions/cmd.js";
-import { formatStats, parseInputOptions } from "../utils.js";
-import { executeWorkflowCmd } from "../workflows/cmd.js";
-import { configureTaskModel, mergeConfOptions, mergeInferParams } from "./conf.js";
+import { usePerfTimer } from "../../../main.js";
+import { isChatMode } from "../../../state/state.js";
+import { executeAction } from "../actions/cmd.js";
+import { parseCommandArgs, parseTaskConfigOptions } from "../options_parsers.js";
+import { runtimeDataError } from "../user_msgs.js";
+import { formatStats, readPromptFile } from "../utils.js";
+import { executeWorkflow } from "../workflows/cmd.js";
+import { configureTaskModel, mergeInferParams } from "./conf.js";
 import { openTaskSpec } from "./utils.js";
-async function executeTaskCmd(args = [], options = {}) {
+import { McpServer } from "./mcp.js";
+async function executeTask(name, payload, options, quiet = false) {
     await initAgent();
-    if (isDebug.value) {
-        console.log("Task args:", args);
+    if (options.debug) {
+        console.log("Payload:", payload);
         console.log("Task options:", options);
     }
-    const isWorkflow = !Array.isArray(args);
-    let name;
-    let pr;
-    if (!isWorkflow) {
-        name = args.shift();
-        const _pr = await parseInputOptions(options);
-        if (!_pr) {
-            const p = args.shift();
-            if (p) {
-                pr = p;
-            }
-            else {
-                throw new Error("Please provide a prompt");
-            }
-        }
-        else {
-            pr = _pr;
-        }
-    }
-    else {
-        if (!(args?.name)) {
-            throw new Error("Provide a task name param");
-        }
-        if (!(args?.prompt)) {
-            throw new Error("Provide a task prompt param");
-        }
-        name = args.name;
-        pr = args.prompt;
-    }
     const taskFileSpec = openTaskSpec(name);
-    let { conf, vars } = parseArgs(args, true);
-    conf = mergeConfOptions(conf, options);
+    const conf = parseTaskConfigOptions(options);
+    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;
-    if (taskSpec.toolsList) {
+    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 tool of Object.values(taskFileSpec.mcp)) {
+            const mcp = new McpServer(tool.command, tool.arguments, 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) {
@@ -59,21 +64,17 @@ async function executeTaskCmd(args = [], options = {}) {
             }
             const lmTool = {
                 ...tool,
-                execute: async (args) => {
-                    const normalizedArgs = Array.isArray(args) ? [toolName, ...args] : {
-                        name: toolName,
-                        ...args,
-                    };
+                execute: async (params) => {
                     switch (type) {
                         case "action":
-                            const res = await executeActionCmd(normalizedArgs, conf, true);
+                            const res = await executeAction(toolName, params, options, true);
                             return res;
                         case "task":
-                            conf.quiet = !isDebug.value;
-                            const tres = await executeTaskCmd(normalizedArgs, conf);
+                            conf.quiet = !options?.debug;
+                            const tres = await executeTask(name, params, options, true);
                             return tres.answer.text;
                         case "workflow":
-                            const wres = await executeWorkflowCmd(toolName, normalizedArgs, conf);
+                            const wres = await executeWorkflow(toolName, params, options);
                             return wres;
                         default:
                             throw new Error(`unknown tool execution function type: ${type} for ${toolName}`);
@@ -90,9 +91,8 @@ async function executeTaskCmd(args = [], options = {}) {
         model.inferParams.grammar = serializeGrammar(await compile(model.inferParams.tsGrammar, "Grammar"));
         delete model.inferParams.tsGrammar;
     }
-    if (isDebug.value) {
+    if (options.debug) {
         console.log("Task model:", model);
-        console.log("Task vars:", vars);
     }
     const ex = brain.getOrCreateExpertForModel(model.name, model.template);
     if (!ex) {
@@ -104,7 +104,7 @@ async function executeTaskCmd(args = [], options = {}) {
     const hasThink = ex.template?.tags?.think;
     const hasTools = ex.template?.tags?.toolCall;
     const printToken = (t) => {
-        if (isShowTokens.value) {
+        if (options?.tokens === true) {
             let txt = t;
             txt = c ? t : `\x1b[100m${t}\x1b[0m`;
             process.stdout.write(txt);
@@ -116,12 +116,23 @@ async function executeTaskCmd(args = [], options = {}) {
         }
     };
     let processToken = printToken;
-    if ((hasThink || hasTools) && !isDebug.value) {
+    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 (isQuiet.value) {
+            if (i == 0) {
+                perfTimer.start();
+            }
+            spinner.text = formatTokenCount(i);
+            if (!options?.verbose) {
                 if (hasThink) {
                     if (t == ex.template.tags.think?.start) {
                         spinner.start();
@@ -131,18 +142,27 @@ async function executeTaskCmd(args = [], options = {}) {
                     else if (t == ex.template.tags.think?.end) {
                         continueWrite = true;
                         skipNextEmptyLinesToken = true;
-                        spinner.stop();
+                        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) {
+                    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 (isVerbose.value) {
+                    if (options?.verbose === true) {
                         skipNextEmptyLinesToken = true;
                         continueWrite = true;
                     }
@@ -162,7 +182,7 @@ async function executeTaskCmd(args = [], options = {}) {
         };
     }
     const onToolCall = (tc) => {
-        console.log("⚒️ ", `Executing [${name}]`, tc.name, tc.arguments);
+        console.log("⚒️ ", color.bold(name), "=>", `${color.yellowBright(tc.name)}`, tc.arguments);
     };
     if (options?.onToken) {
         ex.backend.setOnToken(options.onToken);
@@ -173,14 +193,14 @@ async function executeTaskCmd(args = [], options = {}) {
     const tconf = {
         expert: ex,
         model: model,
-        debug: isDebug.value,
+        debug: options.debug,
         onToolCall: onToolCall,
         ...conf,
     };
     tconf.expert = ex;
     let out;
     try {
-        out = await task.run({ prompt: pr, ...vars }, tconf);
+        out = await task.run({ prompt: payload.prompt, ...vars }, tconf);
         if (!out.answer.text.endsWith("\n")) {
             console.log();
         }
@@ -188,15 +208,37 @@ async function executeTaskCmd(args = [], options = {}) {
     catch (err) {
         throw new Error(`executing task: ${name} (${err})`);
     }
+    mcpServers.forEach(async (s) => await s.stop());
     if (isChatMode.value) {
         if (brain.ex.name != ex.name) {
             brain.setDefaultExpert(ex);
         }
-        brain.ex.template.pushToHistory({ user: pr, assistant: out.answer.text });
+        brain.ex.template.pushToHistory({ user: payload.prompt, assistant: out.answer.text });
     }
-    if (isDebug.value || isVerbose.value) {
+    if (options?.debug === true || options?.verbose === true) {
         console.log("\n", formatStats(out.answer.stats));
     }
     return out;
 }
-export { executeTaskCmd };
+async function executeTaskCmd(name, targs = []) {
+    const { args, options } = parseCommandArgs(targs);
+    let pr;
+    if (options?.clipboardInput === true) {
+        pr = await readClipboard();
+    }
+    else if (options?.inputFile === true) {
+        pr = readPromptFile();
+    }
+    else {
+        if (args[0] !== undefined) {
+            pr = args[0];
+        }
+        else {
+            runtimeDataError("task", name, "provide a prompt or use input options");
+            throw new Error();
+        }
+    }
+    const params = { args: args, prompt: pr };
+    return await executeTask(name, params, options);
+}
+export { executeTask, executeTaskCmd };

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

@@ -0,0 +1,13 @@
+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";
+declare class McpServer {
+    transport: StdioClientTransport;
+    client: Client;
+    authorizedTools: Array<string> | null;
+    constructor(command: string, args: Array<string>, authorizedTools?: string[]);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    extractTools(): Promise<Array<LmTaskToolSpec>>;
+}
+export { McpServer, };

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

@@ -0,0 +1,57 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+class McpServer {
+    transport;
+    client;
+    authorizedTools = null;
+    constructor(command, args, authorizedTools = new Array) {
+        this.transport = new StdioClientTransport({
+            command: command,
+            args: args
+        });
+        this.client = new Client({ name: "AgentSmith", version: "1.0.0" });
+        if (authorizedTools) {
+            this.authorizedTools = authorizedTools;
+        }
+    }
+    async start() {
+        await this.client.connect(this.transport);
+    }
+    async stop() {
+        await this.client.close();
+    }
+    async extractTools() {
+        const toolSpecs = new Array();
+        const serverToolsList = await this.client.listTools();
+        for (const tool of serverToolsList.tools) {
+            if (this.authorizedTools) {
+                if (!this.authorizedTools.includes(tool.name)) {
+                    continue;
+                }
+            }
+            const args = {};
+            if (tool.inputSchema.properties) {
+                for (const [k, v] of Object.entries(tool.inputSchema.properties)) {
+                    const vv = v;
+                    args[k] = { description: vv.description + " (" + vv.type + ")" };
+                }
+            }
+            const exec = async (args) => {
+                const res = await this.client.callTool({
+                    name: tool.name,
+                    arguments: args,
+                });
+                return res;
+            };
+            const t = {
+                name: tool.name,
+                description: tool.description ?? "",
+                arguments: args,
+                execute: exec
+            };
+            toolSpecs.push(t);
+        }
+        return toolSpecs;
+    }
+}
+export { McpServer, };

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

@@ -1,6 +1,13 @@
 import { FeatureExtension } from '../../interfaces.js';
+declare function extractTaskToolDocAndVariables(name: string, ext: FeatureExtension, dirPath: string): {
+    toolDoc: string;
+    variables: {
+        required: Array<string>;
+        optional: Array<string>;
+    };
+};
 declare function extractToolDoc(name: string, ext: FeatureExtension, dirPath: string): {
     found: boolean;
     toolDoc: string;
 };
-export { extractToolDoc, };
+export { extractToolDoc, extractTaskToolDocAndVariables, };