@agent-smith/cli 0.0.96 → 0.0.98

package/dist/cli.js

@@ -7,7 +7,7 @@ async function query(program) {
     const args = q.split(" ");
     await program.parseAsync(args, { from: "user" });
     if (isChatMode.value) {
-        await chat(program);
+        await chat(program, {});
     }
     await query(program);
 }

package/dist/cmd/cmds.d.ts

@@ -1,6 +1,7 @@
+import { InferenceOptions } from "@locallm/types/dist/inference.js";
 import { Command } from "commander";
 declare const program: Command;
-declare function chat(program: Command): Promise<void>;
+declare function chat(program: Command, options: InferenceOptions): Promise<void>;
 declare function buildCmds(): Promise<Command>;
 declare function parseCmd(program: Command): Promise<void>;
-export { program, buildCmds, chat, parseCmd, };
+export { buildCmds, chat, parseCmd, program };

package/dist/cmd/cmds.js

@@ -1,15 +1,14 @@
 import { input } from "@inquirer/prompts";
-import { toRaw } from "@vue/reactivity";
 import { Command } from "commander";
 import { query } from "../cli.js";
 import { readAliases, readFeatures } from "../db/read.js";
-import { chatInferenceParams } from "../state/chat.js";
+import { chatInferenceParams, chatTemplate } from "../state/chat.js";
 import { agent, isChatMode, runMode } from "../state/state.js";
 import { initCommandsFromAliases } from "./clicmds/aliases.js";
 import { initBaseCommands } from "./clicmds/base.js";
 import { initUserCmds } from "./clicmds/cmds.js";
 const program = new Command();
