@agent-smith/cli 0.0.94 → 0.0.96

package/dist/cmd/clicmds/base.js

@@ -1,38 +1,28 @@
-import YAML from 'yaml';
-import { dbPath } from "../../conf.js";
-import { readFeaturePaths, readFeaturesType } from "../../db/read.js";
-import { cleanupFeaturePaths, updateAliases, updateFeatures } from "../../db/write.js";
-import { getFeatureSpec, readFeaturesDirs } from "../../state/features.js";
-import { readPluginsPaths } from "../../state/plugins.js";
-import { runMode } from "../../state/state.js";
-import { showModelsCmd } from "../lib/models.js";
+import { Option } from "commander";
+import { listBackends, setBackend } from "../../state/backends.js";
 import { parseCommandArgs } from "../lib/options_parsers.js";
-import { deleteFileIfExists } from "../sys/delete_file.js";
-import { readTask } from "../sys/read_task.js";
+import { processTaskCmd, processTasksCmd, resetDbCmd, updateFeaturesCmd } from "./cmds.js";
 import { updateConfCmd } from "./update.js";
-import { listBackends, setBackend } from "../../state/backends.js";
+import { inferenceOptions } from "../options.js";
 function initBaseCommands(program) {
     program.command("exit")
         .description("exit the cli")
         .action(() => process.exit(0));
-    program.command("tasks")
+    const tasksCmd = program.command("tasks")
         .description("list all the tasks")
         .action(async (...args) => {
-        const ts = Object.keys(readFeaturesType("task")).sort();
-        console.table(ts);
-    });
-    program.command("task <task>")
-        .description("read a task")
-        .action(async (...args) => {
         const ca = parseCommandArgs(args);
-        await _readTaskCmd(ca.args);
+        await processTasksCmd(ca.args, ca.options);
     });
-    program.command("models [filters...]")
-        .description("list the available models")
+    tasksCmd.addOption(new Option("-c, --conf", "output the tasks config"));
+    const taskCmd = program.command("task <task>")
+        .description("read a task")
         .action(async (...args) => {
         const ca = parseCommandArgs(args);
-        await showModelsCmd(ca.args);
+        await processTaskCmd(ca.args, ca.options);
     });
+    inferenceOptions.forEach(o => taskCmd.addOption(o));
+    taskCmd.addOption(new Option("--reset", "reset the task config to the original"));
     program.command("backend <name>")
         .description("set the default backend")
         .action(async (...args) => {
@@ -47,7 +37,7 @@ function initBaseCommands(program) {
     program.command("update")
         .description("update the available features: run this after adding a new feature")
         .action(async (...args) => {
-        await _updateFeatures();
+        await updateFeaturesCmd();
     });
     program.command("conf <path>")
         .description("process config file")
@@ -58,44 +48,8 @@ function initBaseCommands(program) {
     program.command("reset")
         .description("reset the config database")
         .action(async (...args) => {
-        await _resetDbCmd();
+        await resetDbCmd();
     });
     return program;
 }
-async function _resetDbCmd() {
-    if (runMode.value == "cli") {
-        console.log("This command can not be run in cli mode");
-        return;
-    }
-    deleteFileIfExists(dbPath);
-    console.log("Config database reset ok. Run the conf command to recreate it");
-}
-async function _updateFeatures() {
-    const fp = readFeaturePaths();
-    const pp = await readPluginsPaths();
-    const paths = [...fp, ...pp];
-    const feats = readFeaturesDirs(paths);
-    updateFeatures(feats);
-    updateAliases(feats);
-    const deleted = cleanupFeaturePaths(paths);
-    for (const el of deleted) {
-        console.log("- [feature path]", el);
-    }
-}
-async function _readTaskCmd(args) {
-    if (args.length == 0) {
-        console.warn("Provide a task name");
-        return;
-    }
-    const { found, path } = getFeatureSpec(args[0], "task");
-    if (!found) {
-        console.warn(`FeatureType ${args[0]} not found`);
-        return;
-    }
-    const res = readTask(path);
-    if (!res.found) {
-        throw new Error(`Task ${args[0]}, ${path} not found`);
-    }
-    console.log(YAML.stringify(res.ymlTask));
-}
 export { initBaseCommands };

package/dist/cmd/clicmds/cmds.d.ts

@@ -1,4 +1,8 @@
 import { Command } from 'commander';
 import { FeatureSpec } from '../../interfaces.js';
 declare function initUserCmds(cmdFeats: Record<string, FeatureSpec>): Promise<Array<Command>>;
-export { initUserCmds };
+declare function resetDbCmd(): Promise<any>;
+declare function updateFeaturesCmd(): Promise<any>;
+declare function processTasksCmd(args: Array<string>, options: Record<string, any>): Promise<void>;
+declare function processTaskCmd(args: Array<string>, options: Record<string, any>): Promise<any>;
+export { initUserCmds, resetDbCmd, updateFeaturesCmd, processTaskCmd, processTasksCmd, };

package/dist/cmd/clicmds/cmds.js

@@ -1,4 +1,15 @@
 import { readCmds } from "../sys/read_cmds.js";
+import YAML from 'yaml';
+import colors from "ansi-colors";
+import { dbPath } from "../../conf.js";
+import { readFeaturePaths, readFeaturesType, readTaskSetting } from "../../db/read.js";
+import { cleanupFeaturePaths, deleteTaskSetting, updateAliases, updateFeatures, upsertTaskSettings } from "../../db/write.js";
+import { getFeatureSpec, readFeaturesDirs } from "../../state/features.js";
+import { readPluginsPaths } from "../../state/plugins.js";
+import { runMode } from "../../state/state.js";
+import { deleteFileIfExists } from "../sys/delete_file.js";
+import { readTask } from "../sys/read_task.js";
+import { isTaskSettingsInitialized, initTaskSettings, tasksSettings } from '../../state/tasks.js';
 async function initUserCmds(cmdFeats) {
     const paths = new Set();
     const cmds = new Array();
@@ -12,4 +23,73 @@ async function initUserCmds(cmdFeats) {
     }
     return cmds;
 }
-export { initUserCmds };
+async function resetDbCmd() {
+    if (runMode.value == "cli") {
+        console.log("This command can not be run in cli mode");
+        return;
+    }
+    deleteFileIfExists(dbPath);
+    console.log("Config database reset ok. Run the conf command to recreate it");
+}
+async function updateFeaturesCmd() {
+    const fp = readFeaturePaths();
+    const pp = await readPluginsPaths();
+    const paths = [...fp, ...pp];
+    const feats = readFeaturesDirs(paths);
+    updateFeatures(feats);
+    updateAliases(feats);
+    const deleted = cleanupFeaturePaths(paths);
+    for (const el of deleted) {
+        console.log("- [feature path]", el);
+    }
+}
+async function processTasksCmd(args, options) {
+    if (options?.conf) {
+        if (!isTaskSettingsInitialized.value) {
+            initTaskSettings();
+        }
+        console.log(YAML.stringify({ "tasks": tasksSettings }));
+    }
+    else {
+        const ts = Object.keys(readFeaturesType("task")).sort();
+        console.table(ts);
+    }
+}
+async function processTaskCmd(args, options) {
+    if (args.length == 0) {
+        console.warn("Provide a task name");
+        return;
+    }
+    const { found, path } = getFeatureSpec(args[0], "task");
+    if (!found) {
+        console.warn(`Task ${args[0]} not found`);
+        return;
+    }
+    if (options?.reset) {
+        deleteTaskSetting(args[0]);
+        console.log("Task", args[0], "reset ok");
+        return;
+    }
+    const res = readTask(path);
+    if (!res.found) {
+        throw new Error(`Task ${args[0]}, ${path} not found`);
+    }
+    console.log(res.ymlTask);
+    if (Object.keys(options).length > 0) {
+        upsertTaskSettings(args[0], options);
+    }
+    const s = readTaskSetting(args[0]);
+    if (s.found) {
+        const sts = s.settings;
+        delete sts.id;
+        delete sts.name;
+        const display = {};
+        for (const [k, v] of Object.entries(sts)) {
+            if (v) {
+                display[k] = v;
+            }
+        }
+        console.log(colors.dim("Settings") + ":", display);
+    }
+}
+export { initUserCmds, resetDbCmd, updateFeaturesCmd, processTaskCmd, processTasksCmd, };

package/dist/cmd/clicmds/update.js

@@ -4,7 +4,6 @@ import { readFilePath } from "../../db/read.js";
 import { cleanupFeaturePaths, updateAliases, updateDataDirPath, updateFeatures, updatePromptfilePath, upsertFilePath } from "../../db/write.js";
 import { readFeaturesDirs } from "../../state/features.js";
 import { dataDirPath, promptfilePath } from "../../state/state.js";
-import { updateAllModels } from '../lib/models.js';
 import { runtimeDataError, runtimeInfo } from '../lib/user_msgs.js';
 async function updateConfCmd(args) {
     initDb(false, true);
@@ -37,7 +36,6 @@ async function updateConfCmd(args) {
     const feats = readFeaturesDirs(paths);
     updateFeatures(feats);
     updateAliases(feats);
-    updateAllModels();
     const deleted = cleanupFeaturePaths(paths);
     for (const el of deleted) {
         console.log("- [feature path]", el);

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

@@ -5,7 +5,7 @@ function createJsAction(action) {
             return res;
         }
         catch (e) {
-            throw new Error(`executing action:${e}`);
+            throw new Error(`executing action:${e}. Args: ${args}`);
         }
     };
     return run;

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

@@ -12,19 +12,69 @@ import { parseCommandArgs } from "../options_parsers.js";
 import { runtimeDataError, runtimeError, runtimeWarning } from "../user_msgs.js";
 import { formatStats, processOutput, readPromptFile } from "../utils.js";
 import { readTask } from "./read.js";
+import { backend, backends, listBackends } from "../../../state/backends.js";
+import { isTaskSettingsInitialized, initTaskSettings, tasksSettings } from "../../../state/tasks.js";
 async function executeTask(name, payload, options, quiet) {
-    if (options?.debug) {
+    if (!isTaskSettingsInitialized.value) {
+        initTaskSettings();
+    }
+    const hasSettings = Object.keys(tasksSettings).includes(name);
+    let settings = {};
+    if (hasSettings) {
+        settings = tasksSettings[name];
+    }
+    if (options?.backend) {
+        if (options.backend in backends) {
+            agent.lm = backends[options.backend];
+        }
+        else {
+            const bks = await listBackends(false);
+            runtimeDataError(`The backend ${options.backend} is not registered in config. Available backends:\n`, bks);
+        }
+    }
+    else if (settings?.backend) {
+        agent.lm = backends[settings.backend];
+    }
+    if (options?.debug || options?.backend) {
         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 (hasSettings) {
+        if (!model?.inferParams) {
+            model.inferParams = {};
+        }
+        if (settings?.model && !conf?.model?.name) {
+            model.name = settings.model;
+        }
+        if (settings?.template && !conf?.model?.template) {
+            model.template = settings.template;
+        }
+        if (settings?.ctx && !conf?.model?.ctx) {
+            model.ctx = settings.ctx;
+        }
+        if (settings?.max_tokens && !conf?.inferParams?.max_tokens) {
+            model.inferParams.max_tokens = settings.max_tokens;
+        }
+        if (settings?.top_k && !conf?.inferParams?.top_k) {
+            model.inferParams.top_k = settings.top_k;
+        }
+        if (settings?.top_p && !conf?.inferParams?.top_p) {
+            model.inferParams.top_p = settings.top_p;
+        }
+        if (settings?.min_p && !conf?.inferParams?.min_p) {
+            model.inferParams.min_p = settings.min_p;
+        }
+        if (settings?.temperature && !conf?.inferParams?.temperature) {
+            model.inferParams.temperature = settings.temperature;
+        }
+        if (settings?.repeat_penalty && !conf?.inferParams?.repeat_penalty) {
+            model.inferParams.repeat_penalty = settings.repeat_penalty;
+        }
+    }
     if (model?.inferParams?.tsGrammar) {
         model.inferParams.grammar = serializeGrammar(await compile(model.inferParams.tsGrammar, "Grammar"));
         delete model.inferParams.tsGrammar;
     }
-    if (options?.debug) {
-        console.log("Task model:", model);
-        console.log("Task vars:", vars);
-    }
     let c = false;
     const useTemplates = agent.lm.providerType !== "openai";
     let hasThink = false;
@@ -33,6 +83,10 @@ async function executeTask(name, payload, options, quiet) {
         tpl = new PromptTemplate(model.template ?? "none");
         hasThink = tpl.tags?.think ? true : false;
     }
+    if (options?.debug) {
+        console.log("Task model:", model);
+        console.log("Task vars:", vars);
+    }
     const printToken = (t) => {
         if (options?.tokens === true) {
             let txt = t;
@@ -197,6 +251,9 @@ async function executeTask(name, payload, options, quiet) {
             runtimeWarning("Error formating stats:", `${e}`);
         }
     }
+    if (options?.backend) {
+        agent.lm = backend.value;
+    }
     return out;
 }
 async function executeTaskCmd(name, targs = []) {

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

@@ -19,11 +19,9 @@ function configureTaskModel(itConf, taskSpec) {
     }
     if (!foundTemplate) {
         if (itConf?.model?.name) {
-            if (itConf?.model?.name != taskSpec.model.name) {
-                const gt = guessTemplate(itConf.model.name);
-                model.template = gt;
-                foundTemplate = true;
-            }
+            const gt = guessTemplate(itConf.model.name);
+            model.template = gt;
+            foundTemplate = true;
         }
         else if (taskSpec?.model?.template) {
             model.template = taskSpec.model.template;

package/dist/cmd/options.js

@@ -13,6 +13,7 @@ const inferenceOptions = [
     new Option("--mp, --min_p <number>", "the minimum probability for a token to be considered, relative to the probability of the most likely token").argParser(parseFloatValue),
     new Option("-t, --temperature <number>", "adjusts randomness in sampling; higher values mean more randomness").argParser(parseFloatValue),
     new Option("-r, --repeat_penalty <number>", "adjusts penalty for repeated tokens").argParser(parseFloatValue),
+    new Option("-b, --backend <name>", "use a given backend. It must be registered in config").argParser(parseString),
 ];
 const ioOptions = [
     new Option("--if, --input-file", "use promptfile input mode"),

package/dist/cmd/sys/read_features.js

@@ -22,7 +22,6 @@ function readFeaturesDir(dir) {
         cmd: [],
         workflow: [],
         adaptater: [],
-        modelfile: []
     };
     let dirpath = path.join(dir, "tasks");
     if (fs.existsSync(dirpath)) {
@@ -94,20 +93,6 @@ function readFeaturesDir(dir) {
             });
         });
     }
-    dirpath = path.join(dir, "models");
-    if (fs.existsSync(dirpath)) {
-        const data = _readDir(dirpath, [".yml"]);
-        data.forEach((filename) => {
-            const parts = filename.split(".");
-            const ext = parts.pop();
-            const name = parts.join("");
-            feats.modelfile.push({
-                name: name,
-                path: path.join(dirpath),
-                ext: ext,
-            });
-        });
-    }
     return feats;
 }
 export { readFeaturesDir };

package/dist/conf.js

@@ -1,11 +1,12 @@
 import { readConf } from "./cmd/sys/read_conf.js";
-import { upsertBackends, insertFeaturesPathIfNotExists, insertPluginIfNotExists } from "./db/write.js";
+import { upsertBackends, insertFeaturesPathIfNotExists, insertPluginIfNotExists, upsertTaskSettings, deleteTaskSettings } from "./db/write.js";
 import { buildPluginsPaths } from "./state/plugins.js";
 import { runtimeError } from "./cmd/lib/user_msgs.js";
 import { localBackends } from "./const.js";
 import { homedir } from 'os';
 import { join } from 'path';
 import { createDirectoryIfNotExists } from "./cmd/sys/dirs.js";
+import { initTaskSettings, tasksSettings } from "./state/tasks.js";
 function getConfigPath(appName, filename) {
     let confDir;
     let dbPath;
@@ -93,6 +94,16 @@ async function processConfPath(confPath) {
             insertPluginIfNotExists(_pl.name, _pl.path);
         });
     }
+    if (data?.tasks) {
+        initTaskSettings();
+        const okTasks = new Array();
+        for (const [name, settings] of Object.entries(data.tasks)) {
+            upsertTaskSettings(name, settings);
+            okTasks.push(name);
+        }
+        const toDel = Object.keys(tasksSettings).filter(t => !okTasks.includes(t));
+        deleteTaskSettings(toDel);
+    }
     let pf = "";
     if (data?.promptfile) {
         pf = data.promptfile;

package/dist/db/read.d.ts

@@ -1,5 +1,5 @@
 import { ToolSpec } from "@locallm/types";
-import { AliasType, FeatureSpec, FeatureType, DbModelDef, ToolType, InferenceBackend } from "../interfaces.js";
+import { AliasType, FeatureSpec, FeatureType, ToolType, InferenceBackend } from "../interfaces.js";
 declare function readFeaturePaths(): Array<string>;
 declare function readBackends(): Record<string, InferenceBackend>;
 declare function readPlugins(): Array<Record<string, string>>;
@@ -26,10 +26,9 @@ declare function readFilePath(name: string): {
     found: boolean;
     path: string;
 };
-declare function readModelfiles(): Array<Record<string, string>>;
-declare function readModels(): Array<DbModelDef>;
-declare function readModel(shortname: string): {
+declare function readTaskSettings(): Array<Record<string, any>>;
+declare function readTaskSetting(name: string): {
     found: boolean;
-    modelData: Record<string, any>;
+    settings: Record<string, string>;
 };
-export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readFilePath, readFilePaths, readTool, readModels, readModelfiles, readModel, readFeaturesType, readBackends, };
+export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readFilePath, readFilePaths, readTool, readFeaturesType, readBackends, readTaskSettings, readTaskSetting, };

package/dist/db/read.js

@@ -43,14 +43,13 @@ function readFeaturesType(type) {
 }
 function readFeatures() {
     const feats = {
-        task: {}, action: {}, cmd: {}, workflow: {}, adaptater: {}, modelfile: {}
+        task: {}, action: {}, cmd: {}, workflow: {}, adaptater: {}
     };
     feats.task = readFeaturesType("task");
     feats.action = readFeaturesType("action");
     feats.cmd = readFeaturesType("cmd");
     feats.workflow = readFeaturesType("workflow");
     feats.adaptater = readFeaturesType("adaptater");
-    feats.modelfile = readFeaturesType("modelfile");
     return feats;
 }
 function readAliases() {
@@ -110,38 +109,18 @@ function readFilePath(name) {
     }
     return { found: false, path: "" };
 }
-function readModelfiles() {
-    const stmt = db.prepare("SELECT name, path, ext FROM modelfile");
-    const data = stmt.all();
-    let f = new Array();
-    data.forEach((row) => {
-        f.push(row);
-    });
-    return f;
-}
-function readModels() {
-    const stmt = db.prepare("SELECT name, shortname, data FROM model");
-    const data = stmt.all();
-    let f = new Array();
-    data.forEach((row) => {
-        const ips = JSON.parse(row.data);
-        const mod = {
-            name: row.name,
-            shortname: row.shortname,
-            data: ips,
-        };
-        f.push(mod);
-    });
-    return f;
+function readTaskSettings() {
+    const stmt1 = db.prepare("SELECT * FROM tasksettings ORDER BY name");
+    const data = stmt1.all();
+    return data;
 }
-function readModel(shortname) {
-    const q = `SELECT id, data FROM model WHERE shortname='${shortname}'`;
+function readTaskSetting(name) {
+    const q = "SELECT * FROM tasksettings WHERE name= ?";
     const stmt = db.prepare(q);
-    const result = stmt.get();
+    const result = stmt.get(name);
     if (result?.id) {
-        const data = JSON.parse(result.data);
-        return { found: true, modelData: data };
+        return { found: true, settings: result };
     }
-    return { found: false, modelData: {} };
+    return { found: false, settings: {} };
 }
-export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readFilePath, readFilePaths, readTool, readModels, readModelfiles, readModel, readFeaturesType, readBackends, };
+export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readFilePath, readFilePaths, readTool, readFeaturesType, readBackends, readTaskSettings, readTaskSetting, };

package/dist/db/schemas.js

@@ -58,19 +58,6 @@ const alias = `CREATE TABLE IF NOT EXISTS aliases (
     name TEXT UNIQUE NOT NULL,
     type TEXT NOT NULL CHECK ( type IN ('task', 'action', 'workflow') )
 );`;
-const modelfile = `CREATE TABLE IF NOT EXISTS modelfile (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    name TEXT UNIQUE NOT NULL,
-    path TEXT NOT NULL,
-    variables TEXT,
-    ext TEXT NOT NULL CHECK ( ext IN ('yml') )
-);`;
-const model = `CREATE TABLE IF NOT EXISTS model (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    name TEXT NOT NULL,
-    shortname TEXT UNIQUE NOT NULL,
-    data TEXT NOT NULL
-);`;
 const backend = `CREATE TABLE IF NOT EXISTS backend (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
@@ -79,6 +66,20 @@ const backend = `CREATE TABLE IF NOT EXISTS backend (
     isdefault INTEGER NOT NULL,
     apiKey TEXT
 );`;
+const tasksSettings = `CREATE TABLE IF NOT EXISTS tasksettings (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    model TEXT,
+    template TEXT,
+    ctx INTEGER,
+    maxtokens INTEGER
+    topk INTEGER,
+    topp REAL,
+    minp REAL,
+    temperature REAL,
+    repeat REAL,
+    backend TEXT
+);`;
 const schemas = [
     filepath,
     featurespath,
@@ -89,9 +90,8 @@ const schemas = [
     cmd,
     plugin,
     alias,
-    model,
-    modelfile,
     adaptater,
     backend,
+    tasksSettings,
 ];
 export { schemas };

package/dist/db/write.d.ts

@@ -1,4 +1,4 @@
-import { Features, DbModelDef, InferenceBackend } from "../interfaces.js";
+import { Features, InferenceBackend, TaskSettings } from "../interfaces.js";
 declare function updatePromptfilePath(pf: string): void;
 declare function updateDataDirPath(dd: string): void;
 declare function setDefaultBackend(name: string): void;
@@ -7,7 +7,9 @@ declare function insertFeaturesPathIfNotExists(path: string): boolean;
 declare function insertPluginIfNotExists(n: string, p: string): boolean;
 declare function cleanupFeaturePaths(paths: Array<string>): Array<string>;
 declare function updateAliases(feats: Features): void;
-declare function updateModels(models: Array<DbModelDef>): void;
 declare function updateFeatures(feats: Features): void;
 declare function upsertFilePath(name: string, newPath: string): boolean;
-export { updatePromptfilePath, updateDataDirPath, upsertBackends, setDefaultBackend, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, updateModels, upsertFilePath, };
+declare function upsertTaskSettings(taskName: string, settings: TaskSettings): boolean;
+declare function deleteTaskSettings(settings: Array<string>): void;
+declare function deleteTaskSetting(name: string): void;
+export { updatePromptfilePath, updateDataDirPath, upsertBackends, setDefaultBackend, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, upsertFilePath, upsertTaskSettings, deleteTaskSettings, deleteTaskSetting, };

package/dist/db/write.js

@@ -1,6 +1,5 @@
 import { extractTaskToolDocAndVariables, extractToolDoc } from "../cmd/lib/tools.js";
 import { db } from "./db.js";
-import { readModels } from "./read.js";
 function updatePromptfilePath(pf) {
     const deleteStmt = db.prepare("DELETE FROM filepath WHERE name = ?");
     deleteStmt.run("promptfile");
@@ -145,7 +144,6 @@ function updateVariables(name, variableDoc) {
     }
     const updateStmt = db.prepare("UPDATE task SET variables = ? WHERE id = ?");
     updateStmt.run(variableDoc, result.id);
-    console.log("~", "[task variables] updated for", name);
 }
 function upsertTool(name, type, toolDoc) {
     const stmt1 = db.prepare("SELECT * FROM tool WHERE name = ?");
@@ -153,39 +151,12 @@ function upsertTool(name, type, toolDoc) {
     if (result?.id) {
         const updateStmt = db.prepare("UPDATE tool SET spec = ?, type = ? WHERE id = ?");
         updateStmt.run(toolDoc, type, result.id);
-        console.log("~", "[tool] updated from", type, ":", name);
     }
     else {
         const stmt = db.prepare("INSERT INTO tool (name, spec, type) VALUES (?,?,?)");
         stmt.run(name, toolDoc, type);
-        console.log("+", "[tool] added from", type, ":", name);
     }
 }
-function updateModels(models) {
-    const allDbModels = readModels();
-    const existingModelShortNames = allDbModels.map(row => row.shortname);
-    const newModelShortNames = models.filter(m => !existingModelShortNames.includes(m.shortname)).map(m => m.shortname);
-    const mm = models.map(m => m.shortname);
-    const modelsToDelete = existingModelShortNames.filter(name => !mm.includes(name));
-    db.transaction(() => {
-        for (const model of models) {
-            if (!existingModelShortNames.includes(model.shortname)) {
-                const insertStmt = db.prepare("INSERT INTO model (name, shortname, data) VALUES (?, ?, ?)");
-                insertStmt.run(model.name, model.shortname, JSON.stringify(model.data));
-                console.log("+", "[model]", model.name);
-            }
-            else {
-                const updateStmt = db.prepare("UPDATE model SET name = ?, data = ? WHERE shortname = ?");
-                updateStmt.run(model.name, JSON.stringify(model.data), model.shortname);
-            }
-        }
-        for (const name of modelsToDelete) {
-            const deleteStmt = db.prepare("DELETE FROM model WHERE shortname = ?");
-            deleteStmt.run(name);
-            console.log("-", "[model]", name);
-        }
-    })();
-}
 function updateFeatures(feats) {
     upsertAndCleanFeatures(feats.task, "task");
     feats.task.forEach((feat) => {
@@ -213,7 +184,6 @@ function updateFeatures(feats) {
     });
     upsertAndCleanFeatures(feats.adaptater, "adaptater");
     upsertAndCleanFeatures(feats.cmd, "cmd");
-    upsertAndCleanFeatures(feats.modelfile, "modelfile");
 }
 function upsertFilePath(name, newPath) {
     const selectStmt = db.prepare("SELECT * FROM filepath WHERE name = ?");
@@ -230,4 +200,117 @@ function upsertFilePath(name, newPath) {
         return true;
     }
 }
-export { updatePromptfilePath, updateDataDirPath, upsertBackends, setDefaultBackend, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, updateModels, upsertFilePath, };
+function upsertTaskSettings(taskName, settings) {
+    const selectStmt = db.prepare("SELECT * FROM tasksettings WHERE name = ?");
+    const result = selectStmt.get(taskName);
+    if (result?.id) {
+        const qparams = new Array();
+        const qvalues = new Array();
+        if (settings?.model) {
+            qparams.push("model = ?");
+            qvalues.push(settings.model);
+        }
+        if (settings?.template) {
+            qparams.push("template = ?");
+            qvalues.push(settings.template);
+        }
+        if (settings?.ctx) {
+            qparams.push("ctx = ?");
+            qvalues.push(settings.ctx);
+        }
+        if (settings?.max_tokens) {
+            qparams.push("maxtokens = ?");
+            qvalues.push(settings.max_tokens);
+        }
+        if (settings?.top_k) {
+            qparams.push("topk = ?");
+            qvalues.push(settings.top_k);
+        }
+        if (settings?.top_p) {
+            qparams.push("topp = ?");
+            qvalues.push(settings.top_p);
+        }
+        if (settings?.min_p) {
+            qparams.push("minp = ?");
+            qvalues.push(settings.min_p);
+        }
+        if (settings?.temperature) {
+            qparams.push("temperature = ?");
+            qvalues.push(settings.temperature);
+        }
+        if (settings?.repeat_penalty) {
+            qparams.push("repeat = ?");
+            qvalues.push(settings.repeat_penalty);
+        }
+        if (settings?.backend) {
+            qparams.push("backend = ?");
+            qvalues.push(settings.backend);
+        }
+        const q = `UPDATE tasksettings SET ${qparams.join(", ")} WHERE name = ?`;
+        const stmt = db.prepare(q);
+        const updateResult = stmt.run(...qvalues, taskName);
+        return updateResult.changes > 0;
+    }
+    else {
+        const qnames = new Array();
+        const qvalues = new Array();
+        if (settings?.model) {
+            qnames.push("model");
+            qvalues.push(settings.model);
+        }
+        if (settings?.template) {
+            qnames.push("template");
+            qvalues.push(settings.template);
+        }
+        if (settings?.ctx) {
+            qnames.push("ctx");
+            qvalues.push(settings.ctx);
+        }
+        if (settings?.max_tokens) {
+            qnames.push("maxtokens");
+            qvalues.push(settings.max_tokens);
+        }
+        if (settings?.top_k) {
+            qnames.push("topk");
+            qvalues.push(settings.top_k);
+        }
+        if (settings?.top_p) {
+            qnames.push("topp");
+            qvalues.push(settings.top_p);
+        }
+        if (settings?.min_p) {
+            qnames.push("minp");
+            qvalues.push(settings.min_p);
+        }
+        if (settings?.temperature) {
+            qnames.push("temperature");
+            qvalues.push(settings.temperature);
+        }
+        if (settings?.repeat_penalty) {
+            qnames.push("repeat");
+            qvalues.push(settings.repeat_penalty);
+        }
+        if (settings?.backend) {
+            qnames.push("backend");
+            qvalues.push(settings.backend);
+        }
+        const nq = new Array("?");
+        qnames.forEach(n => nq.push("?"));
+        const q = `INSERT INTO tasksettings (name, ${qnames.join(", ")}) VALUES (${nq.join(", ")})`;
+        console.log(q);
+        const insertStmt = db.prepare(q);
+        insertStmt.run(taskName, ...qvalues);
+        return true;
+    }
+}
+function deleteTaskSettings(settings) {
+    settings.forEach(s => {
+        const deleteStmt = db.prepare("DELETE FROM tasksettings WHERE name = ?");
+        deleteStmt.run(s);
+    });
+}
+function deleteTaskSetting(name) {
+    const deleteStmt = db.prepare("DELETE FROM tasksettings WHERE name = ?");
+    deleteStmt.run(name);
+}
+export { updatePromptfilePath, updateDataDirPath, upsertBackends, setDefaultBackend, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, upsertFilePath, upsertTaskSettings, deleteTaskSettings, deleteTaskSetting, };

package/dist/interfaces.d.ts

@@ -1,5 +1,5 @@
-import { TaskDef, ModelSpec, TaskVariables } from "@agent-smith/task";
-import { InferenceParams, LmProviderType } from "@locallm/types";
+import type { TaskDef, ModelSpec, TaskVariables } from "@agent-smith/task";
+import type { InferenceParams, LmProviderType } from "@locallm/types";
 interface FeatureSpec {
     id?: number;
     name: string;
@@ -33,11 +33,6 @@ interface Features {
         path: string;
         ext: AdaptaterExtension;
     }>;
-    modelfile: Array<{
-        name: string;
-        path: string;
-        ext: ModelFileExtension;
-    }>;
 }
 interface ConfInferenceBackend {
     type: LmProviderType;
@@ -57,6 +52,7 @@ interface ConfigFile {
     features?: Array<string>;
     plugins?: Array<string>;
     backends?: BackendEntries;
+    tasks?: Record<string, TaskSettings>;
 }
 interface Settings {
     name: string;
@@ -86,7 +82,6 @@ interface ModelPack {
 }
 interface LmTaskFileSpec extends TaskDef {
     ctx: number;
-    modelpack?: ModelPack;
     mcp?: McpServerSpec;
 }
 interface BaseLmTaskConfig {
@@ -123,20 +118,31 @@ interface McpServerTool {
         required: string[];
     };
 }
+interface TaskSettings {
+    model?: string;
+    template?: string;
+    ctx?: number;
+    max_tokens?: number;
+    top_k?: number;
+    top_p?: number;
+    min_p?: number;
+    temperature?: number;
+    repeat_penalty?: number;
+    backend?: string;
+}
 type InputMode = "manual" | "promptfile" | "clipboard";
 type OutputMode = "txt" | "clipboard";
 type RunMode = "cli" | "cmd";
 type FormatMode = "text" | "markdown";
 type VerbosityMode = "quiet" | "verbose" | "debug";
-type FeatureType = "task" | "action" | "cmd" | "workflow" | "adaptater" | "modelfile";
+type FeatureType = "task" | "action" | "cmd" | "workflow" | "adaptater";
 type ToolType = "task" | "action" | "cmd" | "workflow";
 type ActionExtension = "js" | "mjs" | "py" | "yml";
 type TaskExtension = "yml";
 type AdaptaterExtension = "js";
 type WorkflowExtension = "yml";
 type CmdExtension = "js";
-type ModelFileExtension = "yml";
-type FeatureExtension = TaskExtension | CmdExtension | ActionExtension | WorkflowExtension | ModelFileExtension;
+type FeatureExtension = TaskExtension | CmdExtension | ActionExtension | WorkflowExtension;
 type AliasType = "task" | "action" | "workflow";
 type FeatureExecutor<I = any, O = any> = (params: I, options: Record<string, any>) => Promise<O>;
-export { InputMode, VerbosityMode, OutputMode, RunMode, FormatMode, FeatureType, ActionExtension, TaskExtension, WorkflowExtension, AdaptaterExtension, CmdExtension, ModelFileExtension, FeatureSpec, Features, ConfigFile, FeatureExtension, AliasType, ToolType, Settings, DbModelDef, ModelSpec, ModelfileSpec, ModelPack, LmTaskFileSpec, LmTaskConfig, FinalLmTaskConfig, McpServerSpec, McpServerTool, InferenceBackend, ConfInferenceBackend, FeatureExecutor, WorkflowStep, };
+export { InputMode, VerbosityMode, OutputMode, RunMode, FormatMode, FeatureType, ActionExtension, TaskExtension, WorkflowExtension, AdaptaterExtension, CmdExtension, FeatureSpec, Features, ConfigFile, FeatureExtension, AliasType, ToolType, Settings, DbModelDef, ModelSpec, ModelfileSpec, ModelPack, LmTaskFileSpec, LmTaskConfig, FinalLmTaskConfig, McpServerSpec, McpServerTool, InferenceBackend, ConfInferenceBackend, FeatureExecutor, WorkflowStep, TaskSettings, };

package/dist/state/backends.d.ts

@@ -3,5 +3,5 @@ declare const backend: import("@vue/reactivity").Ref<Lm | undefined, Lm | undefi
 declare const backends: Record<string, Lm>;
 declare function initBackends(): Promise<void>;
 declare function setBackend(name: string, isVerbose?: boolean): Promise<void>;
-declare function listBackends(): Promise<void>;
+declare function listBackends(printResult?: boolean): Promise<string>;
 export { backend, backends, initBackends, listBackends, setBackend };

package/dist/state/backends.js

@@ -1,11 +1,11 @@
 import { Lm } from "@locallm/api";
-import { reactive, ref } from "@vue/reactivity";
+import { ref } from "@vue/reactivity";
 import colors from "ansi-colors";
 import { readBackends } from "../db/read.js";
 import { setDefaultBackend } from "../db/write.js";
 import { runtimeDataError } from "../utils/user_msgs.js";
 const backend = ref();
-const backends = reactive({});
+const backends = {};
 const isBackendUp = ref(false);
 async function initBackends() {
     const rmb = readBackends();
@@ -51,12 +51,18 @@ async function setBackend(name, isVerbose = false) {
     console.log("Default backend set to", name);
     isBackendUp.value = await probeBackend(backend.value, isVerbose);
 }
-async function listBackends() {
+async function listBackends(printResult = true) {
+    const allBk = new Array();
     for (const [name, lm] of Object.entries(backends)) {
         const bcn = name == backend.value?.name ? colors.bold(name) : name;
         const buf = new Array("-", bcn, colors.dim("(" + lm.providerType + ") " + lm.serverUrl));
-        console.log(buf.join(" "));
+        const str = buf.join(" ");
+        if (printResult) {
+            console.log(str);
+        }
+        allBk.push(str);
     }
+    return allBk.join(" ");
 }
 const probeBackend = async (lm, isVerbose) => {
     let isUp = false;

package/dist/state/features.js

@@ -8,7 +8,6 @@ function readFeaturesDirs(featuresPaths) {
         cmd: [],
         workflow: [],
         adaptater: [],
-        modelfile: [],
     };
     featuresPaths.forEach((dir) => {
         const _f = readFeaturesDir(dir);
@@ -17,7 +16,6 @@ function readFeaturesDirs(featuresPaths) {
         _f.cmd.forEach((item) => feats.cmd.push(item));
         _f.workflow.forEach((item) => feats.workflow.push(item));
         _f.adaptater.forEach((item) => feats.adaptater.push(item));
-        _f.modelfile.forEach((item) => feats.modelfile.push(item));
     });
     return feats;
 }

package/dist/state/tasks.d.ts

@@ -0,0 +1,5 @@
+import { TaskSettings } from "../interfaces.js";
+declare const tasksSettings: Record<string, TaskSettings>;
+declare const isTaskSettingsInitialized: import("@vue/reactivity").Ref<boolean, boolean>;
+declare function initTaskSettings(): void;
+export { tasksSettings, initTaskSettings, isTaskSettingsInitialized, };

package/dist/state/tasks.js

@@ -0,0 +1,21 @@
+import { ref } from "@vue/reactivity";
+import { readTaskSettings } from "../db/read.js";
+const tasksSettings = {};
+const isTaskSettingsInitialized = ref(false);
+function initTaskSettings() {
+    const data = readTaskSettings();
+    data.forEach(row => {
+        const name = row.name;
+        delete row.name;
+        delete row.id;
+        const vals = {};
+        for (const [k, v] of Object.entries(row)) {
+            if (v !== null) {
+                vals[k] = v;
+            }
+        }
+        tasksSettings[name] = vals;
+    });
+    isTaskSettingsInitialized.value = true;
+}
+export { tasksSettings, initTaskSettings, isTaskSettingsInitialized, };

package/package.json

@@ -2,7 +2,7 @@
   "name": "@agent-smith/cli",
   "description": "Agent Smith: terminal client for language model agents",
   "repository": "https://github.com/synw/agent-smith",
-  "version": "0.0.94",
+  "version": "0.0.96",
   "scripts": {
     "buildrl": "rm -rf dist/* && rollup -c",
     "build": "rm -rf dist/* && tsc",
@@ -10,34 +10,35 @@
     "watch": "tsc --noCheck -p . -w"
   },
   "dependencies": {
-    "@agent-smith/agent": "^0.1.4",
-    "@agent-smith/task": "^0.1.5",
+    "@agent-smith/agent": "^0.1.5",
+    "@agent-smith/task": "^0.1.7",
     "@agent-smith/tfm": "^0.2.0",
     "@inquirer/prompts": "^7.10.1",
     "@intrinsicai/gbnfgen": "0.12.0",
-    "@locallm/api": "^0.7.0",
-    "@modelcontextprotocol/sdk": "^1.23.0",
+    "@locallm/api": "^0.7.2",
+    "@modelcontextprotocol/sdk": "^1.24.3",
     "@vue/reactivity": "^3.5.25",
     "ansi-colors": "^4.1.3",
-    "better-sqlite3": "^12.4.6",
-    "clipboardy": "^5.0.1",
+    "better-sqlite3": "^12.5.0",
+    "clipboardy": "^5.0.2",
     "commander": "^14.0.2",
     "marked-terminal": "^7.3.0",
-    "modprompt": "^0.12.5",
+    "modprompt": "^0.12.6",
     "ora": "^9.0.0",
     "python-shell": "^5.0.0",
-    "yaml": "^2.8.1"
+    "yaml": "^2.8.2"
   },
   "devDependencies": {
     "@agent-smith/tmem-jobs": "^0.0.4",
     "@cfworker/json-schema": "^4.1.1",
     "@commander-js/extra-typings": "^14.0.0",
-    "@locallm/types": "^0.6.2",
+    "@locallm/types": "^0.6.4",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-typescript": "^12.3.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/marked-terminal": "^6.1.1",
-    "@types/node": "^24.10.1",
+    "@types/node": "^25.0.2",
+    "openai": "^6.10.0",
     "restmix": "^0.6.1",
     "rollup": "^4.53.3",
     "ts-node": "^10.9.2",

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

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

package/dist/cmd/lib/models.js

@@ -1,53 +0,0 @@
-import path from "path";
-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) {
-    let models = readModels();
-    models.sort((a, b) => a.name.localeCompare(b.name));
-    let foundModels = new Array();
-    if (args.length > 0) {
-        args.forEach((a) => {
-            const fm = models.filter((m) => m.shortname.includes(a) || m.name.includes(a));
-            foundModels.push(...fm);
-        });
-    }
-    else {
-        foundModels = models;
-    }
-    foundModels.forEach((model) => {
-        const ips = model.data.inferParams;
-        const mt = ips.max_tokens;
-        delete ips.max_tokens;
-        const vip = Object.keys(ips).length > 0 ? JSON.stringify(ips) : "";
-        const m = `- ${color.yellow(model.shortname)}: ${color.bold(model.data.name)} - ${model.data.ctx} ctx / ${mt} max tokens ${vip}`;
-        console.log(m);
-    });
-}
-function updateAllModels() {
-    const mfs = readModelfiles();
-    const modelDefs = new Array();
-    mfs.forEach((mf) => {
-        const filePath = path.join(mf.path + "/" + mf.name + "." + mf.ext);
-        const { models, ctx, max_tokens, found } = readModelsFile(filePath);
-        if (!found) {
-            throw new Error(`model file ${filePath} not found`);
-        }
-        for (const [name, m] of (Object.entries(models))) {
-            if (!m?.ctx) {
-                m.ctx = ctx;
-            }
-            if (!m?.inferParams) {
-                m.inferParams = {};
-            }
-            if (!m?.inferParams?.max_tokens) {
-                m.inferParams.max_tokens = max_tokens;
-            }
-            const md = { name: m.name, shortname: name, data: m };
-            modelDefs.push(md);
-        }
-    });
-    dbUpdateModels(modelDefs);
-}
-export { updateAllModels, showModelsCmd, };

package/dist/cmd/sys/read_modelfile.d.ts

@@ -1,8 +0,0 @@
-import { ModelSpec } from "../../interfaces.js";
-declare function readModelsFile(fp: string): {
-    found: boolean;
-    ctx: number;
-    max_tokens: number;
-    models: Record<string, ModelSpec>;
-};
-export { readModelsFile, };

package/dist/cmd/sys/read_modelfile.js

@@ -1,21 +0,0 @@
-import { default as fs } from "fs";
-import YAML from 'yaml';
-function readModelsFile(fp) {
-    if (!fs.existsSync(fp)) {
-        return { models: {}, ctx: 0, max_tokens: 0, found: false };
-    }
-    const data = fs.readFileSync(fp, 'utf8');
-    const m = YAML.parse(data);
-    if (!m?.ctx) {
-        throw new Error(`provide a ctx param in models file`);
-    }
-    if (!m?.max_tokens) {
-        throw new Error(`provide a max_tokens param in models file`);
-    }
-    const ctx = m.ctx;
-    const max_tokens = m.max_tokens;
-    delete m.ctx;
-    delete m.max_tokens;
-    return { models: m, ctx: ctx, max_tokens: max_tokens, found: true };
-}
-export { readModelsFile, };