@agent-smith/cli 0.0.70 → 0.0.71

package/dist/agent.d.ts

@@ -1,7 +1,8 @@
-import { LmTaskBuilder } from "@agent-smith/lmtask";
+import { LmBackend } from "@agent-smith/brain";
+import { LmTaskBuilder } from "../../lmtask/dist/task.js";
 import { marked } from 'marked';
 import { FeatureType } from "./interfaces.js";
 declare let brain: import("@agent-smith/brain").AgentBrain<Record<string, any>>;
 declare const taskBuilder: LmTaskBuilder<FeatureType, Record<string, any>>;
-declare function initAgent(): Promise<boolean>;
+declare function initAgent(backends: Array<LmBackend>): Promise<boolean>;
 export { brain, initAgent, marked, taskBuilder };

package/dist/agent.js

@@ -1,22 +1,19 @@
 import { useAgentBrain } from "@agent-smith/brain";
-import { LmTaskBuilder } from "@agent-smith/lmtask";
+import { LmTaskBuilder } from "../../lmtask/dist/task.js";
 import { marked } from 'marked';
 import { markedTerminal } from "marked-terminal";
 marked.use(markedTerminal());
 let brain = useAgentBrain();
 const taskBuilder = new LmTaskBuilder(brain);
-async function initExperts() {
-    brain.experts.forEach((ex) => {
-        ex.backend.setOnToken((t) => {
-            process.stdout.write(t);
-        });
-    });
-}
-async function initAgent() {
+async function initAgent(backends) {
+    backends.forEach(b => brain.addBackend(b));
     if (!brain.state.get().isOn) {
         brain.resetExperts();
-        await brain.initLocal(true);
-        await initExperts();
+        if (backends.length > 0) {
+            await brain.discover();
+        }
+        await brain.discoverLocal(true);
+        await brain.backendsForModelsInfo();
     }
     const brainUp = brain.state.get().isOn;
     if (!brainUp) {

package/dist/cmd/backends.d.ts

@@ -0,0 +1,3 @@
+import { LmBackend } from "../../../brain/dist/main.js";
+declare function initRemoteBackends(): Array<LmBackend>;
+export { initRemoteBackends, };

package/dist/cmd/backends.js

@@ -0,0 +1,20 @@
+import { readBackends } from "../db/read.js";
+import { useLmBackend } from "../../../brain/dist/main.js";
+function initRemoteBackends() {
+    const rmb = readBackends();
+    const rmbs = new Array();
+    rmb.forEach(b => {
+        const bcs = {
+            name: b.name,
+            providerType: b.type,
+            serverUrl: b.uri,
+        };
+        if (b?.apiKey) {
+            bcs.apiKey = b.apiKey;
+        }
+        ;
+        rmbs.push(useLmBackend(bcs));
+    });
+    return rmbs;
+}
+export { initRemoteBackends, };

package/dist/cmd/clicmds/base.js

@@ -11,10 +11,11 @@ import { parseCommandArgs } from "../lib/options_parsers.js";
 import { deleteFileIfExists } from "../sys/delete_file.js";
 import { readTask } from "../sys/read_task.js";
 import { updateConfCmd } from "./update.js";
+import { initRemoteBackends } from "../backends.js";
 function initBaseCommands(program) {
     program.command("ping")
         .description("ping inference servers")
-        .action(async (...args) => { console.log("Found working inference server(s):", await initAgent()); });
+        .action(async (...args) => { console.log("Found working inference server(s):", await initAgent(initRemoteBackends())); });
     program.command("exit")
         .description("exit the cli")
         .action(() => process.exit(0));

package/dist/cmd/clicmds/cmds.js

@@ -1,9 +1,14 @@
 import { readCmds } from "../sys/read_cmds.js";
 async function initUserCmds(cmdFeats) {
+    const paths = new Set();
     const cmds = new Array();
     for (const feat of Object.values(cmdFeats)) {
+        if (paths.has(feat.path)) {
+            continue;
+        }
         const c = await readCmds(`${feat.path}`);
         cmds.push(...c);
+        paths.add(feat.path);
     }
     return cmds;
 }

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

@@ -2,100 +2,23 @@ import { input } from "@inquirer/prompts";
 import { compile, serializeGrammar } from "@intrinsicai/gbnfgen";
 import color from "ansi-colors";
 import ora from 'ora';
-import { brain, initAgent, taskBuilder } from "../../../agent.js";
+import { brain } from "../../../agent.js";
 import { query } from "../../../cli.js";
 import { readClipboard } from "../../../cmd/sys/clipboard.js";
-import { readTool } from "../../../db/read.js";
 import { usePerfTimer } from "../../../main.js";
 import { isChatMode, runMode } from "../../../state/state.js";
 import { program } from "../../cmds.js";
-import { executeAction } from "../actions/cmd.js";
-import { parseCommandArgs, parseTaskConfigOptions } from "../options_parsers.js";
+import { parseCommandArgs } from "../options_parsers.js";
 import { runtimeDataError, runtimeWarning } from "../user_msgs.js";
 import { formatStats, processOutput, readPromptFile } from "../utils.js";
-import { executeWorkflow } from "../workflows/cmd.js";
-import { configureTaskModel, mergeInferParams } from "./conf.js";
-import { McpClient } from "../mcp.js";
-import { openTaskSpec } from "./utils.js";
+import { readTask } from "./read.js";
 async function executeTask(name, payload, options, quiet, expert) {
-    await initAgent();
-    if (options.debug) {
-        console.log("Payload:", payload);
-        console.log("Task options:", options);
-    }
-    const taskFileSpec = openTaskSpec(name);
-    const opts = payload?.inferParams ? { ...options, ...payload.inferParams } : options;
-    const conf = parseTaskConfigOptions(opts);
-    if (options.debug) {
-        console.log("conf:", conf);
-    }
-    conf.inferParams = mergeInferParams(conf.inferParams, taskFileSpec.inferParams ?? {});
-    const model = configureTaskModel(conf, taskFileSpec);
-    if (options?.ctx) {
-        model.ctx = options.ctx;
-    }
-    const taskSpec = taskFileSpec;
-    let vars = {};
-    taskSpec.variables?.optional?.forEach(k => {
-        if (k in options) {
-            vars[k] = options[k];
-        }
-    });
-    taskSpec.variables?.required?.forEach(k => {
-        if (k in options) {
-            vars[k] = options[k];
-        }
-    });
-    const mcpServers = new Array();
-    if (taskFileSpec?.mcp) {
-        taskSpec.tools = [];
-        for (const [servername, tool] of Object.entries(taskFileSpec.mcp)) {
-            const mcp = new McpClient(servername, tool.command, tool.args, tool?.tools ?? null);
-            mcpServers.push(mcp);
-            await mcp.start();
-            const tools = await mcp.extractTools();
-            tools.forEach(t => taskSpec.tools?.push(t));
-        }
-    }
-    if (taskSpec.toolsList) {
-        if (!taskSpec?.tools) {
-            taskSpec.tools = [];
-        }
-        for (const toolName of taskSpec.toolsList) {
-            const { found, tool, type } = readTool(toolName);
-            if (!found) {
-                throw new Error(`tool ${toolName} not found for task ${taskSpec.name}`);
-            }
-            const lmTool = {
-                ...tool,
-                execute: async (params) => {
-                    switch (type) {
-                        case "action":
-                            const res = await executeAction(toolName, params, options, true);
-                            return res;
-                        case "task":
-                            conf.quiet = !options?.debug;
-                            const tres = await executeTask(name, params, options, true);
-                            return tres.answer.text;
-                        case "workflow":
-                            const wres = await executeWorkflow(toolName, params, options);
-                            return wres;
-                        default:
-                            throw new Error(`unknown tool execution function type: ${type} for ${toolName}`);
-                    }
-                }
-            };
-            taskSpec.tools.push(lmTool);
-        }
-        delete taskSpec.toolsList;
-    }
-    ;
-    const task = taskBuilder.init(taskSpec);
+    const { task, model, conf, vars, mcpServers } = await readTask(name, payload, options);
     if (model?.inferParams?.tsGrammar) {
         model.inferParams.grammar = serializeGrammar(await compile(model.inferParams.tsGrammar, "Grammar"));
         delete model.inferParams.tsGrammar;
     }
-    if (options.debug) {
+    if (options?.debug) {
         console.log("Task model:", model);
     }
     const ex = expert ?? brain.getOrCreateExpertForModel(model.name, model.template);
@@ -194,10 +117,11 @@ async function executeTask(name, payload, options, quiet, expert) {
     else {
         ex.backend.setOnToken(processToken);
     }
+    conf.inferParams.stream = true;
     const tconf = {
         expert: ex,
         model: model,
-        debug: options.debug,
+        debug: options?.debug ?? false,
         onToolCall: onToolCall,
         ...conf,
     };

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

@@ -58,20 +58,25 @@ function configureTaskModel(itConf, taskSpec) {
         const m = readModel(modelName);
         if (m.found) {
             model = m.modelData;
-            model.template = m.modelData.template;
+            model.template = templateName ?? m.modelData.template;
             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"`);
+        if (templateName && modelName) {
+            model = { name: modelName, template: templateName };
+        }
+        else {
+            const gt = tfm.guess(modelName);
+            if (gt == "none") {
+                throw new Error(`Unable to guess the template for ${modelName}: please provide a template name: --tpl templatename`);
+            }
+            const m = {
+                name: modelName,
+                template: gt
+            };
+            model = m;
         }
-        const m = {
-            name: modelName,
-            template: gt
-        };
-        model = m;
     }
     model.inferParams = ip;
     if (!model?.ctx || !isModelFromTaskFile) {

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

@@ -0,0 +1,12 @@
+import { LmTaskInput, LmTaskOutput, ModelSpec } from "../../../../../lmtask/dist/main.js";
+import { McpClient } from "../mcp.js";
+import { AgentTask } from "@agent-smith/jobs/dist/interfaces.js";
+import { FeatureType, LmTaskConfig } from "../../../interfaces.js";
+declare function readTask(name: string, payload: Record<string, any>, options: Record<string, any>): Promise<{
+    task: AgentTask<FeatureType, LmTaskInput, LmTaskOutput, Record<string, any>>;
+    model: ModelSpec;
+    conf: LmTaskConfig;
+    vars: Record<string, any>;
+    mcpServers: Array<McpClient>;
+}>;
+export { readTask };

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

@@ -0,0 +1,90 @@
+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 { configureTaskModel, mergeInferParams } from "./conf.js";
+import { openTaskSpec } from "./utils.js";
+import { executeTask } from "./cmd.js";
+async function readTask(name, payload, options) {
+    if (options?.debug) {
+        console.log("Payload:", payload);
+        console.log("Task options:", options);
+    }
+    const taskFileSpec = openTaskSpec(name);
+    const opts = payload?.inferParams ? { ...options, ...payload.inferParams } : options;
+    const conf = parseTaskConfigOptions(opts);
+    if (options?.debug) {
+        console.log("conf:", conf);
+    }
+    conf.inferParams = mergeInferParams(conf.inferParams, taskFileSpec.inferParams ?? {});
+    const model = configureTaskModel(conf, taskFileSpec);
+    if (options?.ctx) {
+        model.ctx = options.ctx;
+    }
+    const taskSpec = taskFileSpec;
+    let vars = {};
+    taskSpec.variables?.optional?.forEach(k => {
+        if (k in options) {
+            vars[k] = options[k];
+        }
+    });
+    taskSpec.variables?.required?.forEach(k => {
+        if (k in options) {
+            vars[k] = options[k];
+        }
+    });
+    const mcpServers = new Array();
+    if (taskFileSpec?.mcp) {
+        taskSpec.tools = [];
+        for (const [servername, tool] of Object.entries(taskFileSpec.mcp)) {
+            const mcp = new McpClient(servername, tool.command, tool.args, tool?.tools ?? null);
+            mcpServers.push(mcp);
+            await mcp.start();
+            const tools = await mcp.extractTools();
+            tools.forEach(t => taskSpec.tools?.push(t));
+        }
+    }
+    if (taskSpec.toolsList) {
+        if (!taskSpec?.tools) {
+            taskSpec.tools = [];
+        }
+        for (const toolName of taskSpec.toolsList) {
+            const { found, tool, type } = readTool(toolName);
+            if (!found) {
+                throw new Error(`tool ${toolName} not found for task ${taskSpec.name}`);
+            }
+            const lmTool = {
+                ...tool,
+                execute: async (params) => {
+                    switch (type) {
+                        case "action":
+                            const res = await executeAction(toolName, params, options, true);
+                            return res;
+                        case "task":
+                            conf.quiet = !options?.debug;
+                            const tres = await executeTask(name, params, options, true);
+                            return tres.answer.text;
+                        case "workflow":
+                            const wres = await executeWorkflow(toolName, params, options);
+                            return wres;
+                        default:
+                            throw new Error(`unknown tool execution function type: ${type} for ${toolName}`);
+                    }
+                }
+            };
+            taskSpec.tools.push(lmTool);
+        }
+        delete taskSpec.toolsList;
+    }
+    ;
+    const task = taskBuilder.init(taskSpec);
+    if (model?.inferParams?.tsGrammar) {
+        model.inferParams.grammar = serializeGrammar(await compile(model.inferParams.tsGrammar, "Grammar"));
+        delete model.inferParams.tsGrammar;
+    }
+    return { task, model, conf, vars, mcpServers };
+}
+export { readTask };

package/dist/cmd/lib/tools.js

@@ -42,7 +42,7 @@ function _extractYamlToolDoc(filePath, name) {
     if (!found) {
         return { found: false, tspec: {} };
     }
-    if (!data.tool) {
+    if (!data?.tool) {
         return { found: false, tspec: {} };
     }
     data.tool.name = name;
@@ -78,7 +78,7 @@ function extractTaskToolDocAndVariables(name, ext, dirPath) {
     if (!found) {
         throw new Error(`extractTaskToolDocAndVariables: file ${fp} not found`);
     }
-    if (data.tool) {
+    if (data?.tool) {
         data.tool.name = name;
         tspec = data.tool;
         res.toolDoc = JSON.stringify(tspec, null, "  ");

package/dist/conf.js

@@ -1,6 +1,6 @@
 import path from "path";
 import { readConf } from "./cmd/sys/read_conf.js";
-import { insertFeaturesPathIfNotExists, insertPluginIfNotExists } from "./db/write.js";
+import { upsertBackend, insertFeaturesPathIfNotExists, insertPluginIfNotExists } from "./db/write.js";
 import { buildPluginsPaths } from "./state/plugins.js";
 import { runtimeError } from "./cmd/lib/user_msgs.js";
 const confDir = path.join(process.env.HOME, ".config/agent-smith/cli");
@@ -10,7 +10,19 @@ async function processConfPath(confPath) {
     if (!found) {
         runtimeError(`Config file ${confPath} not found`);
     }
+    console.log(data);
     const allPaths = new Array();
+    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);
+        }
+    }
     if (data?.features) {
         allPaths.push(...data.features);
         const fts = new Array();

package/dist/db/read.d.ts

@@ -1,6 +1,7 @@
 import { ToolSpec } from "modprompt";
 import { AliasType, FeatureSpec, FeatureType, DbModelDef, ToolType } from "../interfaces.js";
 declare function readFeaturePaths(): Array<string>;
+declare function readBackends(): Array<Record<string, string>>;
 declare function readPlugins(): Array<Record<string, string>>;
 declare function readFeaturesType(type: FeatureType): Record<string, FeatureSpec>;
 declare function readFeatures(): Record<FeatureType, Record<string, FeatureSpec>>;
@@ -31,4 +32,4 @@ declare function readModel(shortname: string): {
     found: boolean;
     modelData: Record<string, any>;
 };
-export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readFilePath, readFilePaths, readTool, readModels, readModelfiles, readModel, readFeaturesType, };
+export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readFilePath, readFilePaths, readTool, readModels, readModelfiles, readModel, readFeaturesType, readBackends, };

package/dist/db/read.js

@@ -8,6 +8,15 @@ function readFeaturePaths() {
     });
     return f;
 }
+function readBackends() {
+    const stmt = db.prepare("SELECT name, type, uri, apiKey FROM backend");
+    const data = stmt.all();
+    let f = new Array();
+    data.forEach((row) => {
+        f.push({ name: row.name, type: row.type, uri: row.uri, apiKey: row.apiKey });
+    });
+    return f;
+}
 function readPlugins() {
     const stmt = db.prepare("SELECT name, path FROM plugin");
     const data = stmt.all();
@@ -135,4 +144,4 @@ function readModel(shortname) {
     }
     return { found: false, modelData: {} };
 }
-export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readFilePath, readFilePaths, readTool, readModels, readModelfiles, readModel, readFeaturesType, };
+export { readFeatures, readFeaturePaths, readFeature, readPlugins, readAliases, readFilePath, readFilePaths, readTool, readModels, readModelfiles, readModel, readFeaturesType, readBackends, };

package/dist/db/schemas.js

@@ -71,6 +71,13 @@ const model = `CREATE TABLE IF NOT EXISTS model (
     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,
+    type TEXT NOT NULL CHECK ( type IN ('llamacpp', 'koboldcpp', 'ollama') ),
+    uri TEXT NOT NULL,
+    apiKey TEXT
+);`;
 const schemas = [
     filepath,
     featurespath,
@@ -84,5 +91,6 @@ const schemas = [
     model,
     modelfile,
     adaptater,
+    backend,
 ];
 export { schemas };

package/dist/db/write.d.ts

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

package/dist/db/write.js

@@ -13,6 +13,18 @@ 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;
+    }
+    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;
+}
 function insertFeaturesPathIfNotExists(path) {
     const stmt1 = db.prepare("SELECT * FROM featurespath WHERE path = ?");
     const result = stmt1.get(path);
@@ -194,4 +206,4 @@ function upsertFilePath(name, newPath) {
         return true;
     }
 }
-export { updatePromptfilePath, updateDataDirPath, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, updateModels, upsertFilePath, };
+export { updatePromptfilePath, updateDataDirPath, upsertBackend, insertFeaturesPathIfNotExists, insertPluginIfNotExists, updateFeatures, updateAliases, cleanupFeaturePaths, updateModels, upsertFilePath, };

package/dist/index.js

@@ -5,6 +5,7 @@ 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';
 async function main() {
     const nargs = argv.length;
     if (nargs == 2) {
@@ -17,7 +18,8 @@ async function main() {
         }
     }
     await initState();
-    await initAgent();
+    const rmbs = initRemoteBackends();
+    await initAgent(rmbs);
     const program = await buildCmds();
     program.hook('preAction', async (thisCommand, actionCommand) => {
         const options = actionCommand.opts();

package/dist/interfaces.d.ts

@@ -43,11 +43,18 @@ interface Features {
         ext: ModelFileExtension;
     }>;
 }
+interface RemoteBackend {
+    name: string;
+    type: RemoteProviderType;
+    uri: string;
+    apiKey?: string;
+}
 interface ConfigFile {
     promptfile?: string;
     datadir?: string;
     features?: Array<string>;
     plugins?: Array<string>;
+    backends?: Array<RemoteBackend>;
 }
 interface Settings {
     name: string;
@@ -125,4 +132,5 @@ type CmdExtension = "js";
 type ModelFileExtension = "yml";
 type FeatureExtension = TaskExtension | CmdExtension | ActionExtension | WorkflowExtension | ModelFileExtension;
 type AliasType = "task" | "action" | "workflow";
-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, };
+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, };

package/dist/main.d.ts

@@ -7,10 +7,11 @@ 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";
-import { LmTaskConf } from "@agent-smith/lmtask/dist/interfaces.js";
 import { extractToolDoc } from "./cmd/lib/tools.js";
 import { openTaskSpec } from "./cmd/lib/tasks/utils.js";
 import { extractBetweenTags, splitThinking } from "./utils/text.js";
 import { displayOptions, ioOptions, inferenceOptions, allOptions } from "./cmd/options.js";
 import { McpClient } from "./cmd/lib/mcp.js";
-export { execute, run, executeTask, executeAction, executeWorkflow, writeToClipboard, initAgent, initState, pluginDataDir, usePerfTimer, parseCommandArgs, extractToolDoc, LmTaskConf, openTaskSpec, extractBetweenTags, splitThinking, displayOptions, ioOptions, inferenceOptions, allOptions, McpClient, };
+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, };

package/dist/main.js

@@ -12,4 +12,5 @@ import { openTaskSpec } from "./cmd/lib/tasks/utils.js";
 import { extractBetweenTags, splitThinking } from "./utils/text.js";
 import { displayOptions, ioOptions, inferenceOptions, allOptions } from "./cmd/options.js";
 import { McpClient } from "./cmd/lib/mcp.js";
-export { execute, run, executeTask, executeAction, executeWorkflow, writeToClipboard, initAgent, initState, pluginDataDir, usePerfTimer, parseCommandArgs, extractToolDoc, openTaskSpec, extractBetweenTags, splitThinking, displayOptions, ioOptions, inferenceOptions, allOptions, McpClient, };
+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, };

package/dist/state/state.d.ts

@@ -8,6 +8,7 @@ declare const formatMode: import("@vue/reactivity").Ref<FormatMode, FormatMode>;
 declare const isChatMode: 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 isStateReady: import("@vue/reactivity").Ref<boolean, boolean>;
 declare const lastCmd: {
     name: string;
     args: Array<string>;
@@ -15,4 +16,4 @@ declare const lastCmd: {
 declare function initFilepaths(): void;
 declare function initState(): Promise<void>;
 declare function pluginDataDir(pluginName: string): string;
-export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, promptfilePath, dataDirPath, pluginDataDir, initState, initFilepaths, pyShell, };
+export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, promptfilePath, dataDirPath, isStateReady, pluginDataDir, initState, initFilepaths, pyShell, };

package/dist/state/state.js

@@ -48,4 +48,4 @@ function pluginDataDir(pluginName) {
     createDirectoryIfNotExists(pluginDatapath);
     return pluginDatapath;
 }
-export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, promptfilePath, dataDirPath, pluginDataDir, initState, initFilepaths, pyShell, };
+export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, promptfilePath, dataDirPath, isStateReady, pluginDataDir, initState, initFilepaths, 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.70",
+  "version": "0.0.71",
   "scripts": {
     "buildrl": "rm -rf dist/* && rollup -c",
     "build": "rm -rf dist/* && tsc",
@@ -10,9 +10,9 @@
     "watch": "tsc --noCheck -p . -w"
   },
   "dependencies": {
-    "@agent-smith/brain": "^0.0.44",
+    "@agent-smith/brain": "^0.0.46",
     "@agent-smith/jobs": "^0.0.14",
-    "@agent-smith/lmtask": "^0.0.46",
+    "@agent-smith/lmtask": "^0.0.47",
     "@agent-smith/tfm": "^0.1.2",
     "@inquirer/prompts": "^7.5.3",
     "@inquirer/select": "^4.2.3",