@agent-smith/cli 0.0.71 → 0.0.80

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

@@ -1,14 +1,14 @@
+import { Task } from "@agent-smith/task";
 import { compile, serializeGrammar } from "@intrinsicai/gbnfgen";
-import { taskBuilder } from "../../../agent.js";
 import { readTool } from "../../../db/read.js";
 import { executeAction } from "../actions/cmd.js";
 import { McpClient } from "../mcp.js";
 import { parseTaskConfigOptions } from "../options_parsers.js";
 import { executeWorkflow } from "../workflows/cmd.js";
+import { executeTask } from "./cmd.js";
 import { configureTaskModel, mergeInferParams } from "./conf.js";
 import { openTaskSpec } from "./utils.js";
-import { executeTask } from "./cmd.js";
-async function readTask(name, payload, options) {
+async function readTask(name, payload, options, agent) {
     if (options?.debug) {
         console.log("Payload:", payload);
         console.log("Task options:", options);
@@ -26,19 +26,25 @@ async function readTask(name, payload, options) {
     }
     const taskSpec = taskFileSpec;
     let vars = {};
-    taskSpec.variables?.optional?.forEach(k => {
-        if (k in options) {
-            vars[k] = options[k];
+    if (taskSpec.variables?.optional) {
+        for (const k of Object.keys(taskSpec.variables.optional)) {
+            if (k in options) {
+                vars[k] = options[k];
+            }
         }
-    });
-    taskSpec.variables?.required?.forEach(k => {
-        if (k in options) {
-            vars[k] = options[k];
+    }
+    if (taskSpec.variables?.required) {
+        for (const k of Object.keys(taskSpec.variables.required)) {
+            if (k in options) {
+                vars[k] = options[k];
+            }
         }
-    });
+    }
     const mcpServers = new Array();
-    if (taskFileSpec?.mcp) {
+    if (!taskSpec?.tools) {
         taskSpec.tools = [];
+    }
+    if (taskFileSpec?.mcp) {
         for (const [servername, tool] of Object.entries(taskFileSpec.mcp)) {
             const mcp = new McpClient(servername, tool.command, tool.args, tool?.tools ?? null);
             mcpServers.push(mcp);
@@ -48,9 +54,6 @@ async function readTask(name, payload, options) {
         }
     }
     if (taskSpec.toolsList) {
-        if (!taskSpec?.tools) {
-            taskSpec.tools = [];
-        }
         for (const toolName of taskSpec.toolsList) {
             const { found, tool, type } = readTool(toolName);
             if (!found) {
@@ -80,7 +83,7 @@ async function readTask(name, payload, options) {
         delete taskSpec.toolsList;
     }
     ;
-    const task = taskBuilder.init(taskSpec);
+    const task = new Task(agent, taskSpec);
     if (model?.inferParams?.tsGrammar) {
         model.inferParams.grammar = serializeGrammar(await compile(model.inferParams.tsGrammar, "Grammar"));
         delete model.inferParams.tsGrammar;

package/dist/cmd/lib/utils.js

@@ -1,9 +1,11 @@
-import { marked } from "../../agent.js";
 import { formatMode, initFilepaths, outputMode, promptfilePath } from "../../state/state.js";
 import { writeToClipboard } from "../sys/clipboard.js";
 import { readFile } from "../sys/read.js";
 import { splitThinking } from "../../utils/text.js";
 import { runtimeError } from "./user_msgs.js";
+import { marked } from 'marked';
+import { markedTerminal } from "marked-terminal";
+marked.use(markedTerminal());
 function readPromptFile() {
     initFilepaths();
     return readFile(promptfilePath.value);

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

@@ -3,6 +3,7 @@ import { executeAdaptater } from "../adaptaters/cmd.js";
 import { parseCommandArgs } from "../options_parsers.js";
 import { executeTask } from "../tasks/cmd.js";
 import { readWorkflow } from "./read.js";
+import colors from "ansi-colors";
 async function executeWorkflow(name, params, options) {
     const { workflow, found } = await readWorkflow(name);
     if (!found) {
@@ -15,11 +16,11 @@ async function executeWorkflow(name, params, options) {
         console.log("Running workflow", name, stepNames.length, "steps");
     }
     let i = 0;
-    const finalTaskIndex = stepNames.length + 1;
+    const finalTaskIndex = stepNames.length - 1;
     let taskRes = params;
     for (const [name, step] of Object.entries(workflow)) {
         if (isDebug || isVerbose) {
-            console.log(`${i + 1}: ${step.type} ${name}`);
+            console.log(i + 1, name, colors.dim(step.type));
         }
         switch (step.type) {
             case "task":
@@ -35,7 +36,7 @@ async function executeWorkflow(name, params, options) {
                 try {
                     const ares = await executeAction(name, taskRes, options, true);
                     if (typeof ares == "string") {
-                        taskRes = { payload: ares };
+                        taskRes = { args: ares };
                     }
                     else {
                         taskRes = ares;
@@ -52,11 +53,14 @@ async function executeWorkflow(name, params, options) {
                 try {
                     const ares = await executeAdaptater(name, taskRes, options);
                     if (typeof ares == "string") {
-                        taskRes = { payload: ares };
+                        taskRes = { args: ares };
                     }
                     else {
                         taskRes = ares;
                     }
+                    if (i == finalTaskIndex) {
+                        console.log(taskRes);
+                    }
                 }
                 catch (e) {
                     throw new Error(`workflow adaptater ${i + 1}: ${e}`);
@@ -72,7 +76,6 @@ async function executeWorkflow(name, params, options) {
 }
 async function executeWorkflowCmd(name, wargs) {
     const { args, options } = parseCommandArgs(wargs);
-    const params = { args: args };
-    return await executeWorkflow(name, params, options);
+    return await executeWorkflow(name, { args: args }, options);
 }
 export { executeWorkflow, executeWorkflowCmd, };

package/dist/cmd/lib/workflows/read.d.ts

@@ -1,7 +1,6 @@
-import { AgentTask } from "@agent-smith/jobs";
-import { FeatureType } from '../../../interfaces.js';
+import { WorkflowStep } from '../../../interfaces.js';
 declare function readWorkflow(name: string): Promise<{
     found: boolean;
-    workflow: Record<string, AgentTask<FeatureType, any, any, Record<string, any>>>;
+    workflow: Record<string, WorkflowStep>;
 }>;
-export { readWorkflow, };
+export { readWorkflow };

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

@@ -1,6 +1,8 @@
-import YAML from 'yaml';
+import { Agent } from '@agent-smith/agent';
+import { Task } from '@agent-smith/task';
 import { default as fs } from "fs";
-import { taskBuilder } from '../../../agent.js';
+import YAML from 'yaml';
+import { backend } from '../../../state/backends.js';
 import { getFeatureSpec } from '../../../state/features.js';
 import { readTask } from "../../sys/read_task.js";
 import { pythonAction, systemAction } from '../actions/cmd.js';
@@ -26,24 +28,36 @@ async function _createWorkflowFromSpec(spec) {
                 case "js":
                     const { action } = await import(path);
                     const at = action;
-                    at.type = "action";
-                    steps[name] = at;
+                    const wf = {
+                        type: "action",
+                        run: at,
+                    };
+                    steps[name] = wf;
                     break;
                 case "mjs":
                     const mjsa = await import(path);
                     const act = createJsAction(mjsa.action);
-                    act.type = "action";
-                    steps[name] = act;
+                    const wf2 = {
+                        type: "action",
+                        run: act,
+                    };
+                    steps[name] = wf2;
                     break;
                 case "yml":
                     const _t1 = systemAction(path);
-                    _t1.type = "action";
-                    steps[name] = _t1;
+                    const wf3 = {
+                        type: "action",
+                        run: _t1,
+                    };
+                    steps[name] = wf3;
                     break;
                 case "py":
                     const _t = pythonAction(path);
-                    _t.type = "action";
-                    steps[name] = _t;
+                    const wf4 = {
+                        type: "action",
+                        run: _t,
+                    };
+                    steps[name] = wf4;
                     break;
                 default:
                     throw new Error(`Unknown feature extension ${ext}`);
@@ -56,8 +70,11 @@ async function _createWorkflowFromSpec(spec) {
             }
             const jsa = await import(path);
             const act = createJsAction(jsa.action);
-            act.type = "adaptater";
-            steps[name] = act;
+            const wf = {
+                type: "adaptater",
+                run: act,
+            };
+            steps[name] = wf;
         }
         else {
             const { found, path } = getFeatureSpec(name, "task");
@@ -68,8 +85,13 @@ async function _createWorkflowFromSpec(spec) {
             if (!res.found) {
                 throw new Error(`Unable to read task ${name} ${path}`);
             }
-            const tsk = taskBuilder.fromYaml(res.ymlTask, "task");
-            steps[name] = tsk;
+            const agent = new Agent(backend.value);
+            const tsk = Task.fromYaml(agent, res.ymlTask);
+            const wf = {
+                type: "task",
+                run: tsk.run,
+            };
+            steps[name] = wf;
         }
     }
     return steps;
@@ -112,4 +134,4 @@ async function readWorkflow(name) {
     }
     return { found: true, workflow: wf };
 }
-export { readWorkflow, };
+export { readWorkflow };

package/dist/conf.js

@@ -1,8 +1,9 @@
 import path from "path";
 import { readConf } from "./cmd/sys/read_conf.js";
-import { upsertBackend, insertFeaturesPathIfNotExists, insertPluginIfNotExists } from "./db/write.js";
+import { upsertBackends, insertFeaturesPathIfNotExists, insertPluginIfNotExists } from "./db/write.js";
 import { buildPluginsPaths } from "./state/plugins.js";
 import { runtimeError } from "./cmd/lib/user_msgs.js";
+import { localBackends } from "./const.js";
 const confDir = path.join(process.env.HOME, ".config/agent-smith/cli");
 const dbPath = path.join(confDir, "config.db");
 async function processConfPath(confPath) {
@@ -12,17 +13,52 @@ async function processConfPath(confPath) {
     }
     console.log(data);
     const allPaths = new Array();
+    const backends = {};
+    let defaultBackendName = "";
     if (data?.backends) {
-        for (const [name, bconf] of Object.entries(data.backends)) {
-            const bc = {
-                name: name,
-                type: bconf.type,
-                uri: bconf.uri,
-                apiKey: bconf?.apiKey,
-            };
-            upsertBackend(bc);
+        for (const [name, val] of Object.entries(data.backends)) {
+            switch (name) {
+                case "local":
+                    const bs = val;
+                    bs.forEach(b => {
+                        if (!["llamacpp", "koboldcpp", "ollama"].includes(b)) {
+                            throw new Error(`Unknow backend default value: ${b}`);
+                        }
+                        const lb = localBackends[b];
+                        backends[lb.name] = lb;
+                    });
+                    break;
+                case "default":
+                    const v1 = val;
+                    defaultBackendName = v1;
+                    break;
+                default:
+                    const v3 = val;
+                    let apiKey = undefined;
+                    if (v3?.apiKey) {
+                        apiKey = v3.apiKey;
+                    }
+                    const ib = {
+                        name: name,
+                        type: v3.type,
+                        url: v3.url,
+                        isDefault: false,
+                    };
+                    if (apiKey) {
+                        ib.apiKey = apiKey;
+                    }
+                    backends[name] = ib;
+                    break;
+            }
         }
     }
+    console.log("Default backend:", defaultBackendName);
+    console.dir(backends, { depth: 4 });
+    if (!Object.keys(backends).includes(defaultBackendName)) {
+        throw new Error(`Undeclared default backend: ${defaultBackendName}`);
+    }
+    backends[defaultBackendName].isDefault = true;
+    upsertBackends(Object.values(backends));
     if (data?.features) {
         allPaths.push(...data.features);
         const fts = new Array();

package/dist/const.d.ts

@@ -0,0 +1,3 @@
+import { InferenceBackend } from "./interfaces.js";
+declare const localBackends: Record<string, InferenceBackend>;
+export { localBackends };

package/dist/const.js

@@ -0,0 +1,24 @@
+const localBackends = {
+    llamacpp: {
+        name: "llamacpp",
+        type: "llamacpp",
+        url: "http://localhost:8080",
+        apiKey: "",
+        isDefault: false,
+    },
+    koboldcpp: {
+        name: "koboldcpp",
+        type: "koboldcpp",
+        url: "http://localhost:5001",
+        apiKey: "",
+        isDefault: false,
+    },
+    ollama: {
+        name: "ollama",
+        type: "ollama",
+        url: "http://localhost:11434",
+        apiKey: "",
+        isDefault: false,
+    },
+};
+export { localBackends };

package/dist/db/read.d.ts

@@ -1,7 +1,7 @@
-import { ToolSpec } from "modprompt";
-import { AliasType, FeatureSpec, FeatureType, DbModelDef, ToolType } from "../interfaces.js";
+import { ToolSpec } from "@locallm/types";
+import { AliasType, FeatureSpec, FeatureType, DbModelDef, ToolType, InferenceBackend } from "../interfaces.js";
 declare function readFeaturePaths(): Array<string>;
-declare function readBackends(): Array<Record<string, string>>;
+declare function readBackends(): Record<string, InferenceBackend>;
 declare function readPlugins(): Array<Record<string, string>>;
 declare function readFeaturesType(type: FeatureType): Record<string, FeatureSpec>;
 declare function readFeatures(): Record<FeatureType, Record<string, FeatureSpec>>;

package/dist/db/read.js

@@ -9,13 +9,13 @@ function readFeaturePaths() {
     return f;
 }
 function readBackends() {
-    const stmt = db.prepare("SELECT name, type, uri, apiKey FROM backend");
+    const stmt = db.prepare("SELECT name, type, url, apiKey, isdefault FROM backend");
     const data = stmt.all();
-    let f = new Array();
+    const bks = {};
     data.forEach((row) => {
-        f.push({ name: row.name, type: row.type, uri: row.uri, apiKey: row.apiKey });
+        bks[row.name] = { name: row.name, type: row.type, url: row.url, apiKey: row.apiKey, isDefault: row.isdefault === 1 };
     });
-    return f;
+    return bks;
 }
 function readPlugins() {
     const stmt = db.prepare("SELECT name, path FROM plugin");

package/dist/db/schemas.js

@@ -74,8 +74,9 @@ const model = `CREATE TABLE IF NOT EXISTS model (
 const backend = `CREATE TABLE IF NOT EXISTS backend (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
-    type TEXT NOT NULL CHECK ( type IN ('llamacpp', 'koboldcpp', 'ollama') ),
-    uri TEXT NOT NULL,
+    type TEXT NOT NULL CHECK ( type IN ('llamacpp', 'koboldcpp', 'ollama', 'openai') ),
+    url TEXT NOT NULL,
+    isdefault INTEGER NOT NULL,
     apiKey TEXT
 );`;
 const schemas = [

package/dist/db/write.d.ts

@@ -1,7 +1,8 @@
-import { Features, DbModelDef, RemoteBackend } from "../interfaces.js";
+import { Features, DbModelDef, InferenceBackend } from "../interfaces.js";
 declare function updatePromptfilePath(pf: string): void;
 declare function updateDataDirPath(dd: string): void;
-declare function upsertBackend(bdata: RemoteBackend): boolean;
+declare function setDefaultBackend(name: string): void;
+declare function upsertBackends(bdata: Array<InferenceBackend>): boolean;
 declare function insertFeaturesPathIfNotExists(path: string): boolean;
 declare function insertPluginIfNotExists(n: string, p: string): boolean;
 declare function cleanupFeaturePaths(paths: Array<string>): Array<string>;
@@ -9,4 +10,4 @@ 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, upsertBackend, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, updateModels, upsertFilePath, };
+export { updatePromptfilePath, updateDataDirPath, upsertBackends, setDefaultBackend, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, updateModels, upsertFilePath, };

package/dist/db/write.js

@@ -13,17 +13,41 @@ function updateDataDirPath(dd) {
     const stmt = db.prepare("INSERT INTO filepath (name, path) VALUES (?, ?)");
     stmt.run("datadir", dd);
 }
-function upsertBackend(bdata) {
-    const stmt1 = db.prepare("SELECT * FROM backend WHERE name = ?");
-    const result = stmt1.get(bdata.name);
-    if (result?.id) {
-        const updateStmt = db.prepare("UPDATE backend SET type = ?, uri = ?, apiKey = ? WHERE name = ?");
-        updateStmt.run(bdata.type, bdata.uri, bdata?.apiKey ?? "NULL", bdata.name);
-        return true;
+function setDefaultBackend(name) {
+    const updateStmt = db.prepare("UPDATE backend SET isdefault = 0 WHERE isdefault = 1");
+    updateStmt.run();
+    const nupdStmt = db.prepare("UPDATE backend SET isdefault = 1 WHERE name = ?");
+    nupdStmt.run(name);
+}
+function upsertBackends(bdata) {
+    let hasUpdates = false;
+    const existingStmt = db.prepare("SELECT name FROM backend");
+    const existingBackends = existingStmt.all();
+    const existingNames = new Set(existingBackends.map(b => b.name));
+    const newNames = new Set(bdata.map(b => b.name));
+    const toDelete = Array.from(existingNames).filter(name => !newNames.has(name));
+    if (toDelete.length > 0) {
+        const deleteStmt = db.prepare("DELETE FROM backend WHERE name = ?");
+        for (const name of toDelete) {
+            deleteStmt.run(name);
+        }
+        hasUpdates = true;
     }
-    const stmt = db.prepare("INSERT INTO backend (name,type,uri,apiKey) VALUES (?,?,?,?)");
-    stmt.run(bdata.name, bdata.type, bdata.uri, bdata?.apiKey ?? "NULL");
-    return false;
+    for (const backend of bdata) {
+        const stmt1 = db.prepare("SELECT * FROM backend WHERE name = ?");
+        const result = stmt1.get(backend.name);
+        if (result?.id) {
+            const updateStmt = db.prepare("UPDATE backend SET type = ?, url = ?, apiKey = ?, isdefault = ? WHERE name = ?");
+            updateStmt.run(backend.type, backend.url, backend?.apiKey ?? "NULL", backend.isDefault ? 1 : 0, backend.name);
+            hasUpdates = true;
+        }
+        else {
+            const stmt = db.prepare("INSERT INTO backend (name,type,url,apiKey,isdefault) VALUES (?,?,?,?,?)");
+            stmt.run(backend.name, backend.type, backend.url, backend?.apiKey ?? "NULL", backend.isDefault ? 1 : 0);
+            hasUpdates = true;
+        }
+    }
+    return hasUpdates;
 }
 function insertFeaturesPathIfNotExists(path) {
     const stmt1 = db.prepare("SELECT * FROM featurespath WHERE path = ?");
@@ -169,7 +193,7 @@ function updateFeatures(feats) {
         if (toolDoc.length > 0) {
             upsertTool(feat.name, "task", toolDoc);
         }
-        if (variables.required.length > 0 || variables.optional.length > 0) {
+        if (Object.keys(variables.required).length > 0 || Object.keys(variables.optional).length > 0) {
             updateVariables(feat.name, JSON.stringify(variables, null, "  "));
         }
     });
@@ -206,4 +230,4 @@ function upsertFilePath(name, newPath) {
         return true;
     }
 }
-export { updatePromptfilePath, updateDataDirPath, upsertBackend, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, updateModels, upsertFilePath, };
+export { updatePromptfilePath, updateDataDirPath, upsertBackends, setDefaultBackend, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, updateModels, upsertFilePath, };

package/dist/index.js

@@ -1,11 +1,10 @@
 #!/usr/bin/env node
 import { argv } from 'process';
-import { initAgent } from './agent.js';
 import { query } from "./cli.js";
 import { buildCmds, parseCmd } from './cmd/cmds.js';
 import { formatMode, initState, inputMode, isChatMode, outputMode, runMode } from './state/state.js';
 import { updateConfCmd } from './cmd/clicmds/update.js';
-import { initRemoteBackends } from './cmd/backends.js';
+import { initBackends } from './state/backends.js';
 async function main() {
     const nargs = argv.length;
     if (nargs == 2) {
@@ -18,8 +17,7 @@ async function main() {
         }
     }
     await initState();
-    const rmbs = initRemoteBackends();
-    await initAgent(rmbs);
+    await initBackends();
     const program = await buildCmds();
     program.hook('preAction', async (thisCommand, actionCommand) => {
         const options = actionCommand.opts();

package/dist/interfaces.d.ts

@@ -1,15 +1,11 @@
-import { BaseLmTask, ModelSpec } from "@agent-smith/lmtask";
-import { InferenceParams } from "@locallm/types";
-interface FeatureVariables {
-    required: Array<string>;
-    optional: Array<string>;
-}
+import { TaskDef, ModelSpec, TaskVariables } from "@agent-smith/task";
+import { InferenceParams, LmProviderType } from "@locallm/types";
 interface FeatureSpec {
     id?: number;
     name: string;
     path: string;
     ext: FeatureExtension;
-    variables?: FeatureVariables;
+    variables?: TaskVariables;
 }
 interface Features {
     task: Array<{
@@ -43,18 +39,24 @@ interface Features {
         ext: ModelFileExtension;
     }>;
 }
-interface RemoteBackend {
-    name: string;
-    type: RemoteProviderType;
-    uri: string;
+interface ConfInferenceBackend {
+    type: LmProviderType;
+    url: string;
     apiKey?: string;
 }
+interface InferenceBackend extends ConfInferenceBackend {
+    name: string;
+    isDefault?: boolean;
+}
+interface BackendEntries {
+    [key: string]: ConfInferenceBackend | string | Array<"llamacpp" | "koboldcpp" | "ollama">;
+}
 interface ConfigFile {
     promptfile?: string;
     datadir?: string;
     features?: Array<string>;
     plugins?: Array<string>;
-    backends?: Array<RemoteBackend>;
+    backends?: BackendEntries;
 }
 interface Settings {
     name: string;
@@ -82,9 +84,8 @@ interface ModelPack {
     default: string;
     recommended?: Array<string>;
 }
-interface LmTaskFileSpec extends BaseLmTask {
+interface LmTaskFileSpec extends TaskDef {
     ctx: number;
-    model?: ModelSpec;
     modelpack?: ModelPack;
     mcp?: McpServerSpec;
 }
@@ -100,6 +101,10 @@ interface FinalLmTaskConfig {
     model?: ModelSpec;
     modelname?: string;
 }
+interface WorkflowStep {
+    type: string;
+    run: FeatureExecutor;
+}
 interface McpServerSpec {
     command: string;
     arguments: string[];
@@ -132,5 +137,5 @@ type CmdExtension = "js";
 type ModelFileExtension = "yml";
 type FeatureExtension = TaskExtension | CmdExtension | ActionExtension | WorkflowExtension | ModelFileExtension;
 type AliasType = "task" | "action" | "workflow";
-type RemoteProviderType = "llamacpp" | "koboldcpp" | "ollama";
-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, RemoteBackend, RemoteProviderType, };
+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, };

package/dist/main.d.ts

@@ -3,7 +3,6 @@ import { executeTask } from "./cmd/lib/tasks/cmd.js";
 import { executeAction } from "./cmd/lib/actions/cmd.js";
 import { executeWorkflow } from "./cmd/lib/workflows/cmd.js";
 import { writeToClipboard } from "./cmd/sys/clipboard.js";
-import { initAgent } from "./agent.js";
 import { initState, pluginDataDir } from "./state/state.js";
 import { usePerfTimer } from "./utils/perf.js";
 import { parseCommandArgs } from "./cmd/lib/options_parsers.js";
@@ -14,4 +13,4 @@ import { displayOptions, ioOptions, inferenceOptions, allOptions } from "./cmd/o
 import { McpClient } from "./cmd/lib/mcp.js";
 import { readTask } from "./cmd/lib/tasks/read.js";
 import { FeatureType } from "./interfaces.js";
-export { execute, run, executeTask, executeAction, executeWorkflow, writeToClipboard, initAgent, initState, pluginDataDir, usePerfTimer, parseCommandArgs, extractToolDoc, openTaskSpec, extractBetweenTags, splitThinking, displayOptions, ioOptions, inferenceOptions, allOptions, McpClient, readTask, FeatureType, };
+export { execute, run, executeTask, executeAction, executeWorkflow, writeToClipboard, initState, pluginDataDir, usePerfTimer, parseCommandArgs, extractToolDoc, openTaskSpec, extractBetweenTags, splitThinking, displayOptions, ioOptions, inferenceOptions, allOptions, McpClient, readTask, FeatureType, };

package/dist/main.js

@@ -3,7 +3,6 @@ import { executeTask } from "./cmd/lib/tasks/cmd.js";
 import { executeAction } from "./cmd/lib/actions/cmd.js";
 import { executeWorkflow } from "./cmd/lib/workflows/cmd.js";
 import { writeToClipboard } from "./cmd/sys/clipboard.js";
-import { initAgent } from "./agent.js";
 import { initState, pluginDataDir } from "./state/state.js";
 import { usePerfTimer } from "./utils/perf.js";
 import { parseCommandArgs } from "./cmd/lib/options_parsers.js";
@@ -13,4 +12,4 @@ import { extractBetweenTags, splitThinking } from "./utils/text.js";
 import { displayOptions, ioOptions, inferenceOptions, allOptions } from "./cmd/options.js";
 import { McpClient } from "./cmd/lib/mcp.js";
 import { readTask } from "./cmd/lib/tasks/read.js";
-export { execute, run, executeTask, executeAction, executeWorkflow, writeToClipboard, initAgent, initState, pluginDataDir, usePerfTimer, parseCommandArgs, extractToolDoc, openTaskSpec, extractBetweenTags, splitThinking, displayOptions, ioOptions, inferenceOptions, allOptions, McpClient, readTask, };
+export { execute, run, executeTask, executeAction, executeWorkflow, writeToClipboard, initState, pluginDataDir, usePerfTimer, parseCommandArgs, extractToolDoc, openTaskSpec, extractBetweenTags, splitThinking, displayOptions, ioOptions, inferenceOptions, allOptions, McpClient, readTask, };

package/dist/state/backends.d.ts

@@ -0,0 +1,7 @@
+import { Lm } from "@locallm/api";
+declare const backend: import("@vue/reactivity").Ref<Lm | undefined, Lm | undefined>;
+declare const backends: Record<string, Lm>;
+declare function initBackends(isVerbose?: boolean): Promise<void>;
+declare function setBackend(name: string, isVerbose?: boolean): Promise<void>;
+declare function listBackends(): Promise<void>;
+export { backend, backends, initBackends, listBackends, setBackend };