-async function chat(program) {
+async function chat(program, options) {
     const data = { message: '>', default: "" };
     const prompt = await input(data);
     if (prompt == "/q") {
@@ -21,9 +20,9 @@ async function chat(program) {
             await query(program);
         }
     }
-    await agent.lm.infer(prompt, toRaw(chatInferenceParams));
+    await agent.run(prompt, chatInferenceParams, options, chatTemplate ? chatTemplate : undefined);
     console.log();
-    await chat(program);
+    await chat(program, options);
 }
 async function buildCmds() {
     initBaseCommands(program);
@@ -41,4 +40,4 @@ async function parseCmd(program) {
     program.description('Terminal agents toolkit');
     await program.parseAsync();
 }
-export { program, buildCmds, chat, parseCmd, };
+export { buildCmds, chat, parseCmd, program };

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

@@ -1,19 +1,18 @@
-import { input } from "@inquirer/prompts";
 import { compile, serializeGrammar } from "@intrinsicai/gbnfgen";
 import { default as color, default as colors } from "ansi-colors";
 import { PromptTemplate } from "modprompt";
 import ora from 'ora';
-import { query } from "../../../cli.js";
-import { readClipboard } from "../../../cmd/sys/clipboard.js";
 import { usePerfTimer } from "../../../main.js";
-import { isChatMode, runMode, agent } from "../../../state/state.js";
-import { program } from "../../cmds.js";
+import { backend, backends, listBackends } from "../../../state/backends.js";
+import { setChatInferenceParams, setChatTemplate } from "../../../state/chat.js";
+import { agent, isChatMode } from "../../../state/state.js";
+import { initTaskSettings, isTaskSettingsInitialized, tasksSettings } from "../../../state/tasks.js";
+import { chat, program } from "../../cmds.js";
 import { parseCommandArgs } from "../options_parsers.js";
 import { runtimeDataError, runtimeError, runtimeWarning } from "../user_msgs.js";
-import { formatStats, processOutput, readPromptFile } from "../utils.js";
+import { formatStats, processOutput } from "../utils.js";
 import { readTask } from "./read.js";
-import { backend, backends, listBackends } from "../../../state/backends.js";
-import { isTaskSettingsInitialized, initTaskSettings, tasksSettings } from "../../../state/tasks.js";
+import { getTaskPrompt } from "./utils.js";
 async function executeTask(name, payload, options, quiet) {
     if (!isTaskSettingsInitialized.value) {
         initTaskSettings();
@@ -99,7 +98,12 @@ async function executeTask(name, payload, options, quiet) {
             process.stdout.write(t);
         }
     };
-    const hasTools = options?.tools;
+    let hasTools = false;
+    if (task.def?.tools) {
+        if (task.def.tools.length > 0) {
+            hasTools = true;
+        }
+    }
     let continueWrite = true;
     let skipNextEmptyLinesToken = false;
     const spinner = ora("Thinking ...");
@@ -147,10 +151,8 @@ async function executeTask(name, payload, options, quiet) {
                 return;
             }
             else if (t == tpl.tags.toolCall?.end) {
-                if (options?.verbose === true) {
-                    skipNextEmptyLinesToken = true;
-                    continueWrite = true;
-                }
+                skipNextEmptyLinesToken = true;
+                continueWrite = true;
                 return;
             }
         }
@@ -194,6 +196,8 @@ async function executeTask(name, payload, options, quiet) {
         onToolCallEnd: onToolCallEnd,
         ...conf,
     };
+    const initialInferParams = Object.assign({}, conf.inferParams);
+    initialInferParams.model = tconf.model;
     let out;
     try {
         out = await task.run({ prompt: payload.prompt, ...vars }, tconf);
@@ -225,20 +229,23 @@ async function executeTask(name, payload, options, quiet) {
     mcpServers.forEach(async (s) => await s.stop());
     await processOutput(out);
     if (isChatMode.value) {
-        const data = { message: '>', default: "" };
-        const prompt = await input(data);
-        if (prompt == "/q") {
-            isChatMode.value = false;
-            if (runMode.value == "cmd") {
-                process.exit(0);
-            }
-            else {
-                await query(program);
-            }
+        if (tpl) {
+            setChatTemplate(tpl);
         }
-        else {
-            await executeTask(name, { ...vars, prompt: prompt }, options, quiet);
+        if (task.def.tools) {
+            options.tools = task.def.tools;
         }
+        if (task.def.shots) {
+            options.history = task.def.shots;
+        }
+        if (task.def.template?.system) {
+            options.system = task.def.template.system;
+        }
+        if (task.def.template?.assistant) {
+            options.assistant = task.def.template.assistant;
+        }
+        setChatInferenceParams(initialInferParams);
+        await chat(program, options);
     }
     if (options?.debug === true || options?.verbose === true) {
         try {
@@ -257,24 +264,8 @@ async function executeTask(name, payload, options, quiet) {
     return out;
 }
 async function executeTaskCmd(name, targs = []) {
-    const { args, options } = parseCommandArgs(targs);
-    let pr;
-    if (options?.clipboardInput === true) {
-        pr = await readClipboard();
-    }
-    else if (options?.inputFile === true) {
-        pr = readPromptFile();
-    }
-    else {
-        if (args[0] !== undefined) {
-            pr = args[0];
-        }
-        else {
-            runtimeDataError("task", name, "provide a prompt or use input options");
-            throw new Error();
-        }
-    }
-    const params = { args: args, prompt: pr };
-    return await executeTask(name, params, options);
+    const ca = parseCommandArgs(targs);
+    const prompt = await getTaskPrompt(name, ca.args, ca.options);
+    return await executeTask(name, { prompt: prompt }, ca.options);
 }
 export { executeTask, executeTaskCmd };

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

@@ -92,6 +92,7 @@ async function readTask(name, payload, options, agent) {
     }
     ;
     const task = new Task(agent, taskSpec);
+    task.addTools(taskSpec.tools);
     if (model?.inferParams?.tsGrammar) {
         model.inferParams.grammar = serializeGrammar(await compile(model.inferParams.tsGrammar, "Grammar"));
         delete model.inferParams.tsGrammar;

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

@@ -1,3 +1,4 @@
 import { LmTaskFileSpec } from "../../../interfaces.js";
 declare function openTaskSpec(name: string): LmTaskFileSpec;
-export { openTaskSpec, };
+declare function getTaskPrompt(name: string, args: Array<string>, options: Record<string, any>): Promise<string>;
+export { openTaskSpec, getTaskPrompt, };

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

@@ -1,6 +1,9 @@
 import YAML from 'yaml';
 import { readTask } from "../../../cmd/sys/read_task.js";
 import { getFeatureSpec } from "../../../state/features.js";
+import { readClipboard } from '../../../cmd/sys/clipboard.js';
+import { readPromptFile } from '../utils.js';
+import { runtimeDataError } from '../user_msgs.js';
 function openTaskSpec(name) {
     const { found, path } = getFeatureSpec(name, "task");
     if (!found) {
@@ -14,4 +17,23 @@ function openTaskSpec(name) {
     taskFileSpec.name = name;
     return taskFileSpec;
 }
-export { openTaskSpec, };
+async function getTaskPrompt(name, args, options) {
+    let pr;
+    if (options?.clipboardInput === true) {
+        pr = await readClipboard();
+    }
+    else if (options?.inputFile === true) {
+        pr = readPromptFile();
+    }
+    else {
+        if (args[0] !== undefined) {
+            pr = args[0];
+        }
+        else {
+            runtimeDataError("task", name, "provide a prompt or use input options");
+            throw new Error();
+        }
+    }
+    return pr;
+}
+export { openTaskSpec, getTaskPrompt, };

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

@@ -1,3 +1,3 @@
-declare function executeWorkflow(name: string, args: any, options?: Record<string, any>): Promise<any>;
+declare function executeWorkflow(wname: string, args: any, options?: Record<string, any>): Promise<any>;
 declare function executeWorkflowCmd(name: string, wargs: Array<any>): Promise<any>;
 export { executeWorkflow, executeWorkflowCmd, };

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

@@ -2,30 +2,51 @@ import { executeAction } from "../actions/cmd.js";
 import { executeAdaptater } from "../adaptaters/cmd.js";
 import { parseCommandArgs } from "../options_parsers.js";
 import { executeTask } from "../tasks/cmd.js";
+import { getTaskPrompt } from "../tasks/utils.js";
 import { readWorkflow } from "./read.js";
 import colors from "ansi-colors";
-async function executeWorkflow(name, args, options = {}) {
-    const { workflow, found } = await readWorkflow(name);
+async function executeWorkflow(wname, args, options = {}) {
+    const { workflow, found } = await readWorkflow(wname);
     if (!found) {
-        throw new Error(`Workflow ${name} not found`);
+        throw new Error(`Workflow ${wname} not found`);
     }
     const isDebug = options?.debug === true;
     const isVerbose = options?.verbose === true;
     const stepNames = Object.keys(workflow);
     if (isDebug || isVerbose) {
-        console.log("Running workflow", name, stepNames.length, "steps");
+        console.log("Running workflow", wname, stepNames.length, "steps");
     }
     let i = 0;
     const finalTaskIndex = stepNames.length - 1;
     let taskRes = { cmdArgs: args };
-    for (const [name, step] of Object.entries(workflow)) {
+    let prevStepType = null;
+    for (const step of workflow) {
         if (isDebug || isVerbose) {
-            console.log(i + 1, name, colors.dim(step.type));
+            console.log(i + 1, step.name, colors.dim(step.type));
         }
         switch (step.type) {
             case "task":
                 try {
-                    const tr = await executeTask(name, taskRes, options, true);
+                    let pr = null;
+                    if (i == 0) {
+                        pr = await getTaskPrompt(step.name, taskRes.cmdArgs, options);
+                    }
+                    else {
+                        if (prevStepType) {
+                            if (prevStepType == "task") {
+                                pr = taskRes.answer.text;
+                            }
+                        }
+                        if (!pr) {
+                            if (taskRes?.prompt) {
+                                pr = taskRes.prompt;
+                            }
+                        }
+                    }
+                    if (!pr) {
+                        throw new Error(`Workflow ${wname} step ${i + 1}: provide a prompt for the task ${step.name}`);
+                    }
+                    const tr = await executeTask(step.name, { prompt: pr }, options, true);
                     taskRes = { ...tr, ...taskRes };
                 }
                 catch (e) {
@@ -35,7 +56,7 @@ async function executeWorkflow(name, args, options = {}) {
             case "action":
                 try {
                     const actArgs = i == 0 ? taskRes.cmdArgs : taskRes;
-                    const ares = await executeAction(name, actArgs, options, true);
+                    const ares = await executeAction(step.name, actArgs, options, true);
                     if (typeof ares == "string" || Array.isArray(ares)) {
                         taskRes.args = ares;
                     }
@@ -53,7 +74,7 @@ async function executeWorkflow(name, args, options = {}) {
             case "adaptater":
                 try {
                     const actArgs = i == 0 ? taskRes.cmdArgs : taskRes;
-                    const adres = await executeAdaptater(name, actArgs, options);
+                    const adres = await executeAdaptater(step.name, actArgs, options);
                     if (typeof adres == "string" || Array.isArray(adres)) {
                         taskRes.args = adres;
                     }
@@ -71,6 +92,7 @@ async function executeWorkflow(name, args, options = {}) {
             default:
                 throw new Error(`unknown task type ${step.type} in workflow ${name}`);
         }
+        prevStepType = step.type;
         ++i;
     }
     return taskRes;

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

@@ -1,6 +1,6 @@
 import { WorkflowStep } from '../../../interfaces.js';
 declare function readWorkflow(name: string): Promise<{
     found: boolean;
-    workflow: Record<string, WorkflowStep>;
+    workflow: Array<WorkflowStep>;
 }>;
 export { readWorkflow };

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/db/write.js

@@ -297,7 +297,6 @@ function upsertTaskSettings(taskName, settings) {
         const nq = new Array("?");
         qnames.forEach(n => nq.push("?"));
         const q = `INSERT INTO tasksettings (name, ${qnames.join(", ")}) VALUES (${nq.join(", ")})`;
-        console.log(q);
         const insertStmt = db.prepare(q);
         insertStmt.run(taskName, ...qvalues);
         return true;

package/dist/interfaces.d.ts

@@ -98,6 +98,7 @@ interface FinalLmTaskConfig {
     modelname?: string;
 }
 interface WorkflowStep {
+    name: string;
     type: string;
     run: FeatureExecutor;
 }

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/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.96",
+  "version": "0.0.98",
   "scripts": {
     "buildrl": "rm -rf dist/* && rollup -c",
     "build": "rm -rf dist/* && tsc",
@@ -10,20 +10,19 @@
     "watch": "tsc --noCheck -p . -w"
   },
   "dependencies": {
-    "@agent-smith/agent": "^0.1.5",
-    "@agent-smith/task": "^0.1.7",
+    "@agent-smith/agent": "^0.1.8",
+    "@agent-smith/task": "^0.1.9",
     "@agent-smith/tfm": "^0.2.0",
-    "@inquirer/prompts": "^7.10.1",
+    "@inquirer/prompts": "^8.1.0",
     "@intrinsicai/gbnfgen": "0.12.0",
-    "@locallm/api": "^0.7.2",
-    "@modelcontextprotocol/sdk": "^1.24.3",
-    "@vue/reactivity": "^3.5.25",
+    "@locallm/api": "^0.7.3",
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "@vue/reactivity": "^3.5.26",
     "ansi-colors": "^4.1.3",
     "better-sqlite3": "^12.5.0",
     "clipboardy": "^5.0.2",
     "commander": "^14.0.2",
     "marked-terminal": "^7.3.0",
-    "modprompt": "^0.12.6",
     "ora": "^9.0.0",
     "python-shell": "^5.0.0",
     "yaml": "^2.8.2"
@@ -32,15 +31,15 @@
     "@agent-smith/tmem-jobs": "^0.0.4",
     "@cfworker/json-schema": "^4.1.1",
     "@commander-js/extra-typings": "^14.0.0",
-    "@locallm/types": "^0.6.4",
+    "@locallm/types": "^0.6.5",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-typescript": "^12.3.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/marked-terminal": "^6.1.1",
-    "@types/node": "^25.0.2",
-    "openai": "^6.10.0",
+    "@types/node": "^25.0.3",
+    "openai": "^6.15.0",
     "restmix": "^0.6.1",
-    "rollup": "^4.53.3",
+    "rollup": "^4.54.0",
     "ts-node": "^10.9.2",
     "tslib": "2.8.1",
     "typescript": "^5.9.3"