@agent-smith/cli 0.0.108 → 0.0.110

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

@@ -15,6 +15,9 @@ import { readTask } from "./read.js";
 import { getTaskPrompt } from "./utils.js";
 import { Agent } from "@agent-smith/agent";
 async function executeTask(name, payload, options) {
+    //console.log("EXEC TASK", payload, options);
+    //console.log("TN", name);
+    //console.log("AGENT", agent);
     if (!isTaskSettingsInitialized.value) {
         initTaskSettings();
     }
@@ -27,6 +30,7 @@ async function executeTask(name, payload, options) {
     if (options?.backend) {
         if (options.backend in backends) {
             agent.lm = backends[options.backend];
+            //console.log("SET AGENT BACKEND TO", backends[options.backend]);
         }
         else {
             const bks = await listBackends(false);
@@ -34,6 +38,7 @@ async function executeTask(name, payload, options) {
         }
     }
     else if (settings?.backend) {
+        //console.log("SET AGENT BACKEND TO", backends[options.backend]);
         agent.lm = backends[settings.backend];
     }
     if (options?.debug || options?.backend) {
@@ -51,6 +56,7 @@ async function executeTask(name, payload, options) {
             console.log("MCP start", mcp.name);
         }
     }
+    //console.log("TASKCONF IP", conf.inferParams);
     if (hasSettings) {
         if (!model?.inferParams) {
             model.inferParams = {};
@@ -83,14 +89,19 @@ async function executeTask(name, payload, options) {
             model.inferParams.repeat_penalty = settings.repeat_penalty;
         }
     }
+    //console.log("TASK MODEL", model);
+    // check for grammars
     if (model?.inferParams?.tsGrammar) {
+        //console.log("TSG");
         model.inferParams.grammar = serializeGrammar(await compile(model.inferParams.tsGrammar, "Grammar"));
         delete model.inferParams.tsGrammar;
     }
+    //let i = 0;
     let c = false;
     const useTemplates = agent.lm.providerType !== "openai";
     let hasThink = false;
     let tpl = null;
+    //console.log("Use templates:", useTemplates);
     if (useTemplates) {
         try {
             tpl = new PromptTemplate(model.template ?? "none");
@@ -98,12 +109,19 @@ async function executeTask(name, payload, options) {
         catch (e) {
             throw new Error(`Can not load template ${model.template}\nAvailable templates: ${Object.keys(templates)}\n`);
         }
+        //console.log("TPL:", tpl.id);
         hasThink = tpl.tags?.think ? true : false;
+        //console.log("HT", hasThink);
     }
     if (options?.debug) {
         console.log("Task model:", model);
         console.log("Task vars:", vars);
     }
+    //const hasTools = ex.template?.tags?.toolCall;
+    //console.log("EX TPL", ex.template);
+    //console.log("ST", thinkStart);
+    //console.log("ET", thinkEnd);
+    //let fullTxt = ""
     let emittedTokens = 0;
     const printToken = (t) => {
         if (options?.tokens === true) {
@@ -113,7 +131,13 @@ async function executeTask(name, payload, options) {
             c = !c;
         }
         else {
+            /*if (formatMode.value == "markdown") {
+                fullTxt += t;
+                process.stdout.write('\u001Bc\u001B[3J');
+                process.stdout.write(marked.parse(fullTxt) as string);*/
+            //} else {
             process.stdout.write(t);
+            //}
         }
     };
     let hasTools = false;
@@ -122,6 +146,7 @@ async function executeTask(name, payload, options) {
             hasTools = true;
         }
     }
+    //console.log("HAS TOOLS", hasTools);
     let continueWrite = true;
     let skipNextEmptyLinesToken = false;
     const spinner = ora("Thinking ...");
@@ -131,19 +156,30 @@ async function executeTask(name, payload, options) {
         return `${ts} ${color.bold(i.toString())} ${te}`;
     };
     const perfTimer = usePerfTimer(false);
+    let abort = options?.abort ? options.abort : new AbortController();
+    setInterval(() => {
+        //console.log("ABS", abort.signal.aborted);
+        if (abort.signal.aborted) {
+            agent.lm.abort();
+            abort = new AbortController();
+        }
+    }, 200);
     const processToken = (t) => {
         if (emittedTokens == 0) {
             perfTimer.start();
         }
         spinner.text = formatTokenCount(emittedTokens);
         if (!options?.verbose && !options?.debug) {
+            //console.log("TTTTTT", hasThink && tpl);
             if (hasThink && tpl) {
                 if (t == tpl.tags.think?.start) {
+                    //console.log("Start thinking token", thinkStart);
                     spinner.start();
                     continueWrite = false;
                     return;
                 }
                 else if (t == tpl.tags.think?.end) {
+                    //console.log("End thinking token", thinkEnd);
                     continueWrite = true;
                     skipNextEmptyLinesToken = true;
                     let msg = color.dim("Thinking:") + ` ${emittedTokens} ${color.dim("tokens")}`;
@@ -163,6 +199,7 @@ async function executeTask(name, payload, options) {
             }
         }
         if (hasTools && tpl) {
+            // check for tool call and silence the output
             if (t == tpl.tags.toolCall?.start) {
                 if (!options?.debug) {
                     continueWrite = false;
@@ -200,14 +237,24 @@ async function executeTask(name, payload, options) {
         }
         ++emittedTokens;
     };
-    const onToolCall = (tc) => {
+    //const spinnerInit = (name: string) => ora(`Executing the ${name} tool ...\n`);
+    //let tcspinner: Ora;
+    const _onToolCall = (tc) => {
+        //console.log("TC START");
         console.log("⚒️ ", color.bold(name), "=>", `${color.yellowBright(tc.name)}`, tc.arguments);
     };
-    const onToolCallEnd = (tr) => {
+    const onToolCall = options?.onToolCall ?? _onToolCall;
+    const _onToolCallEnd = (tr) => {
         if (options?.debug) {
             console.log(tr);
         }
     };
+    const onToolCallEnd = options?.onToolCallEnd ?? _onToolCallEnd;
+    const onToolsTurnStart = options?.onToolsTurnStart ?? undefined;
+    const onToolsTurnEnd = options?.onToolsTurnEnd ?? undefined;
+    const onTurnEnd = options?.onTurnEnd ?? undefined;
+    const onAssistant = options?.onAssistant ?? undefined;
+    //console.log("OOT", options?.onToken, "/", processToken);
     if (options?.onToken) {
         task.agent.lm.onToken = options.onToken;
     }
@@ -224,47 +271,73 @@ async function executeTask(name, payload, options) {
     const tconf = {
         baseDir: taskDir,
         model: model,
+        //debug: options?.debug ?? false,
         onToolCall: onToolCall,
         onToolCallEnd: onToolCallEnd,
+        onToolsTurnStart: onToolsTurnStart,
+        onToolsTurnEnd: onToolsTurnEnd,
+        onTurnEnd: onTurnEnd,
+        onAssistant: onAssistant,
         ...conf,
     };
+    if (options?.history) {
+        agent.history = options.history;
+    }
     const initialInferParams = Object.assign({}, conf.inferParams);
     initialInferParams.model = tconf.model;
+    //console.log("CONF", conf);
+    //console.log("TCONF", tconf);
+    //console.log("RUN", task);
     let out;
+    //console.log("CLI EXEC TASK", payload.prompt, "\nVARS:", vars, "\nOPTS", tconf)
     try {
         out = await task.run({ prompt: payload.prompt, ...vars }, tconf);
     }
     catch (e) {
+        console.log("ERR CATCH", e);
         const errMsg = `${e}`;
         if (errMsg.includes("502 Bad Gateway")) {
             runtimeError("The server answered with a 502 Bad Gateway error. It might be down or misconfigured. Check your inference server.");
             if (options?.debug) {
                 throw new Error(errMsg);
             }
+            //@ts-ignore
             return;
         }
         else if (errMsg.includes("404 Not Found")) {
             runtimeError("The server answered with a 404 Not Found error. That might mean that the model you are requesting does not exist on the server.");
+            //@ts-ignore
             return;
         }
         else if (errMsg.includes("400 Bad Request")) {
-            runtimeError("The server answered with a 400 Bad Request error. That might mean that the model you are requesting does not exist on the server or a parameter is missing in your request.");
+            runtimeError("The server answered with a 400 Bad Request error. That might mean that the model you are requesting does not exist on the server, a parameter is wrong or missing in your request.");
+            //@ts-ignore
             return;
         }
         else if (errMsg.includes("fetch failed")) {
             runtimeError("The server is not responding. Check if your inference backend is running.");
+            //@ts-ignore
             return;
         }
+        else if (e instanceof DOMException && e.name === 'AbortError') {
+            if (options?.debug || options?.verbose) {
+                console.log("The request was canceled by the user");
+            }
+            return {};
+        }
         else {
             throw new Error(errMsg);
         }
     }
+    //console.log("END TASK", out);
     if (!options?.isToolCall) {
         if (!out.answer.text.endsWith("\n")) {
             console.log();
         }
     }
+    //console.log("END", name, "ISCM", isChatMode.value, "isTC", options?.isToolCall)
     if (!isChatMode.value || options?.isToolCall) {
+        // close mcp connections
         if (options?.debug && mcpServers.length > 0) {
             console.log("Closing", mcpServers.length, "mcp server(s)");
         }
@@ -276,6 +349,8 @@ async function executeTask(name, payload, options) {
         });
     }
     await processOutput(out);
+    // chat mode
+    //console.log("CLI CONF IP", initialInferParams);
     if (!options?.isToolCall && isChatMode.value) {
         if (tpl) {
             setChatTemplate(tpl);
@@ -284,11 +359,14 @@ async function executeTask(name, payload, options) {
             options.tools = task.def.tools;
         }
         if (task.def.shots) {
-            options.history = task.def.shots;
+            options.history = options?.history ? [...options.history, ...task.def.shots] : task.def.shots;
         }
         if (task.def.template?.system) {
             options.system = task.def.template.system;
         }
+        /*if (task.def.template?.afterSystem) {
+            options.system = (tpl?.system ?? "") + task.def.template.afterSystem
+        }*/
         if (task.def.template?.assistant) {
             options.assistant = task.def.template.assistant;
         }
@@ -298,6 +376,7 @@ async function executeTask(name, payload, options) {
     if (options?.debug === true || options?.verbose === true) {
         try {
             console.log(emittedTokens.toString(), color.dim("tokens"), out.answer.stats.tokensPerSecond, color.dim("tps"));
+            //console.log("\n", formatStats(out.answer.stats))
             if (options?.debug === true) {
                 console.log(out.answer.stats);
             }
@@ -307,13 +386,19 @@ async function executeTask(name, payload, options) {
         }
     }
     if (options?.backend || settings?.backend) {
+        //console.log("SET BACK AGENT BACKEND TO", backend.value);
+        // set back the default backend
         agent.lm = backend.value;
     }
+    //console.log("TASK OUT", out);
     return out;
 }
 async function executeTaskCmd(name, targs = []) {
     const ca = parseCommandArgs(targs);
+    //console.log("ARGS", ca);
     const prompt = await getTaskPrompt(name, ca.args, ca.options);
-    return await executeTask(name, { prompt: prompt }, ca.options);
+    const tr = await executeTask(name, { prompt: prompt }, ca.options);
+    //console.log("TR", tr);
+    return tr;
 }
 export { executeTask, executeTaskCmd };

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

@@ -8,6 +8,10 @@ function guessTemplate(modelname) {
     return gt;
 }
 function configureTaskModel(itConf, taskSpec) {
+    //console.log("IT CONF", itConf);
+    //console.log("TASK SPEC", taskSpec);
+    //let modelName: string = "";
+    //let templateName: string = "";
     let ip = itConf.inferParams;
     let isModelFromTaskFile = false;
     let model = { template: "", name: "" };
@@ -35,12 +39,15 @@ function configureTaskModel(itConf, taskSpec) {
     }
     if (itConf?.model?.name) {
         if (taskSpec?.models && Object.keys(taskSpec.models).includes(itConf.model.name)) {
+            // try to find the model from the task's models
             for (const [k, v] of Object.entries(taskSpec.models)) {
+                //console.log("TSM", modelName, "/", k);
                 if (k == itConf.model.name) {
                     model = v;
                     if (v?.inferParams) {
                         const tip = v.inferParams;
                         for (const [k, v] of Object.entries(tip)) {
+                            // @ts-ignore
                             ip[k] = v;
                         }
                     }
@@ -68,12 +75,39 @@ function configureTaskModel(itConf, taskSpec) {
         model = taskSpec.model;
         foundModel = true;
     }
+    // try to find the models from db models
+    /*if (!found) {
+        const m = readModel(modelName);
+        //console.log("FM", m.found, m)
+        //console.log("DBM", templateName, "/", m.modelData.template);
+        if (m.found) {
+            model = m.modelData as ModelSpec;
+            model.template = templateName ?? m.modelData.template;
+            found = true
+        }
+    }*/
+    // fallback to use the model name directly
     if (!foundModel) {
         throw new Error(`No model found in task`);
     }
+    /*if (!foundTemplate) {
+        // try to guess the template
+        const gt = tfm.guess(model.name);
+        if (gt == "none") {
+            throw new Error(`Unable to guess the template for ${model.name}: please provide a template name: --tpl templatename`)
+        }
+        model.template = gt;
+        foundTemplate = true;
+    }
+    if (!model?.template) {
+        throw new Error(`No template found`)
+    }*/
+    //model.inferParams = ip;
+    // use default ctx if the model is not from defined in the task file
     if (!model?.ctx || !isModelFromTaskFile) {
         model.ctx = taskSpec.ctx;
     }
+    //model.inferParams = ip;
     return model;
 }
 function mergeConfOptions(conf, options) {
@@ -88,6 +122,7 @@ function mergeConfOptions(conf, options) {
 }
 function mergeInferParams(userInferParams, taskInferParams) {
     const ip = taskInferParams;
+    //console.log("IP", ip);
     for (const [k, v] of Object.entries(userInferParams)) {
         ip[k] = v;
     }

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

@@ -18,6 +18,7 @@ async function readTask(name, payload, options, agent) {
     }
     const { taskFileSpec, taskPath } = openTaskSpec(name, options?.isAgent);
     const taskDir = path.dirname(taskPath);
+    // merge passed options from payload
     const opts = payload?.inferParams ? { ...options, ...payload.inferParams } : options;
     const conf = parseTaskConfigOptions(opts);
     if (options?.debug) {
@@ -29,6 +30,7 @@ async function readTask(name, payload, options, agent) {
     if (options?.ctx) {
         model.ctx = options.ctx;
     }
+    // vars
     const taskSpec = taskFileSpec;
     let vars = {};
     if (taskSpec?.variables?.optional) {
@@ -43,6 +45,7 @@ async function readTask(name, payload, options, agent) {
     }
     if (taskSpec?.variables?.required) {
         for (const k of Object.keys(taskSpec.variables.required)) {
+            //console.log("TASK V required:", Object.keys(taskSpec.variables.required), "/", k in options, "/", k in payload);
             if (k in options) {
                 vars[k] = options[k];
             }
@@ -71,8 +74,10 @@ async function readTask(name, payload, options, agent) {
             console.log("Opening", options.mcp.length, "server(s)");
         }
     }
+    // mcp tools
     if (taskFileSpec?.mcp) {
         for (const [servername, tool] of Object.entries(taskFileSpec.mcp)) {
+            //console.log("MCP TOOL:", tool)
             const authorizedTools = new Array();
             const askUserTools = new Array();
             if (tool?.tools) {
@@ -90,9 +95,15 @@ async function readTask(name, payload, options, agent) {
                 margs.push(...mcpServersArgs[servername]);
             }
             const mcp = new McpClient(servername, tool.command, tool.arguments, authorizedTools.length > 0 ? authorizedTools : null, askUserTools.length > 0 ? askUserTools : null);
+            //console.log("MCP", mcp);
             mcpServers.push(mcp);
+            /*await mcp.start();
+            const tools = await mcp.extractTools();
+            tools.forEach(t => taskSpec.tools?.push(t))*/
         }
     }
+    // tools
+    //console.log("Task tools list:", taskSpec.toolsList);
     if (taskSpec.toolsList) {
         for (const rawToolName of taskSpec.toolsList) {
             let toolName = rawToolName;
@@ -105,10 +116,12 @@ async function readTask(name, payload, options, agent) {
             if (!found) {
                 throw new Error(`tool ${toolName} not found for task ${taskSpec.name}`);
             }
+            //console.log("Tool found:", toolName, tool);
             const quiet = !options?.debug;
             const lmTool = {
                 ...tool,
                 execute: async (params) => {
+                    //console.log("EXEC TOOL:", type, toolName, params);
                     switch (type) {
                         case "action":
                             const res = await executeAction(toolName, params, options, quiet);
@@ -118,6 +131,7 @@ async function readTask(name, payload, options, agent) {
                             options.isAgent = false;
                             const tres = await executeTask(toolName, params, options);
                             options.isToolCall = false;
+                            //console.log("WFTRESP", tres.answer.text);
                             return tres.answer.text;
                         case "agent":
                             options.isToolCall = true;
@@ -125,6 +139,7 @@ async function readTask(name, payload, options, agent) {
                             const agres = await executeTask(toolName, params, options);
                             options.isAgent = false;
                             options.isToolCall = false;
+                            //console.log("WFTRESP", tres.answer.text);
                             if (agres?.answer?.text) {
                                 return agres.answer.text;
                             }
@@ -140,18 +155,32 @@ async function readTask(name, payload, options, agent) {
                 }
             };
             if (!autoRunTool) {
-                lmTool.canRun = confirmToolUsage;
+                lmTool.canRun = options?.confirmToolUsage ?
+                    options.confirmToolUsage :
+                    confirmToolUsage;
             }
             taskSpec.tools.push(lmTool);
         }
         delete taskSpec.toolsList;
     }
     ;
+    if (options?.chatMode) {
+        taskSpec.prompt = "{prompt}";
+    }
+    //console.log("TASK SPEC:", JSON.stringify(taskSpec, null, "  "));
     const task = new NodeTask(agent, taskSpec);
+    //task.addTools(taskSpec.tools);
+    //console.log("TASK TOOLS", task.agent.tools);
+    // check for grammars
     if (model?.inferParams?.tsGrammar) {
+        //console.log("TSG");
         model.inferParams.grammar = serializeGrammar(await compile(model.inferParams.tsGrammar, "Grammar"));
         delete model.inferParams.tsGrammar;
     }
+    /*if (options?.debug) {
+        console.log("Task model:", model);
+        //console.log("Task vars:", vars);
+    }*/
     return { task, model, conf, vars, mcpServers, taskDir };
 }
 export { readTask };

package/dist/cmd/lib/tools.js

@@ -2,15 +2,16 @@ import YAML from 'yaml';
 import * as fs from 'fs';
 import { readYmlFile } from '../sys/read_yml_file.js';
 import { confirm } from '@inquirer/prompts';
+import colors from "ansi-colors";
 async function confirmToolUsage(toolCall) {
-    let args;
+    console.log("Tool call:", colors.bold(toolCall.name));
     if (toolCall?.arguments) {
-        args = `with arguments ${JSON.stringify(toolCall.arguments)}`;
+        console.log("Arguments:", toolCall.arguments);
     }
     else {
-        args = "with no arguments";
+        console.log("No arguments");
     }
-    return await confirm({ message: `Execute tool ${toolCall.name} ${args}?` });
+    return await confirm({ message: `Execute tool ${toolCall.name}?` });
 }
 function _extractToolDoc(filePath, startComment, endComment) {
     try {
@@ -50,6 +51,7 @@ function _extractJsToolDoc(filePath) {
 }
 function _extractYamlToolDoc(filePath, name) {
     const { data, found } = readYmlFile(filePath);
+    //console.log("_extractYamlToolDoc from", name, data?.tool);
     if (!found) {
         return { found: false, tspec: {} };
     }
@@ -63,6 +65,7 @@ function _parseToolDoc(rawTxt, name) {
     try {
         const res = YAML.parse(rawTxt);
         res["name"] = name;
+        //console.log("PARSE TOOL DOC", res);
         return res;
     }
     catch (e) {
@@ -85,6 +88,7 @@ function extractTaskToolDocAndVariables(name, ext, dirPath) {
     const fp = dirPath + "/" + name + "." + ext;
     const { data, found } = readYmlFile(fp);
     const res = { variables: { required: new Array(), optional: new Array() }, toolDoc: "" };
+    // tools
     let tspec;
     if (!found) {
         throw new Error(`extractTaskToolDocAndVariables: file ${fp} not found`);
@@ -94,6 +98,7 @@ function extractTaskToolDocAndVariables(name, ext, dirPath) {
         tspec = data.tool;
         res.toolDoc = JSON.stringify(tspec, null, "  ");
     }
+    // variables
     const { required, optional } = _parseTaskVariables(data);
     res.variables.required = required;
     res.variables.optional = optional;
@@ -122,6 +127,7 @@ function extractToolDoc(name, ext, dirPath) {
             break;
         default:
             return { found: false, toolDoc: "" };
+        //throw new Error(`Unknown tool doc feature type`)        
     }
     if (found) {
         let ts;

package/dist/cmd/lib/user_msgs.js

@@ -1,17 +1,18 @@
-import { exit } from "process";
 import chalk from 'chalk';
 function runtimeError(...msg) {
     console.warn("💥", chalk.dim("Runtime error:"), ...msg);
-    exit(1);
+    //exit(1)
 }
 function runtimeWarning(...msg) {
     console.warn("⚠️", chalk.dim("Runtime warning:"), ...msg);
+    //exit(1)
 }
 function runtimeDataError(...msg) {
     console.warn("❌", chalk.dim("Runtime data error:"), ...msg);
-    exit(1);
+    //exit(1)
 }
 function runtimeInfo(...msg) {
+    //console.log("ℹ️ ", chalk.dim("Info:"), ...msg);
     console.log("📫", chalk.dim("Info:"), ...msg);
 }
 export { runtimeError, runtimeWarning, runtimeDataError, runtimeInfo, };

package/dist/cmd/lib/utils.js

@@ -11,10 +11,13 @@ function readPromptFile() {
     return readFile(promptfilePath.value);
 }
 async function processOutput(res) {
+    //if (!(outputMode.value == "clipboard")) { return }
     let data = "";
+    //console.log("Process OUTPUT", typeof res);
     let hasTextData = false;
     if (typeof res == "object") {
         if (res?.answer?.text) {
+            //console.log("****************** TPL", res?.answer?.template);
             if (res?.template?.tags?.think) {
                 const { finalAnswer } = splitThinking(res.answer.text, res.template.tags.think.start, res.template.tags.think.end);
                 data = finalAnswer;
@@ -36,7 +39,9 @@ async function processOutput(res) {
     else {
         data = res;
     }
+    //onsole.log("OUTPUT", typeof res, data);
     if (outputMode.value == "clipboard") {
+        //console.log("Writing to kb", data)
         await writeToClipboard(data);
     }
     if (hasTextData) {

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

@@ -22,6 +22,7 @@ async function executeWorkflow(wname, args, options = {}) {
     let i = 0;
     const finalTaskIndex = stepNames.length - 1;
     let taskRes = { cmdArgs: args };
+    //console.log("WPARAMS", taskRes);
     let prevStepType = null;
     for (const step of workflow) {
         if (isDebug || isVerbose) {
@@ -93,6 +94,8 @@ async function executeWorkflow(wname, args, options = {}) {
                 break;
             case "action":
                 try {
+                    //console.log("EXEC ACTION ARGS", taskRes);
+                    //const actArgs = i == 0 ? taskRes.cmdArgs : taskRes;
                     let actArgs;
                     if (i == 0) {
                         actArgs = taskRes.cmdArgs;
@@ -105,12 +108,15 @@ async function executeWorkflow(wname, args, options = {}) {
                         actArgs = taskRes;
                     }
                     const ares = await executeAction(step.name, actArgs, options, true);
+                    //console.log("WF ACTION RES", typeof ares, ares);
+                    //console.log("LAST ACT", i, finalTaskIndex);
                     if (i == finalTaskIndex && !options?.isToolCall && !options?.quiet) {
                         console.log(ares);
                         break;
                     }
                     if (typeof ares == "string" || Array.isArray(ares)) {
                         taskRes.args = ares;
+                        //console.log("ARRAY ACTION RES", taskRes)
                     }
                     else {
                         taskRes = { ...ares, ...taskRes };
@@ -122,9 +128,13 @@ async function executeWorkflow(wname, args, options = {}) {
                 break;
             case "adaptater":
                 try {
+                    //console.log("WF AD ARGS IN", taskRes);
+                    //console.log("AD OPTS IN", options);
                     let actArgs;
                     if (i == 0) {
+                        //console.log("TR", taskRes);
                         actArgs = taskRes.cmdArgs;
+                        //console.log("ACT ARGS", actArgs);
                         const inputData = await getInputFromOptions(options);
                         if (inputData) {
                             actArgs.push(inputData);
@@ -134,16 +144,21 @@ async function executeWorkflow(wname, args, options = {}) {
                         actArgs = taskRes;
                     }
                     const adres = await executeAdaptater(step.name, actArgs, options);
+                    //console.log("WF AD FINAL RES", taskRes);
+                    //console.log("LAST ACT", i, finalTaskIndex);
                     if (i == finalTaskIndex && !options?.isToolCall && !options?.quiet) {
                         console.log(adres);
                         break;
                     }
+                    //console.log("WF AD RES", typeof adres, adres);
                     if (typeof adres == "string" || Array.isArray(adres)) {
                         taskRes.args = adres;
+                        //console.log("WF AD IT RES", taskRes);
                     }
                     else {
                         taskRes = { ...adres };
                     }
+                    //console.log("WF ADAPT RES", typeof ares, Array.isArray(ares) ? ares.length : "NA");
                 }
                 catch (e) {
                     throw new Error(`workflow adaptater ${i + 1}: ${e}`);
@@ -156,7 +171,7 @@ async function executeWorkflow(wname, args, options = {}) {
                         throw new Error(`Command ${step.name} not found`);
                     }
                     const url = pathToFileURL(path).href;
-                    const jsa = await import(url);
+                    const jsa = await import(/* @vite-ignore */ url);
                     if (!jsa?.runCmd) {
                         runtimeError(`workflow ${wname}: can not import the runCmd function from step ${i} for command ${step.name}: please add a runCmd function export`);
                         return;
@@ -188,12 +203,20 @@ async function executeWorkflow(wname, args, options = {}) {
                 throw new Error(`unknown workflow step type ${step.type} in workflow ${wname}`);
         }
         prevStepType = step.type;
+        //console.log("WF NODE RES", step.type, taskRes);
+        /*if (isDebug) {
+            console.log("->", params);
+        }*/
+        //console.log("WFR", taskRes)
         ++i;
     }
     return taskRes;
 }
 async function executeWorkflowCmd(name, wargs) {
+    //console.log("WF INITIAL ARGS", typeof wargs, wargs.slice(0, -1));
     const { args, options } = parseCommandArgs(wargs);
+    //console.log("WF ARGS", typeof args, args);
+    //console.log("WF OPTS", options);
     return await executeWorkflow(name, args, options);
 }
 export { executeWorkflow, executeWorkflowCmd };