@agent-smith/cli 0.0.44 → 0.0.46

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 { configureTaskModel, 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 model;
+    let vars = {};
+    if (!isWorkflow) {
+        const tv = parseTaskVars(args, taskFileSpec?.inferParams ? taskFileSpec.inferParams : {});
+        vars = tv.vars;
+        model = configureTaskModel(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;
+        model = configureTaskModel(tv.conf, taskFileSpec);
     }
+    const taskSpec = taskFileSpec;
     if (taskSpec.toolsList) {
         taskSpec.tools = [];
         for (const toolName of taskSpec.toolsList) {
@@ -127,39 +100,40 @@ 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 (model?.inferParams?.tsGrammar) {
+        model.inferParams.grammar = serializeGrammar(await compile(model.inferParams.tsGrammar, "Grammar"));
+        delete model.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 model:", model);
         console.log("Task vars:", vars);
     }
-    const ex = brain.getOrCreateExpertForModel(conf.model.name, conf.model.template);
+    const ex = brain.getOrCreateExpertForModel(model.name, model.template);
     if (!ex) {
-        throw new Error("No expert found for model " + conf.model.name);
+        throw new Error("No expert found for model " + model.name);
     }
     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;
+        });
+    }
+    const conf = {
+        expert: ex,
+        model: model,
+        debug: isDebug.value,
+    };
     conf.expert = ex;
     if (isDebug.value || isVerbose.value) {
         conf.debug = true;
@@ -172,7 +146,6 @@ async function executeTaskCmd(args = [], options = {}) {
     catch (err) {
         throw new Error(`Error executing task: ${name} ${err}`);
     }
-    conf.prompt = pr;
     if (isChatMode.value) {
         if (brain.ex.name != ex.name) {
             brain.setDefaultExpert(ex);

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

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

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

@@ -0,0 +1,150 @@
+import { useTemplateForModel } from "@agent-smith/tfm";
+import { readModel } from "../../../db/read.js";
+const tfm = useTemplateForModel();
+function configureTaskModel(itConf, taskSpec) {
+    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) {
+        const gt = tfm.guess(modelName);
+        if (gt == "none") {
+            throw new Error(`Unable to guess the template for ${modelName}: please provide a template name: m="modelname/templatename"`);
+        }
+        const m = {
+            name: modelName,
+            template: gt
+        };
+        model = m;
+    }
+    model.inferParams = ip;
+    if (!model?.ctx || !isModelFromTaskFile) {
+        model.ctx = taskSpec.ctx;
+    }
+    model.inferParams = ip;
+    if (templateName.length > 0) {
+        model.template = templateName;
+    }
+    return model;
+}
+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, configureTaskModel, };

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