@agent-smith/cli 0.0.44 → 0.0.45

package/dist/cmd/clicmds/cmds.js

@@ -1,8 +1,8 @@
 import YAML from 'yaml';
-import { formatMode, isChatMode, promptfilePath, runMode } from "../../state/state.js";
+import { dataDirPath, formatMode, isChatMode, promptfilePath, runMode } from "../../state/state.js";
 import { getFeatureSpec, readFeaturesDirs } from "../../state/features.js";
 import { readAliases, readFeatures } from "../../db/read.js";
-import { cleanupFeaturePaths, updateAliases, updateFeatures, updatePromptfilePath } from "../../db/write.js";
+import { cleanupFeaturePaths, updateAliases, updateDataDirPath, updateFeatures, updatePromptfilePath } from "../../db/write.js";
 import { processConfPath } from "../../conf.js";
 import { executeActionCmd } from "../lib/actions/cmd.js";
 import { initAgent, marked, taskBuilder } from "../../agent.js";
@@ -10,7 +10,7 @@ import { executeTaskCmd } from "../lib/tasks/cmd.js";
 import { readCmds } from "../sys/read_cmds.js";
 import { executeWorkflowCmd } from "../lib/workflows/cmd.js";
 import { readTask } from "../sys/read_task.js";
-import { deleteFileIfExists } from "../sys/reset.js";
+import { deleteFileIfExists } from "../sys/delete_file.js";
 import { dbPath } from "../../db/db.js";
 let cmds = {
     exit: {
@@ -82,11 +82,15 @@ async function _updateConfCmd(args = [], options) {
         console.warn("Provide a config.yml file path");
         return;
     }
-    const { paths, pf } = await processConfPath(args[0]);
+    const { paths, pf, dd } = await processConfPath(args[0]);
     if (pf.length > 0) {
         updatePromptfilePath(pf);
         promptfilePath.value = pf;
     }
+    if (dd.length > 0) {
+        updateDataDirPath(dd);
+        dataDirPath.value = dd;
+    }
     const feats = readFeaturesDirs(paths);
     updateFeatures(feats);
     updateAliases(feats);
@@ -147,6 +151,7 @@ async function _readTaskCmd(args = [], options) {
     console.log(YAML.stringify(ts));
 }
 async function _listTasksCmd(args = [], options) {
-    Object.keys(readFeatures().task).forEach((t) => console.log("-", t));
+    const ts = Object.keys(readFeatures().task).sort();
+    console.table(ts);
 }
 export { cmds, initCmds, pingCmd, initAliases };

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

@@ -80,7 +80,9 @@ async function executeActionCmd(args = [], options = {}, quiet = false) {
         throw res.error;
     }
     if (!quiet) {
-        console.log(res);
+        if (res) {
+            console.log(res);
+        }
     }
     await processOutput(res);
     return res;

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

@@ -0,0 +1,2 @@
+declare function updateModels(): void;
+export { updateModels, };

package/dist/cmd/lib/models.js

@@ -0,0 +1,35 @@
+import path from "path";
+import { readModelfiles } from "../../db/read.js";
+import { readModelsFile } from "../sys/read_modelfile.js";
+import { upsertModels } from "../../db/write.js";
+function updateModels() {
+    const mfs = readModelfiles();
+    const modelNames = new Array();
+    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 (modelNames.includes(m.name)) {
+                console.log("🔴 [models] error: duplicate model name", m.name, "found in", filePath);
+                continue;
+            }
+            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);
+        }
+        upsertModels(modelDefs);
+    });
+}
+export { updateModels, };

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

@@ -1,3 +1,3 @@
-import { LmTaskOutput } from "../../../../../lmtask/dist/main.js";
-declare function executeTaskCmd(args?: Array<string> | Record<string, any>, options?: any): Promise<LmTaskOutput>;
+import { LmTaskOutput } from "@agent-smith/lmtask";
+declare function executeTaskCmd(args?: Array<string> | Record<string, any>, options?: Record<string, any>): Promise<LmTaskOutput>;
 export { executeTaskCmd };

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

@@ -1,13 +1,14 @@
+import { compile, serializeGrammar } from "@intrinsicai/gbnfgen";
+import YAML from 'yaml';
 import { brain, initAgent, taskBuilder } from "../../../agent.js";
 import { getFeatureSpec } from "../../../state/features.js";
 import { isChatMode, isDebug, isShowTokens, isVerbose } from "../../../state/state.js";
-import { formatStats, initTaskConf, initTaskParams, initTaskVars, parseInputOptions } from "../utils.js";
+import { formatStats, parseInputOptions } from "../utils.js";
 import { readTask } from "../../sys/read_task.js";
-import { readFeature, readTool } from "../../../db/read.js";
-import { LmTaskBuilder } from "../../../../../lmtask/dist/main.js";
+import { readTool } from "../../../db/read.js";
 import { executeActionCmd, } from "../actions/cmd.js";
 import { executeWorkflowCmd } from "../workflows/cmd.js";
