@agent-smith/cli 0.0.70 → 0.0.80

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,10 +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 { 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()); });
     program.command("exit")
         .description("exit the cli")
         .action(() => process.exit(0));
@@ -36,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) => {
@@ -88,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/clicmds/cmds.js

@@ -1,9 +1,14 @@
 import { readCmds } from "../sys/read_cmds.js";
 async function initUserCmds(cmdFeats) {
+    const paths = new Set();
     const cmds = new Array();
     for (const feat of Object.values(cmdFeats)) {
+        if (paths.has(feat.path)) {
+            continue;
+        }
         const c = await readCmds(`${feat.path}`);
         cmds.push(...c);
+        paths.add(feat.path);
     }
     return cmds;
 }

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