@agent-smith/cli 0.0.95 → 0.0.97

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

@@ -9,17 +9,12 @@ import { pythonAction, systemAction } from '../actions/cmd.js';
 import { createJsAction } from '../actions/read.js';
 import { pathToFileURL } from 'url';
 async function _createWorkflowFromSpec(spec) {
-    const steps = {};
+    const steps = [];
+    let i = 1;
     for (const step of spec.steps) {
         const type = Object.keys(step)[0];
         const sval = step[type];
-        let name;
-        if (typeof sval == "string") {
-            name = sval;
-        }
-        else {
-            name = step[type].name;
-        }
+        const name = sval;
         if (type == "action") {
             const { found, path, ext } = getFeatureSpec(name, "action");
             if (!found) {
@@ -31,36 +26,40 @@ async function _createWorkflowFromSpec(spec) {
                     const { action } = await import(url);
                     const at = action;
                     const wf = {
+                        name: name,
                         type: "action",
                         run: at,
                     };
-                    steps[name] = wf;
+                    steps.push(wf);
                     break;
                 case "mjs":
                     const url2 = pathToFileURL(path).href;
                     const mjsa = await import(url2);
                     const act = createJsAction(mjsa.action);
                     const wf2 = {
+                        name: name,
                         type: "action",
                         run: act,
                     };
-                    steps[name] = wf2;
+                    steps.push(wf2);
                     break;
                 case "yml":
                     const _t1 = systemAction(path);
                     const wf3 = {
+                        name: name,
                         type: "action",
                         run: _t1,
                     };
-                    steps[name] = wf3;
+                    steps.push(wf3);
                     break;
                 case "py":
                     const _t = pythonAction(path);
                     const wf4 = {
+                        name: name,
                         type: "action",
                         run: _t,
                     };
-                    steps[name] = wf4;
+                    steps.push(wf4);
                     break;
                 default:
                     throw new Error(`Unknown feature extension ${ext}`);
@@ -75,10 +74,11 @@ async function _createWorkflowFromSpec(spec) {
             const jsa = await import(url);
             const act = createJsAction(jsa.action);
             const wf = {
+                name: name,
                 type: "adaptater",
                 run: act,
             };
-            steps[name] = wf;
+            steps.push(wf);
         }
         else {
             const { found, path } = getFeatureSpec(name, "task");
@@ -92,11 +92,13 @@ async function _createWorkflowFromSpec(spec) {
             const agent = new Agent(backend.value);
             const tsk = Task.fromYaml(agent, res.ymlTask);
             const wf = {
+                name: name,
                 type: "task",
                 run: tsk.run,
             };
-            steps[name] = wf;
+            steps.push(wf);
         }
+        ++i;
     }
     return steps;
 }
@@ -116,16 +118,16 @@ async function _readWorkflowFromDisk(name) {
 async function readWorkflow(name) {
     const { found, ext } = getFeatureSpec(name, "workflow");
     if (!found) {
-        return { found: false, workflow: {} };
+        return { found: false, workflow: [] };
     }
-    let wf = {};
+    let wf = new Array();
     switch (ext) {
         case "yml":
             const { data } = await _readWorkflowFromDisk(name);
             try {
                 const workflow = await _createWorkflowFromSpec(data);
                 if (!found) {
-                    return { found: false, workflow: {} };
+                    return { found: false, workflow: [] };
                 }
                 wf = workflow;
             }

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,116 @@ 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(", ")})`;
+        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

@@ -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;
@@ -102,6 +98,7 @@ interface FinalLmTaskConfig {
     modelname?: string;
 }
 interface WorkflowStep {
+    name: string;
     type: string;
     run: FeatureExecutor;
 }
@@ -122,20 +119,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/chat.d.ts

@@ -1,27 +1,7 @@
-declare const chatInferenceParams: {
-    stream?: boolean | undefined;
-    model?: {
-        name: string;
-        ctx?: number | undefined;
-        info?: {
-            size: string;
-            quant: string;
-        } | undefined;
-        extra?: Record<string, any> | undefined;
-    } | undefined;
-    template?: string | undefined;
-    max_tokens?: number | undefined;
-    top_k?: number | undefined;
-    top_p?: number | undefined;
-    min_p?: number | undefined;
-    temperature?: number | undefined;
-    repeat_penalty?: number | undefined;
-    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;
-};
-export { chatInferenceParams, };
+import { InferenceParams } from "@locallm/types";
+import { PromptTemplate } from "modprompt";
+declare let chatInferenceParams: InferenceParams;
+declare let chatTemplate: PromptTemplate;
+declare function setChatTemplate(tpl: PromptTemplate): void;
+declare function setChatInferenceParams(ip: InferenceParams): void;
+export { chatInferenceParams, chatTemplate, setChatInferenceParams, setChatTemplate, };

package/dist/state/chat.js

@@ -1,3 +1,10 @@
-import { reactive } from "@vue/reactivity";
-const chatInferenceParams = reactive({ temperature: 0.2, min_p: 0.05, max_tokens: 2048 });
-export { chatInferenceParams, };
+import { PromptTemplate } from "modprompt";
+let chatInferenceParams = { temperature: 0.2, min_p: 0.05, max_tokens: 2048 };
+let chatTemplate = new PromptTemplate("none");
+function setChatTemplate(tpl) {
+    chatTemplate = tpl;
+}
+function setChatInferenceParams(ip) {
+    chatInferenceParams = ip;
+}
+export { chatInferenceParams, chatTemplate, setChatInferenceParams, setChatTemplate, };

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