-import { readModelsFile } from "../../../cmd/sys/read_models.js";
+import { configureTask, parseTaskVars } from "./conf.js";
 async function executeTaskCmd(args = [], options = {}) {
     await initAgent();
     if (isDebug.value) {
@@ -53,48 +54,20 @@ async function executeTaskCmd(args = [], options = {}) {
     if (!res.found) {
         throw new Error(`Task ${name}, ${path} not found`);
     }
-    const taskRawSpec = taskBuilder.readSpecFromYaml(res.ymlTask);
-    let taskSpec;
-    let defaultCtx;
-    if (taskRawSpec?.modelset) {
-        const modelsFeat = readFeature(taskRawSpec.modelset.name, "modelset");
-        if (!modelsFeat.found) {
-            throw new Error(`modelset feature ${taskRawSpec.modelset.name} not found in conf db`);
-        }
-        const { found, ctx, max_tokens, models } = readModelsFile(modelsFeat.feature.path + "/" + modelsFeat.feature.name + "." + modelsFeat.feature.ext);
-        if (!found) {
-            throw new Error(`modelset ${taskRawSpec.modelset.name} not found`);
-        }
-        defaultCtx = ctx;
-        for (const [k, v] of Object.entries(models)) {
-            if (!v?.ctx) {
-                v.ctx = ctx;
-                models[k] = v;
-            }
-        }
-        taskRawSpec.model = models[taskRawSpec.modelset.default];
-        if (!taskRawSpec.model) {
-            throw new Error(`model ${taskRawSpec.modelset.default} not found`);
-        }
-        if (!taskRawSpec.model?.ctx) {
-            taskRawSpec.model.ctx = ctx;
-        }
-        if (!taskRawSpec?.inferParams?.max_tokens) {
-            if (!taskRawSpec?.inferParams) {
-                taskRawSpec.inferParams = {};
-            }
-            taskRawSpec.inferParams.max_tokens = max_tokens;
-        }
-        taskRawSpec.models = models;
-        taskSpec = LmTaskBuilder.fromRawSpec(taskRawSpec);
+    const taskFileSpec = YAML.parse(res.ymlTask);
+    let conf = {};
+    let vars = {};
+    if (!isWorkflow) {
+        const tv = parseTaskVars(args, taskFileSpec?.inferParams ? taskFileSpec.inferParams : {});
+        vars = tv.vars;
+        conf = configureTask(tv.conf, taskFileSpec);
     }
     else {
-        taskSpec = taskRawSpec;
-        if (!taskSpec.model?.ctx) {
-            throw new Error(`provide a ctx parameter in the task default model`);
-        }
-        defaultCtx = taskSpec.model.ctx;
+        const tv = parseTaskVars({ name: name, prompt: pr, ...args }, taskFileSpec?.inferParams ? taskFileSpec.inferParams : {});
+        vars = tv.vars;
+        conf = configureTask(tv.conf, taskFileSpec);
     }
+    const taskSpec = taskFileSpec;
     if (taskSpec.toolsList) {
         taskSpec.tools = [];
         for (const toolName of taskSpec.toolsList) {
@@ -127,19 +100,10 @@ async function executeTaskCmd(args = [], options = {}) {
     }
     ;
     const task = taskBuilder.init(taskSpec);
-    let conf = {};
-    let vars = {};
-    if (!isWorkflow) {
-        const tv = initTaskVars(args, taskSpec?.inferParams ? taskSpec.inferParams : {});
-        conf = tv.conf;
-        vars = tv.vars;
+    if (conf?.inferParams?.tsGrammar) {
+        conf.inferParams.grammar = serializeGrammar(await compile(conf.inferParams.tsGrammar, "Grammar"));
+        delete conf.inferParams.tsGrammar;
     }
-    else {
-        const tv = initTaskParams({ name: name, prompt: pr, ...args }, taskSpec?.inferParams ? taskSpec.inferParams : {});
-        conf = tv.conf;
-        vars = tv.vars;
-    }
-    conf = initTaskConf(conf, taskSpec, defaultCtx);
     if (isDebug.value) {
         console.log("Task conf:", conf);
         console.log("Task vars:", vars);
@@ -151,15 +115,20 @@ async function executeTaskCmd(args = [], options = {}) {
     ex.checkStatus();
     let i = 0;
     let c = false;
-    ex.backend.setOnToken((t) => {
-        let txt = t;
-        if (isShowTokens.value) {
-            txt = c ? t : `\x1b[100m${t}\x1b[0m`;
-        }
-        process.stdout.write(txt);
-        ++i;
-        c = !c;
-    });
+    if (options?.onToken) {
+        ex.backend.setOnToken(options.onToken);
+    }
+    else {
+        ex.backend.setOnToken((t) => {
+            let txt = t;
+            if (isShowTokens.value) {
+                txt = c ? t : `\x1b[100m${t}\x1b[0m`;
+            }
+            process.stdout.write(txt);
+            ++i;
+            c = !c;
+        });
+    }
     conf.expert = ex;
     if (isDebug.value || isVerbose.value) {
         conf.debug = true;

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

@@ -0,0 +1,7 @@
+import { LmTaskConfig, FinalLmTaskConfig, LmTaskFileSpec } from "../../../interfaces.js";
+declare function configureTask(itConf: LmTaskConfig, taskSpec: LmTaskFileSpec): FinalLmTaskConfig;
+declare function parseTaskVars(params: Array<any> | Record<string, any>, inferParams: Record<string, any>): {
+    conf: LmTaskConfig;
+    vars: Record<string, any>;
+};
+export { parseTaskVars, configureTask, };

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

@@ -0,0 +1,144 @@
+import { readModel } from "../../../db/read.js";
+function configureTask(itConf, taskSpec) {
+    const _conf = {};
+    let modelName = "";
+    let templateName = "";
+    let ip = itConf.inferParams;
+    let isModelFromTaskFile = false;
+    let model = {};
+    let found = false;
+    if (itConf?.templateName) {
+        templateName = itConf.templateName;
+    }
+    if (!itConf?.modelname) {
+        if (taskSpec?.model?.name) {
+            model = taskSpec.model;
+            isModelFromTaskFile = true;
+            found = true;
+        }
+        else {
+            if (!taskSpec?.modelpack) {
+                throw new Error("provide a default model or a use a modelpack in the task definition");
+            }
+            modelName = taskSpec.modelpack.default;
+        }
+    }
+    else {
+        modelName = itConf.modelname;
+    }
+    if (!found) {
+        if (modelName.length == 0) {
+            throw new Error("no model name defined");
+        }
+        if (taskSpec?.models) {
+            for (const [k, v] of Object.entries(taskSpec.models)) {
+                if (modelName == k) {
+                    model = v;
+                    if (v?.inferParams) {
+                        const tip = v.inferParams;
+                        for (const [k, v] of Object.entries(tip)) {
+                            ip[k] = v;
+                        }
+                    }
+                    if (v?.system) {
+                        model.system = v.system;
+                    }
+                    if (v.assistant) {
+                        model.assistant = v.assistant;
+                    }
+                    isModelFromTaskFile = true;
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if (!found) {
+            const m = readModel(modelName);
+            if (m.found) {
+                model = m.modelData;
+                found = true;
+            }
+        }
+    }
+    if (found) {
+        model.inferParams = ip;
+        if (!model?.ctx || !isModelFromTaskFile) {
+            model.ctx = taskSpec.ctx;
+        }
+        _conf.model = model;
+        _conf.model.inferParams = ip;
+        if (templateName.length > 0) {
+            _conf.model.template = templateName;
+        }
+    }
+    else {
+        _conf.modelname = modelName;
+    }
+    return _conf;
+}
+function parseTaskVars(params, inferParams) {
+    switch (Array.isArray(params)) {
+        case true:
+            return _initTaskVars(params, inferParams);
+        default:
+            return _initTaskParams(params, inferParams);
+    }
+}
+function _initTaskParams(params, inferParams) {
+    const conf = { inferParams: inferParams, modelname: "", templateName: "" };
+    if (!params?.prompt) {
+        throw new Error(`Error initializing task params: provide a prompt`);
+    }
+    if (params?.images) {
+        conf.inferParams.images = params.images;
+        delete params.images;
+    }
+    if (params?.model) {
+        conf.modelname = params.model;
+        delete params.model;
+    }
+    if (params?.template) {
+        conf.templateName = params.template;
+        delete params.template;
+    }
+    const res = { conf: conf, vars: params };
+    return res;
+}
+function _initTaskVars(args, inferParams) {
+    const conf = { inferParams: inferParams, modelname: "", templateName: "" };
+    const vars = {};
+    args.forEach((a) => {
+        if (a.includes("=")) {
+            const delimiter = "=";
+            const [k, v] = a.split(delimiter, 2);
+            if (v === undefined) {
+                throw new Error(`invalid parameter ${a}`);
+            }
+            switch (k) {
+                case "m":
+                    if (v.includes("/")) {
+                        const _s = v.split("/");
+                        conf.modelname = _s[0];
+                        conf.templateName = _s[1];
+                    }
+                    else {
+                        conf.modelname = v;
+                    }
+                    break;
+                case "ip":
+                    v.split(",").forEach((p) => {
+                        const s = p.split(":");
+                        const cip = conf.inferParams;
+                        cip[s[0]] = parseFloat(s[1]);
+                        conf.inferParams = cip;
+                    });
+                    break;
+                default:
+                    vars[k] = v;
+                    break;
+            }
+        }
+    });
+    return { conf, vars };
+}
+export { parseTaskVars, configureTask, };

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

@@ -1,18 +1,7 @@
-import { LmTask } from "@agent-smith/lmtask";
 import { InferenceStats } from "@locallm/types/dist/interfaces.js";
 declare function setOptions(args: Array<string> | undefined, options: Record<string, any>): Promise<Array<string>>;
 declare function readPromptFile(): string;
 declare function processOutput(res: any): Promise<void>;
-declare function initTaskConf(conf: Record<string, any>, taskSpec: LmTask, defaultCtx: number): Record<string, any>;
-declare function initTaskParams(params: Record<string, any>, inferParams: Record<string, any>): {
-    conf: Record<string, any>;
-    vars: Record<string, any>;
-};
-declare function initActionVars(args: Array<any>): Record<string, any>;
-declare function initTaskVars(args: Array<any>, inferParams: Record<string, any>): {
-    conf: Record<string, any>;
-    vars: Record<string, any>;
-};
 declare function parseInputOptions(options: any): Promise<string | null>;
 declare function formatStats(stats: InferenceStats): string;
-export { initTaskConf, initTaskParams, initTaskVars, initActionVars, parseInputOptions, processOutput, readPromptFile, setOptions, formatStats, };
+export { parseInputOptions, processOutput, readPromptFile, setOptions, formatStats, };

package/dist/cmd/lib/utils.js

@@ -34,9 +34,12 @@ async function processOutput(res) {
     }
     let data = "";
     if (typeof res == "object") {
-        if (res?.answer && res?.stats) {
+        if (res?.answer?.text) {
             data = res.answer.text;
         }
+        else {
+            data = JSON.stringify(res);
+        }
     }
     else {
         data = res;
@@ -48,171 +51,6 @@ async function processOutput(res) {
         await writeToClipboard(data);
     }
 }
-function initTaskConf(conf, taskSpec, defaultCtx) {
-    const _conf = conf;
-    let m = taskSpec.model.name;
-    let t = taskSpec.model.template;
-    let c = taskSpec.model?.ctx ?? defaultCtx;
-    let ip = conf.inferParams;
-    let system = taskSpec.model?.system;
-    let assistant = taskSpec.model?.assistant;
-    if (conf?.model) {
-        m = conf.model;
-        if (conf?.template) {
-            t = conf.template;
-        }
-        else {
-            const gt = tfm.guess(m);
-            if (gt == "none") {
-                throw new Error(`Unable to guess the template for ${m}: please provide a template name"`);
-            }
-            t = gt;
-        }
-    }
-    else {
-        if (conf?.size) {
-            if (!taskSpec?.models) {
-                throw new Error(`Model ${conf.size} not found in task`);
-            }
-            if (!Object.keys(taskSpec.models).includes(conf.size)) {
-                throw new Error(`Model ${conf.size} not found in task`);
-            }
-            m = taskSpec.models[conf.size].name;
-            t = taskSpec.models[conf.size].template;
-            c = taskSpec.models[conf.size]?.ctx ?? defaultCtx;
-            if (taskSpec.models[conf.size]?.inferParams) {
-                const tip = taskSpec.models[conf.size].inferParams;
-                for (const [k, v] of Object.entries(tip)) {
-                    ip[k] = v;
-                }
-            }
-            system = taskSpec.models[conf.size]?.system;
-            assistant = taskSpec.models[conf.size]?.assistant;
-        }
-    }
-    _conf.model = {
-        name: m,
-        template: t,
-        ctx: c,
-    };
-    if (system) {
-        _conf.model.system = system;
-    }
-    if (assistant) {
-        _conf.model.assistant = assistant;
-    }
-    _conf.inferParams = ip;
-    if (_conf?.template) {
-        delete conf.template;
-    }
-    return _conf;
-}
-function initTaskParams(params, inferParams) {
-    const conf = { inferParams: inferParams };
-    if (!params?.prompt) {
-        throw new Error(`Error initializing task params: provide a prompt`);
-    }
-    if (params?.images) {
-        conf.inferParams.images = params.images;
-        delete params.images;
-    }
-    if (params?.size) {
-        conf.size = params.size;
-        delete params.size;
-    }
-    if (params?.model) {
-        conf.model = params.model;
-        delete params.model;
-    }
-    if (params?.template) {
-        conf.template = params.template;
-        delete params.template;
-    }
-    const res = { conf: conf, vars: params };
-    return res;
-}
-function initActionVars(args) {
-    const vars = {};
-    args.forEach((a) => {
-        if (a.includes("=")) {
-            const t = a.split("=");
-            const k = t[0];
-            const v = t[1];
-            switch (k) {
-                case "m":
-                    if (v.includes("/")) {
-                        const _s = v.split("/");
-                        vars.model = _s[0];
-                        vars.template = _s[1];
-                    }
-                    else {
-                        vars.model = v;
-                    }
-                    break;
-                case "ip":
-                    v.split(",").forEach((p) => {
-                        const s = p.split(":");
-                        vars["inferParams"][s[0]] = parseFloat(s[1]);
-                    });
-                    break;
-                case "s":
-                    vars.size = v;
-                    break;
-                default:
-                    vars[k] = v;
-                    break;
-            }
-        }
-    });
-    return { vars };
-}
-function initTaskVars(args, inferParams) {
-    const conf = { inferParams: inferParams };
-    const vars = {};
-    args.forEach((a) => {
-        if (a.includes("=")) {
-            const delimiter = "=";
-            const firstDelimiterIndex = a.indexOf(delimiter);
-            let t = new Array();
-            if (firstDelimiterIndex !== -1) {
-                t = [
-                    a.slice(0, firstDelimiterIndex),
-                    a.slice(firstDelimiterIndex + 1)
-                ];
-            }
-            else {
-                t = [a];
-            }
-            const k = t[0];
-            const v = t[1];
-            switch (k) {
-                case "m":
-                    if (v.includes("/")) {
-                        const _s = v.split("/");
-                        conf.model = _s[0];
-                        conf.template = _s[1];
-                    }
-                    else {
-                        conf.model = v;
-                    }
-                    break;
-                case "ip":
-                    v.split(",").forEach((p) => {
-                        const s = p.split(":");
-                        conf["inferParams"][s[0]] = parseFloat(s[1]);
-                    });
-                    break;
-                case "s":
-                    conf.size = v;
-                    break;
-                default:
-                    vars[k] = v;
-                    break;
-            }
-        }
-    });
-    return { conf, vars };
-}
 async function parseInputOptions(options) {
     let out = null;
     if (options?.Ic == true || inputMode.value == "clipboard") {
@@ -231,4 +69,4 @@ function formatStats(stats) {
     buf.push(`${stats.inferenceTimeSeconds}s inference)`);
     return buf.join(" ");
 }
-export { initTaskConf, initTaskParams, initTaskVars, initActionVars, parseInputOptions, processOutput, readPromptFile, setOptions, formatStats, };
+export { parseInputOptions, processOutput, readPromptFile, setOptions, formatStats, };

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

@@ -0,0 +1,2 @@
+declare function createDirectoryIfNotExists(dirPath: string, recursive?: boolean): void;
+export { createDirectoryIfNotExists };

package/dist/cmd/sys/dirs.js

@@ -0,0 +1,9 @@
+import * as fs from 'fs';
+import * as path from 'path';
+function createDirectoryIfNotExists(dirPath, recursive = false) {
+    const resolvedDirPath = path.resolve(dirPath);
+    if (!fs.existsSync(resolvedDirPath)) {
+        fs.mkdirSync(resolvedDirPath, { recursive: recursive });
+    }
+}
+export { createDirectoryIfNotExists };

package/dist/cmd/sys/read_cmds.js

@@ -19,6 +19,9 @@ async function readCmds(dir) {
     const fileNames = _readCmdsDir(dir);
     for (const name of fileNames) {
         const { cmd } = await import(path.join(dir, name + ".js"));
+        if (!cmd) {
+            throw new Error(`command ${name} not found in ${dir}`);
+        }
         cmds[name] = cmd;
     }
     return cmds;

package/dist/cmd/sys/read_features.js

@@ -22,7 +22,7 @@ function readFeaturesDir(dir) {
         cmd: [],
         workflow: [],
         adaptater: [],
-        modelset: []
+        modelfile: []
     };
     let dirpath = path.join(dir, "tasks");
     if (fs.existsSync(dirpath)) {
@@ -101,7 +101,7 @@ function readFeaturesDir(dir) {
             const parts = filename.split(".");
             const ext = parts.pop();
             const name = parts.join("");
-            feats.modelset.push({
+            feats.modelfile.push({
                 name: name,
                 path: path.join(dirpath),
                 ext: ext,

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

@@ -0,0 +1,8 @@
+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_models.js → read_modelfile.js}

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

package/dist/conf.d.ts

@@ -4,5 +4,6 @@ declare function createConfDirIfNotExists(): boolean;
 declare function processConfPath(confPath: string): Promise<{
     paths: Array<string>;
     pf: string;
+    dd: string;
 }>;
 export { confDir, dbPath, createConfDirIfNotExists, processConfPath, };

package/dist/conf.js

@@ -36,9 +36,13 @@ async function processConfPath(confPath) {
         });
     }
     let pf = "";
-    if (data.promptfile) {
+    if (data?.promptfile) {
         pf = data.promptfile;
     }
-    return { paths: allPaths, pf: pf };
+    let dd = "";
+    if (data?.datadir) {
+        dd = data.datadir;
+    }
+    return { paths: allPaths, pf: pf, dd: dd };
 }
 export { confDir, dbPath, createConfDirIfNotExists, processConfPath, };

package/dist/db/read.d.ts

@@ -1,5 +1,5 @@
 import { ToolSpec } from "modprompt";
-import { AliasType, FeatureSpec, FeatureType, ToolType } from "../interfaces.js";
+import { AliasType, FeatureSpec, FeatureType, DbModelDef, ToolType } from "../interfaces.js";
 declare function readFeaturePaths(): Array<string>;
 declare function readPlugins(): Array<Record<string, string>>;
 declare function readFeatures(): Record<FeatureType, Record<string, string>>;
@@ -16,5 +16,14 @@ declare function readTool(name: string): {
     tool: ToolSpec;
     type: ToolType;
 };
-declare function readPromptFilePath(): string;
-export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readPromptFilePath, readTool, };
+declare function readFilePaths(): Array<{
+    name: string;
+    path: string;
+}>;
+declare function readModelfiles(): Array<Record<string, string>>;
+declare function readModels(): Array<DbModelDef>;
+declare function readModel(shortname: string): {
+    found: boolean;
+    modelData: Record<string, any>;
+};
+export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readFilePaths, readTool, readModels, readModelfiles, readModel, };

package/dist/db/read.js

@@ -27,13 +27,15 @@ function _readFeaturesType(type) {
     return f;
 }
 function readFeatures() {
-    const feats = { task: {}, action: {}, cmd: {}, workflow: {}, adaptater: {}, modelset: {} };
+    const feats = {
+        task: {}, action: {}, cmd: {}, workflow: {}, adaptater: {}, modelfile: {}
+    };
     feats.task = _readFeaturesType("task");
     feats.action = _readFeaturesType("action");
     feats.cmd = _readFeaturesType("cmd");
     feats.workflow = _readFeaturesType("workflow");
     feats.adaptater = _readFeaturesType("adaptater");
-    feats.modelset = _readFeaturesType("modelset");
+    feats.modelfile = _readFeaturesType("modelfile");
     return feats;
 }
 function readAliases() {
@@ -76,13 +78,41 @@ function readTool(name) {
     }
     return { found: false, tool: {}, type: "action" };
 }
-function readPromptFilePath() {
-    const stmt1 = db.prepare("SELECT * FROM filepath WHERE name = ?");
-    const result = stmt1.get("promptfile");
-    let res = "";
+function readFilePaths() {
+    const stmt1 = db.prepare("SELECT name, path FROM filepath");
+    const data = stmt1.all();
+    let f = new Array();
+    data.forEach((row) => {
+        f.push({ name: row.name, path: row.path });
+    });
+    return f;
+}
+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) => {
+        f.push(row);
+    });
+    return f;
+}
+function readModel(shortname) {
+    const q = `SELECT id, data FROM model WHERE shortname='${shortname}'`;
+    const stmt = db.prepare(q);
+    const result = stmt.get();
     if (result?.id) {
-        res = result.path;
+        const data = JSON.parse(result.data);
+        return { found: true, modelData: data };
     }
-    return res;
+    return { found: false, modelData: {} };
 }
-export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readPromptFilePath, readTool, };
+export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readFilePaths, readTool, readModels, readModelfiles, readModel, };

package/dist/db/schemas.js

@@ -53,12 +53,18 @@ const alias = `CREATE TABLE IF NOT EXISTS aliases (
     name TEXT UNIQUE NOT NULL,
     type TEXT NOT NULL CHECK ( type IN ('task', 'action', 'workflow') )
 );`;
-const model = `CREATE TABLE IF NOT EXISTS modelset (
+const modelfile = `CREATE TABLE IF NOT EXISTS modelfile (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
     path TEXT NOT NULL,
     ext TEXT NOT NULL CHECK ( ext IN ('yml') )
 );`;
+const model = `CREATE TABLE IF NOT EXISTS model (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    name TEXT UNIQUE NOT NULL,
+    shortname TEXT UNIQUE NOT NULL,
+    data TEXT NOT NULL
+);`;
 const schemas = [
     filepath,
     featurespath,
@@ -70,6 +76,7 @@ const schemas = [
     plugin,
     alias,
     model,
+    modelfile,
     adaptater,
 ];
 export { schemas };

package/dist/db/write.d.ts

@@ -1,8 +1,10 @@
-import { Features } from "../interfaces.js";
+import { Features, DbModelDef } from "../interfaces.js";
 declare function updatePromptfilePath(pf: string): void;
+declare function updateDataDirPath(dd: string): void;
 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 upsertModels(models: Array<DbModelDef>): void;
 declare function updateFeatures(feats: Features): void;
-export { updatePromptfilePath, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, };
+export { updatePromptfilePath, updateDataDirPath, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, upsertModels, };

package/dist/db/write.js

@@ -6,6 +6,12 @@ function updatePromptfilePath(pf) {
     const stmt = db.prepare("INSERT INTO filepath (name, path) VALUES (?, ?)");
     stmt.run("promptfile", pf);
 }
+function updateDataDirPath(dd) {
+    const deleteStmt = db.prepare("DELETE FROM filepath WHERE name = ?");
+    deleteStmt.run("datadir");
+    const stmt = db.prepare("INSERT INTO filepath (name, path) VALUES (?, ?)");
+    stmt.run("datadir", dd);
+}
 function insertFeaturesPathIfNotExists(path) {
     const stmt1 = db.prepare("SELECT * FROM featurespath WHERE path = ?");
     const result = stmt1.get(path);
@@ -104,6 +110,29 @@ function upsertTool(name, type, toolDoc) {
     stmt.run(name, toolDoc, type);
     console.log("+", "[tool] from", type, ":", name);
 }
+function upsertModels(models) {
+    const stmt1 = db.prepare("SELECT shortname FROM model");
+    const rows = stmt1.all();
+    const existingModelShortNames = rows.map(row => row.shortname);
+    const stmt = db.prepare(`INSERT INTO model (name, shortname, data) VALUES (?,?,?)`);
+    existingModelShortNames.forEach((name) => {
+        if (!existingModelShortNames.includes(name)) {
+            const deleteStmt = db.prepare("DELETE FROM model WHERE name = ?");
+            deleteStmt.run(name);
+            console.log("-", "[model]", name);
+        }
+    });
+    db.transaction(() => {
+        for (const model of models) {
+            const stmt1 = db.prepare("SELECT * FROM model WHERE shortname = ?");
+            const result = stmt1.get(model.shortname);
+            if (result?.id) {
+                continue;
+            }
+            stmt.run(model.name, model.shortname, JSON.stringify(model.data));
+        }
+    })();
+}
 function updateFeatures(feats) {
     upsertAndCleanFeatures(feats.task, "task");
     const newActions = upsertAndCleanFeatures(feats.action, "action");
@@ -118,6 +147,6 @@ function updateFeatures(feats) {
     upsertAndCleanFeatures(feats.cmd, "cmd");
     upsertAndCleanFeatures(feats.workflow, "workflow");
     upsertAndCleanFeatures(feats.adaptater, "adaptater");
-    upsertAndCleanFeatures(feats.modelset, "modelset");
+    upsertAndCleanFeatures(feats.modelfile, "modelfile");
 }
-export { updatePromptfilePath, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, };
+export { updatePromptfilePath, updateDataDirPath, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, upsertModels, };

package/dist/interfaces.d.ts

@@ -1,9 +1,12 @@
+import { BaseLmTask, ModelSpec } from "@agent-smith/lmtask";
+import { InferenceParams } from "@locallm/types";
 interface Cmd {
     cmd: CmdExecutor;
     description: string;
     args?: string;
 }
 interface FeatureSpec {
+    id?: number;
     name: string;
     path: string;
     ext: FeatureExtension;
@@ -34,14 +37,15 @@ interface Features {
         path: string;
         ext: AdaptaterExtension;
     }>;
-    modelset: Array<{
+    modelfile: Array<{
         name: string;
         path: string;
-        ext: ModelsetExtension;
+        ext: ModelFileExtension;
     }>;
 }
 interface ConfigFile {
     promptfile?: string;
+    datadir?: string;
     features?: Array<string>;
     plugins?: Array<string>;
 }
@@ -56,19 +60,50 @@ interface Settings {
     isverbose: boolean;
     promptfile: string;
 }
+interface DbModelDef {
+    id?: number;
+    name: string;
+    shortname: string;
+    data: Record<string, any>;
+}
+interface ModelfileSpec {
+    ctx: number;
+    max_tokens: number;
+    models: Array<ModelSpec>;
+}
+interface ModelPack {
+    default: string;
+    recommended?: Array<string>;
+}
+interface LmTaskFileSpec extends BaseLmTask {
+    ctx: number;
+    model?: ModelSpec;
+    modelpack?: ModelPack;
+}
+interface BaseLmTaskConfig {
+    templateName: string;
+    inferParams: InferenceParams;
+}
+interface LmTaskConfig extends BaseLmTaskConfig {
+    modelname?: string;
+}
+interface FinalLmTaskConfig {
+    model?: ModelSpec;
+    modelname?: string;
+}
 type CmdExecutor = (args: Array<string>, options: any) => Promise<any>;
 type InputMode = "manual" | "promptfile" | "clipboard";
 type OutputMode = "txt" | "clipboard";
 type RunMode = "cli" | "cmd";
 type FormatMode = "text" | "markdown";
-type FeatureType = "task" | "action" | "cmd" | "workflow" | "adaptater" | "modelset";
+type FeatureType = "task" | "action" | "cmd" | "workflow" | "adaptater" | "modelfile";
 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 ModelsetExtension = "yml";
-type FeatureExtension = TaskExtension | CmdExtension | ActionExtension | WorkflowExtension;
+type ModelFileExtension = "yml";
+type FeatureExtension = TaskExtension | CmdExtension | ActionExtension | WorkflowExtension | ModelFileExtension;
 type AliasType = "task" | "action" | "workflow";
-export { Cmd, CmdExecutor, InputMode, OutputMode, RunMode, FormatMode, FeatureType, ActionExtension, TaskExtension, WorkflowExtension, AdaptaterExtension, CmdExtension, ModelsetExtension, FeatureSpec, Features, ConfigFile, FeatureExtension, AliasType, ToolType, Settings, };
+export { Cmd, CmdExecutor, InputMode, OutputMode, RunMode, FormatMode, FeatureType, ActionExtension, TaskExtension, WorkflowExtension, AdaptaterExtension, CmdExtension, ModelFileExtension, FeatureSpec, Features, ConfigFile, FeatureExtension, AliasType, ToolType, Settings, DbModelDef, ModelSpec, ModelfileSpec, ModelPack, LmTaskFileSpec, LmTaskConfig, FinalLmTaskConfig, };

package/dist/main.d.ts

@@ -5,5 +5,9 @@ import { executeWorkflowCmd } from "./cmd/lib/workflows/cmd.js";
 import { writeToClipboard } from "./cmd/sys/clipboard.js";
 import { pingCmd } from "./cmd/clicmds/cmds.js";
 import { initAgent } from "./agent.js";
-import { initState } from "./state/state.js";
-export { execute, run, pingCmd, executeWorkflowCmd, executeActionCmd, executeTaskCmd, writeToClipboard, initAgent, initState, };
+import { initState, pluginDataDir } from "./state/state.js";
+import { usePerfTimer } from "./primitives/perf.js";
+import { parseInferenceArgs } from "./primitives/args.js";
+import { parseTaskVars } from "./cmd/lib/tasks/conf.js";
+import { LmTaskConf } from "@agent-smith/lmtask/dist/interfaces.js";
+export { execute, run, pingCmd, executeWorkflowCmd, executeActionCmd, executeTaskCmd, writeToClipboard, initAgent, initState, pluginDataDir, usePerfTimer, parseInferenceArgs, parseTaskVars, LmTaskConf, };

package/dist/main.js

@@ -5,5 +5,8 @@ import { executeWorkflowCmd } from "./cmd/lib/workflows/cmd.js";
 import { writeToClipboard } from "./cmd/sys/clipboard.js";
 import { pingCmd } from "./cmd/clicmds/cmds.js";
 import { initAgent } from "./agent.js";
-import { initState } from "./state/state.js";
-export { execute, run, pingCmd, executeWorkflowCmd, executeActionCmd, executeTaskCmd, writeToClipboard, initAgent, initState, };
+import { initState, pluginDataDir } from "./state/state.js";
+import { usePerfTimer } from "./primitives/perf.js";
+import { parseInferenceArgs } from "./primitives/args.js";
+import { parseTaskVars } from "./cmd/lib/tasks/conf.js";
+export { execute, run, pingCmd, executeWorkflowCmd, executeActionCmd, executeTaskCmd, writeToClipboard, initAgent, initState, pluginDataDir, usePerfTimer, parseInferenceArgs, parseTaskVars, };

package/dist/primitives/args.d.ts

@@ -0,0 +1,5 @@
+declare function parseInferenceArgs(args: Array<string>): {
+    inferenceVars: Record<string, any>;
+    currentArgs: Array<string>;
+};
+export { parseInferenceArgs, };

package/dist/primitives/args.js

@@ -0,0 +1,40 @@
+function parseInferenceArgs(args) {
+    const vars = {};
+    const nargs = new Array();
+    args.forEach((a) => {
+        if (a.includes("=")) {
+            const t = a.split("=");
+            const k = t[0];
+            const v = t[1];
+            switch (k) {
+                case "m":
+                    if (v.includes("/")) {
+                        const _s = v.split("/");
+                        vars.model = _s[0];
+                        vars.template = _s[1];
+                    }
+                    else {
+                        vars.model = v;
+                    }
+                    break;
+                case "ip":
+                    v.split(",").forEach((p) => {
+                        const s = p.split(":");
+                        vars["inferParams"][s[0]] = parseFloat(s[1]);
+                    });
+                    break;
+                case "s":
+                    vars.size = v;
+                    break;
+                default:
+                    vars[k] = v;
+                    break;
+            }
+        }
+        else {
+            nargs.push(a);
+        }
+    });
+    return { inferenceVars: vars, currentArgs: nargs };
+}
+export { parseInferenceArgs, };

package/dist/primitives/perf.d.ts

@@ -0,0 +1,7 @@
+declare const usePerfTimer: (startTimer?: boolean) => {
+    start: () => number;
+    time: () => string | number;
+    timeRaw: () => string | number;
+    printTime: () => void;
+};
+export { usePerfTimer };

package/dist/primitives/perf.js

@@ -0,0 +1,38 @@
+const usePerfTimer = (startTimer = true) => {
+    let _startTime;
+    if (startTimer) {
+        _startTime = performance.now();
+    }
+    const start = () => _startTime = performance.now();
+    const _end = (raw) => {
+        if (!_startTime) {
+            throw new Error("the timer has not started, can not end it");
+        }
+        const endTime = performance.now();
+        const duration = endTime - _startTime;
+        if (raw) {
+            return duration;
+        }
+        const humanizedTime = _formatDuration(duration);
+        return humanizedTime;
+    };
+    const time = () => _end(false);
+    const printTime = () => console.log(_end(false));
+    const timeRaw = () => _end(true);
+    const _formatDuration = (ms) => {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        if (ms < 1000)
+            return `${ms.toFixed(2)}ms`;
+        if (seconds < 60)
+            return `${seconds.toFixed(2)}s`;
+        return `${minutes}m ${seconds % 60}s`;
+    };
+    return {
+        start,
+        time,
+        timeRaw,
+        printTime,
+    };
+};
+export { usePerfTimer };

package/dist/state/chat.d.ts

@@ -19,6 +19,8 @@ declare const chatInferenceParams: {
     tfs?: number | undefined;
     stop?: Array<string> | undefined;
     grammar?: string | undefined;
+    tsGrammar?: string | undefined;
+    schema?: Record<string, any> | undefined;
     images?: Array<string> | undefined;
     extra?: Record<string, any> | undefined;
 };

package/dist/state/features.js

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

package/dist/state/state.d.ts

@@ -10,10 +10,12 @@ declare const isDebug: import("@vue/reactivity").Ref<boolean, boolean>;
 declare const isVerbose: import("@vue/reactivity").Ref<boolean, boolean>;
 declare const isShowTokens: import("@vue/reactivity").Ref<boolean, boolean>;
 declare const promptfilePath: import("@vue/reactivity").Ref<string, string>;
+declare const dataDirPath: import("@vue/reactivity").Ref<string, string>;
 declare const lastCmd: {
     name: string;
     args: Array<string>;
 };
 declare function initFeatures(): Promise<void>;
 declare function initState(): Promise<void>;
-export { inputMode, outputMode, isChatMode, isShowTokens, runMode, formatMode, lastCmd, isDebug, isVerbose, promptfilePath, initState, initFeatures, pyShell, };
+declare function pluginDataDir(pluginName: string): string;
+export { inputMode, outputMode, isChatMode, isShowTokens, runMode, formatMode, lastCmd, isDebug, isVerbose, promptfilePath, dataDirPath, pluginDataDir, initState, initFeatures, pyShell, };

package/dist/state/state.js

@@ -1,10 +1,13 @@
 import { reactive, ref } from "@vue/reactivity";
 import { createConfDirIfNotExists, confDir } from "../conf.js";
 import { initDb } from "../db/db.js";
-import { readFeaturePaths, readPromptFilePath } from "../db/read.js";
+import { readFeaturePaths, readFilePaths } from "../db/read.js";
 import { updateAliases, updateFeatures } from "../db/write.js";
 import { readFeaturesDirs } from "./features.js";
 import { readPluginsPaths } from "./plugins.js";
+import path from "path";
+import { createDirectoryIfNotExists } from "../cmd/sys/dirs.js";
+import { updateModels } from "../cmd/lib/models.js";
 let pyShell;
 const inputMode = ref("manual");
 const outputMode = ref("txt");
@@ -15,6 +18,7 @@ const isDebug = ref(false);
 const isVerbose = ref(false);
 const isShowTokens = ref(false);
 const promptfilePath = ref("");
+const dataDirPath = ref("");
 const isStateReady = ref(false);
 const lastCmd = reactive({
     name: "",
@@ -34,7 +38,17 @@ async function initFeatures() {
     const feats = readFeaturesDirs(p);
     updateFeatures(feats);
     updateAliases(feats);
-    promptfilePath.value = readPromptFilePath();
+    updateModels();
+    const filePaths = readFilePaths();
+    for (const fp of filePaths) {
+        switch (fp.name) {
+            case "promptfile":
+                promptfilePath.value = fp.path;
+                break;
+            case "datadir":
+                dataDirPath.value = fp.path;
+        }
+    }
 }
 async function initState() {
     if (isStateReady.value) {
@@ -44,4 +58,16 @@ async function initState() {
     await initFeatures();
     isStateReady.value = true;
 }
-export { inputMode, outputMode, isChatMode, isShowTokens, runMode, formatMode, lastCmd, isDebug, isVerbose, promptfilePath, initState, initFeatures, pyShell, };
+function _getDataDirPath() {
+    if (dataDirPath.value.length == 0) {
+        throw new Error("datadir path is not configured: update your config file with 'datadir' and run conf");
+    }
+    return dataDirPath.value;
+}
+function pluginDataDir(pluginName) {
+    const dd = _getDataDirPath();
+    const pluginDatapath = path.join(dd, pluginName);
+    createDirectoryIfNotExists(pluginDatapath);
+    return pluginDatapath;
+}
+export { inputMode, outputMode, isChatMode, isShowTokens, runMode, formatMode, lastCmd, isDebug, isVerbose, promptfilePath, dataDirPath, pluginDataDir, initState, initFeatures, pyShell, };

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.44",
+  "version": "0.0.45",
   "scripts": {
     "buildrl": "rm -rf dist/* && rollup -c",
     "build": "rm -rf dist/* && tsc",
@@ -10,12 +10,11 @@
     "watch": "tsc --noCheck -p . -w"
   },
   "dependencies": {
-    "@agent-smith/brain": "^0.0.41",
+    "@agent-smith/brain": "^0.0.42",
     "@agent-smith/jobs": "^0.0.14",
-    "@agent-smith/lmtask": "^0.0.35",
-    "@agent-smith/tfm": "^0.1.2",
-    "@inquirer/prompts": "^7.4.0",
-    "@inquirer/select": "^4.1.0",
+    "@agent-smith/lmtask": "^0.0.37",
+    "@inquirer/prompts": "^7.4.1",
+    "@inquirer/select": "^4.1.1",
     "@vue/reactivity": "^3.5.13",
     "@wllama/wllama": "^2.3.0",
     "better-sqlite3": "^11.9.1",
@@ -29,17 +28,17 @@
   "devDependencies": {
     "@agent-smith/tmem-jobs": "^0.0.4",
     "@commander-js/extra-typings": "^13.1.0",
-    "@locallm/types": "^0.1.6",
+    "@locallm/types": "^0.1.9",
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-typescript": "^12.1.2",
-    "@types/better-sqlite3": "^7.6.12",
+    "@types/better-sqlite3": "^7.6.13",
     "@types/marked-terminal": "^6.1.1",
-    "@types/node": "^22.13.14",
+    "@types/node": "^22.14.0",
     "restmix": "^0.5.0",
-    "rollup": "^4.38.0",
+    "rollup": "^4.39.0",
     "ts-node": "^10.9.2",
     "tslib": "2.8.1",
-    "typescript": "^5.8.2"
+    "typescript": "^5.8.3"
   },
   "type": "module",
   "preferGlobal": true,

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

@@ -1,7 +0,0 @@
-declare function readModelsFile(dir: string): {
-    found: boolean;
-    ctx: number;
-    max_tokens: number;
-    models: Record<string, any>;
-};
-export { readModelsFile, };