@agent-smith/cli 0.0.103 → 0.0.105

package/dist/cli.js

@@ -1,13 +1,16 @@
 import { input } from '@inquirer/prompts';
 import { chat } from './cmd/cmds.js';
 import { isChatMode } from './state/state.js';
+import { Agent } from '@agent-smith/agent';
+import { backend } from './state/backends.js';
 async function query(program) {
     const data = { message: "$", default: "" };
     const q = await input(data);
     const args = q.split(" ");
     await program.parseAsync(args, { from: "user" });
     if (isChatMode.value) {
-        await chat(program, {});
+        const agent = new Agent(backend.value, "chat");
+        await chat(program, {}, agent, []);
     }
     await query(program);
 }

package/dist/cmd/clicmds/cache.js

@@ -15,8 +15,8 @@ function createCacheFileContent(cmdFeats) {
         ++i;
     });
     const finalImports = imports.join("\n");
-    const cmds = `const cmds = [ ${cmdNames.join(", ")} ]`;
-    const end = "export { cmds }";
+    const cmds = `const cmds = [ ${cmdNames.join(", ")} ];\nconst isCacheReady = true;`;
+    const end = "export { isCacheReady, cmds }";
     return `${finalImports}\n\n${cmds}\n\n${end}`;
 }
 function ensureUserCmdsCacheFileExists(cacheFilePath) {

package/dist/cmd/clicmds/cmds.js

@@ -1,29 +1,24 @@
 import colors from "ansi-colors";
 import path from "path";
-import { pathToFileURL } from 'url';
 import YAML from 'yaml';
 import { cacheFilePath, dbPath } from "../../conf.js";
 import { readFeaturePaths, readFeaturesType, readTaskSetting } from "../../db/read.js";
 import { cleanupFeaturePaths, deleteTaskSetting, updateAliases, updateFeatures, upsertTaskSettings } from "../../db/write.js";
+import { isCacheReady, cmds } from "../../state/auto/usercmds.js";
 import { getFeatureSpec, readFeaturesDirs } from "../../state/features.js";
 import { readPluginsPaths } from "../../state/plugins.js";
 import { runMode } from "../../state/state.js";
 import { initTaskSettings, isTaskSettingsInitialized, tasksSettings } from '../../state/tasks.js';
-import { cmds } from "../../state/auto/usercmds.js";
 import { deleteFileIfExists } from "../sys/delete_file.js";
 import { readCmd } from "../sys/read_cmds.js";
 import { readTask } from "../sys/read_task.js";
 import { updateUserCmdsCache } from './cache.js';
 async function initUserCmds(cmdFeats) {
     const features = Object.values(cmdFeats);
-    if (features.length == 0) {
-        return [];
-    }
     let endCmds = cmds;
-    if (cmds.length == 0) {
+    if (!isCacheReady) {
         updateUserCmdsCache(cacheFilePath, features);
-        const url = pathToFileURL(cacheFilePath).href;
-        const usrCmds = new Array();
+        const usrCmds = [];
         for (const feat of features) {
             const cmdPath = path.join(feat.path, feat.name + "." + feat.ext);
             const c = await readCmd(feat.name, cmdPath);

package/dist/cmd/cmds.d.ts

@@ -1,7 +1,9 @@
 import { InferenceOptions } from "@locallm/types/dist/inference.js";
 import { Command } from "commander";
+import type { McpClient } from "../main.js";
+import type { Agent } from "@agent-smith/agent";
 declare const program: Command;
-declare function chat(program: Command, options: InferenceOptions): Promise<void>;
+declare function chat(program: Command, options: InferenceOptions, agent: Agent, mcpServers: Array<McpClient>): Promise<void>;
 declare function buildCmds(): Promise<Command>;
 declare function parseCmd(program: Command): Promise<void>;
 export { buildCmds, chat, parseCmd, program };

package/dist/cmd/cmds.js

@@ -3,12 +3,12 @@ import { Command } from "commander";
 import { query } from "../cli.js";
 import { readAliases, readFeatures } from "../db/read.js";
 import { chatInferenceParams, chatTemplate } from "../state/chat.js";
-import { agent, isChatMode, runMode } from "../state/state.js";
+import { 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, options) {
+async function chat(program, options, agent, mcpServers) {
     const data = { message: '>', default: "" };
     const prompt = await input(data);
     if (prompt == "/q") {
@@ -17,12 +17,13 @@ async function chat(program, options) {
             process.exit(0);
         }
         else {
+            mcpServers.forEach(async (s) => await s.stop());
             await query(program);
         }
     }
     await agent.run(prompt, chatInferenceParams, options, chatTemplate ? chatTemplate : undefined);
     console.log();
-    await chat(program, options);
+    await chat(program, options, agent, mcpServers);
 }
 async function buildCmds() {
     initBaseCommands(program);

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

@@ -5,7 +5,7 @@ import ora from 'ora';
 import { usePerfTimer } from "../../../main.js";
 import { backend, backends, listBackends } from "../../../state/backends.js";
 import { setChatInferenceParams, setChatTemplate } from "../../../state/chat.js";
-import { agent, isChatMode } from "../../../state/state.js";
+import { 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";
@@ -13,10 +13,12 @@ import { runtimeDataError, runtimeError, runtimeWarning } from "../user_msgs.js"
 import { processOutput } from "../utils.js";
 import { readTask } from "./read.js";
 import { getTaskPrompt } from "./utils.js";
+import { Agent } from "@agent-smith/agent";
 async function executeTask(name, payload, options) {
     if (!isTaskSettingsInitialized.value) {
         initTaskSettings();
     }
+    const agent = new Agent(backend.value, name);
     const hasSettings = Object.keys(tasksSettings).includes(name);
     let settings = {};
     if (hasSettings) {
@@ -35,9 +37,20 @@ async function executeTask(name, payload, options) {
         agent.lm = backends[settings.backend];
     }
     if (options?.debug || options?.backend) {
-        console.log("Agent:", colors.bold(agent.lm.name), "( " + agent.lm.providerType + " backend type)");
+        console.log("Agent:", colors.bold(agent.name), "( " + agent.lm.providerType + " backend type)");
     }
     const { task, model, conf, vars, mcpServers, taskDir } = await readTask(name, payload, options, agent);
+    if (options?.debug && mcpServers.length > 0) {
+        console.log("Starting", mcpServers.length, "mcp servers");
+    }
+    for (const mcp of mcpServers) {
+        await mcp.start();
+        const tools = await mcp.extractTools();
+        tools.forEach(t => task.def.tools?.push(t));
+        if (options?.debug) {
+            console.log("MCP start", mcp.name);
+        }
+    }
     if (hasSettings) {
         if (!model?.inferParams) {
             model.inferParams = {};
@@ -222,10 +235,22 @@ async function executeTask(name, payload, options) {
             throw new Error(errMsg);
         }
     }
-    if (!out.answer.text.endsWith("\n")) {
-        console.log();
+    if (!options?.isToolCall) {
+        if (!out.answer.text.endsWith("\n")) {
+            console.log();
+        }
+    }
+    if (!isChatMode.value || options?.isToolCall) {
+        if (options?.debug) {
+            console.log("Closing", mcpServers.length, "mcp server(s)");
+        }
+        mcpServers.forEach((s) => {
+            s.stop();
+            if (options?.debug) {
+                console.log("MCP stop", s.name);
+            }
+        });
     }
-    mcpServers.forEach(async (s) => await s.stop());
     await processOutput(out);
     if (!options?.isToolCall && isChatMode.value) {
         if (tpl) {
@@ -244,7 +269,7 @@ async function executeTask(name, payload, options) {
             options.assistant = task.def.template.assistant;
         }
         setChatInferenceParams(initialInferParams);
-        await chat(program, options);
+        await chat(program, options, agent, mcpServers);
     }
     if (options?.debug === true || options?.verbose === true) {
         try {
@@ -257,7 +282,7 @@ async function executeTask(name, payload, options) {
             runtimeWarning("Error formating stats:", `${e}`);
         }
     }
-    if (options?.backend) {
+    if (options?.backend || settings?.backend) {
         agent.lm = backend.value;
     }
     return out;

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

@@ -55,6 +55,22 @@ async function readTask(name, payload, options, agent) {
     if (!taskSpec?.tools) {
         taskSpec.tools = [];
     }
+    const mcpServersArgs = {};
+    if (options?.mcp) {
+        options.mcp.forEach(v => {
+            const s = v.split(":");
+            if (s.length < 2) {
+                throw new Error(`Malformed mcp option ${v}: use --mcp servername:arg1,arg2`);
+            }
+            const sn = s[0];
+            const sa = s[1];
+            const _margs = sa.split(",");
+            mcpServersArgs[sn] = _margs;
+        });
+        if (options?.debug) {
+            console.log("Opening", options.mcp.length, "server(s)");
+        }
+    }
     if (taskFileSpec?.mcp) {
         for (const [servername, tool] of Object.entries(taskFileSpec.mcp)) {
             const authorizedTools = new Array();
@@ -69,11 +85,12 @@ async function readTask(name, payload, options, agent) {
                     authorizedTools.push(tn);
                 });
             }
+            const margs = tool.arguments;
+            if (servername in mcpServersArgs) {
+                margs.push(...mcpServersArgs[servername]);
+            }
             const mcp = new McpClient(servername, tool.command, tool.arguments, authorizedTools.length > 0 ? authorizedTools : null, askUserTools.length > 0 ? askUserTools : null);
             mcpServers.push(mcp);
-            await mcp.start();
-            const tools = await mcp.extractTools();
-            tools.forEach(t => taskSpec.tools?.push(t));
         }
     }
     if (taskSpec.toolsList) {

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

@@ -5,6 +5,9 @@ import { executeTask } from "../tasks/cmd.js";
 import { getTaskPrompt } from "../tasks/utils.js";
 import { readWorkflow } from "./read.js";
 import colors from "ansi-colors";
+import { getFeatureSpec } from "../../../state/features.js";
+import { pathToFileURL } from "node:url";
+import { runtimeError } from "../user_msgs.js";
 async function executeWorkflow(wname, args, options = {}) {
     const { workflow, found } = await readWorkflow(wname);
     if (!found) {
@@ -27,7 +30,7 @@ async function executeWorkflow(wname, args, options = {}) {
         switch (step.type) {
             case "task":
                 try {
-                    let tdata = {};
+                    let tdata = taskRes;
                     if (i == 0) {
                         tdata.prompt = await getTaskPrompt(step.name, taskRes.cmdArgs, options);
                     }
@@ -37,7 +40,6 @@ async function executeWorkflow(wname, args, options = {}) {
                                 tdata.prompt = taskRes.answer.text;
                             }
                         }
-                        tdata = taskRes;
                     }
                     if (!tdata?.prompt) {
                         throw new Error(`Workflow ${wname} step ${i + 1}: provide a prompt for the task ${step.name}`);
@@ -49,6 +51,31 @@ async function executeWorkflow(wname, args, options = {}) {
                     throw new Error(`workflow task ${i + 1}: ${e}`);
                 }
                 break;
+            case "agent":
+                try {
+                    let tdata = taskRes;
+                    if (i == 0) {
+                        tdata.prompt = await getTaskPrompt(step.name, taskRes.cmdArgs, options);
+                    }
+                    else {
+                        if (prevStepType) {
+                            if (prevStepType == "task") {
+                                tdata.prompt = taskRes.answer.text;
+                            }
+                        }
+                    }
+                    if (!tdata?.prompt) {
+                        throw new Error(`Workflow ${wname} step ${i + 1}: provide a prompt for the task ${step.name}`);
+                    }
+                    options.isAgent = true;
+                    const tr = await executeTask(step.name, tdata, options);
+                    options.isAgent = false;
+                    taskRes = { ...tr, ...taskRes };
+                }
+                catch (e) {
+                    throw new Error(`workflow task ${i + 1}: ${e}`);
+                }
+                break;
             case "action":
                 try {
                     const actArgs = i == 0 ? taskRes.cmdArgs : taskRes;
@@ -75,7 +102,7 @@ async function executeWorkflow(wname, args, options = {}) {
                         taskRes.args = adres;
                     }
                     else {
-                        taskRes = { ...adres, ...taskRes };
+                        taskRes = { ...adres };
                     }
                     if (i == finalTaskIndex) {
                         console.log(taskRes);
@@ -85,8 +112,32 @@ async function executeWorkflow(wname, args, options = {}) {
                     throw new Error(`workflow adaptater ${i + 1}: ${e}`);
                 }
                 break;
+            case "cmd":
+                try {
+                    const { found, path } = getFeatureSpec(step.name, "cmd");
+                    if (!found) {
+                        throw new Error(`Command ${step.name} not found`);
+                    }
+                    const url = pathToFileURL(path).href;
+                    const jsa = await import(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;
+                    }
+                    const cres = await jsa.runCmd(args, options);
+                    if (typeof cres == "string" || Array.isArray(cres)) {
+                        taskRes.args = cres;
+                    }
+                    else {
+                        taskRes = { ...cres, ...taskRes };
+                    }
+                }
+                catch (e) {
+                    throw new Error(`workflow command ${i + 1}: ${e}`);
+                }
+                break;
             default:
-                throw new Error(`unknown task type ${step.type} in workflow ${name}`);
+                throw new Error(`unknown workflow step type ${step.type} in workflow ${wname}`);
         }
         prevStepType = step.type;
         ++i;

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

@@ -1,104 +1,17 @@
-import { Agent } from '@agent-smith/agent';
-import { Task } from '@agent-smith/task';
 import { default as fs } from "fs";
 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';
-import { createJsAction } from '../actions/read.js';
-import { pathToFileURL } from 'url';
 async function _createWorkflowFromSpec(spec) {
     const steps = [];
-    let i = 1;
     for (const step of spec.steps) {
         const type = Object.keys(step)[0];
         const sval = step[type];
         const name = sval;
-        if (type == "action") {
-            const { found, path, ext } = getFeatureSpec(name, "action");
-            if (!found) {
-                throw new Error(`Action ${name} not found`);
-            }
-            switch (ext) {
-                case "js":
-                    const url = pathToFileURL(path).href;
-                    const { action } = await import(url);
-                    const at = action;
-                    const wf = {
-                        name: name,
-                        type: "action",
-                        run: at,
-                    };
-                    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.push(wf2);
-                    break;
-                case "yml":
-                    const _t1 = systemAction(path);
-                    const wf3 = {
-                        name: name,
-                        type: "action",
-                        run: _t1,
-                    };
-                    steps.push(wf3);
-                    break;
-                case "py":
-                    const _t = pythonAction(path);
-                    const wf4 = {
-                        name: name,
-                        type: "action",
-                        run: _t,
-                    };
-                    steps.push(wf4);
-                    break;
-                default:
-                    throw new Error(`Unknown feature extension ${ext}`);
-            }
-        }
-        else if (type == "adaptater") {
-            const { found, path } = getFeatureSpec(name, "adaptater");
-            if (!found) {
-                throw new Error(`Adaptater ${name} not found`);
-            }
-            const url = pathToFileURL(path).href;
-            const jsa = await import(url);
-            const act = createJsAction(jsa.action);
-            const wf = {
-                name: name,
-                type: "adaptater",
-                run: act,
-            };
-            steps.push(wf);
-        }
-        else {
-            const { found, path } = getFeatureSpec(name, "task");
-            if (!found) {
-                throw new Error(`Task ${name} not found`);
-            }
-            const res = readTask(path);
-            if (!res.found) {
-                throw new Error(`Unable to read task ${name} ${path}`);
-            }
-            const agent = new Agent(backend.value);
-            const tsk = Task.fromYaml(agent, res.ymlTask);
-            const wf = {
-                name: name,
-                type: "task",
-                run: tsk.run,
-            };
-            steps.push(wf);
-        }
-        ++i;
+        const wf = {
+            name: name,
+            type: type == "command" ? "cmd" : type,
+        };
+        steps.push(wf);
     }
     return steps;
 }

package/dist/cmd/options.js

@@ -14,6 +14,7 @@ const inferenceOptions = [
     new Option("-t, --temperature <number>", "adjusts randomness in sampling; higher values mean more randomness").argParser(parseFloatValue),
     new Option("-r, --repeat_penalty <number>", "adjusts penalty for repeated tokens").argParser(parseFloatValue),
     new Option("-b, --backend <name>", "use a given backend. It must be registered in config").argParser(parseString),
+    new Option("--mcp [args...]", "extra arguments for mcp server arguments: --mcp servername:arg1,arg2"),
 ];
 const ioOptions = [
     new Option("--if, --input-file", "use promptfile input mode"),

package/dist/cmd/sys/read_features.js

@@ -66,7 +66,7 @@ function readFeaturesDir(dir) {
     }
     dirpath = path.join(dir, "actions");
     if (fs.existsSync(dirpath)) {
-        const data = _readDir(dirpath, ["yml", ".js", "mjs", ".py"]);
+        const data = _readDir(dirpath, [".yml", ".js", ".py"]);
         data.forEach((filename) => {
             const parts = filename.split(".");
             const ext = parts.pop();

package/dist/interfaces.d.ts

@@ -105,7 +105,6 @@ interface FinalLmTaskConfig {
 interface WorkflowStep {
     name: string;
     type: string;
-    run: FeatureExecutor;
 }
 interface McpServerSpec {
     command: string;

package/dist/state/auto/usercmds.d.ts

@@ -1 +1,4 @@
-export const cmds: any[];
+import { Command } from "commander";
+declare const cmds: Command[];
+declare const isCacheReady = false;
+export { cmds, isCacheReady, };

package/dist/state/auto/usercmds.js

@@ -1,9 +1,12 @@
-import { cmd as c1 } from "file:///home/ggg/dev/js/agent-smith-plugins/system/fs/dist/cmds/lsdir.js";
-import { cmd as c2 } from "file:///home/ggg/dev/js/agent-smith-plugins/code/git/dist/cmds/commit.js";
-import { cmd as c3 } from "file:///home/ggg/dev/js/agent-smith-plugins/code/git/dist/cmds/commita.js";
-import { cmd as c4 } from "file:///home/ggg/dev/js/snowind-astro/features/cmds/design-component.js";
-import { cmd as c5 } from "file:///home/ggg/dev/js/docdundee/package/features/dist/cmds/tsdoccmd.js";
+import { cmd as c1 } from "file:///home/ggg/lm/features/dist/cmds/testcmd.js";
+import { cmd as c2 } from "file:///home/ggg/dev/js/agent-smith-plugins/system/fs/dist/cmds/lsdir.js";
+import { cmd as c3 } from "file:///home/ggg/dev/js/agent-smith-plugins/code/git/dist/cmds/commit.js";
+import { cmd as c4 } from "file:///home/ggg/dev/js/agent-smith-plugins/code/git/dist/cmds/commita.js";
+import { cmd as c5 } from "file:///home/ggg/dev/js/agent-smith-plugins/vision/dist/cmds/imgs2base64.js";
+import { cmd as c6 } from "file:///home/ggg/dev/js/snowind-astro/features/cmds/design-component.js";
+import { cmd as c7 } from "file:///home/ggg/dev/js/docdundee/package/features/dist/cmds/tsdoccmd.js";
 
-const cmds = [ c1, c2, c3, c4, c5 ]
+const cmds = [ c1, c2, c3, c4, c5, c6, c7 ];
+const isCacheReady = true;
 
-export { cmds }
+export { isCacheReady, cmds }

package/dist/state/state.d.ts

@@ -1,6 +1,5 @@
 import { PythonShell } from 'python-shell';
 import { InputMode, RunMode, FormatMode, OutputMode } from "../interfaces.js";
-import { Agent } from "@agent-smith/agent";
 declare let pyShell: PythonShell;
 declare const inputMode: import("@vue/reactivity").Ref<InputMode, InputMode>;
 declare const outputMode: import("@vue/reactivity").Ref<OutputMode, OutputMode>;
@@ -10,7 +9,6 @@ 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 let agent: Agent;
 declare const lastCmd: {
     name: string;
     args: Array<string>;
@@ -19,4 +17,4 @@ declare function initFilepaths(): void;
 declare function init(): Promise<void>;
 declare function initState(): Promise<void>;
 declare function pluginDataDir(pluginName: string): string;
-export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, promptfilePath, dataDirPath, isStateReady, pluginDataDir, initState, initFilepaths, init, pyShell, agent, };
+export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, promptfilePath, dataDirPath, isStateReady, pluginDataDir, initState, initFilepaths, init, pyShell, };

package/dist/state/state.js

@@ -4,7 +4,6 @@ import { readFilePaths } from "../db/read.js";
 import path from "path";
 import { createDirectoryIfNotExists } from "../cmd/sys/dirs.js";
 import { backend, initBackends } from "./backends.js";
-import { Agent } from "@agent-smith/agent";
 import { runtimeDataError } from "../utils/user_msgs.js";
 let pyShell;
 const inputMode = ref("manual");
@@ -15,7 +14,6 @@ const isChatMode = ref(false);
 const promptfilePath = ref("");
 const dataDirPath = ref("");
 const isStateReady = ref(false);
-let agent;
 const lastCmd = reactive({
     name: "",
     args: [],
@@ -39,7 +37,6 @@ async function init() {
         runtimeDataError("No backend found, can not initialize agent");
         return;
     }
-    agent = new Agent(backend.value);
 }
 async function initState() {
     if (isStateReady.value) {
@@ -61,4 +58,4 @@ function pluginDataDir(pluginName) {
     createDirectoryIfNotExists(pluginDatapath);
     return pluginDatapath;
 }
-export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, promptfilePath, dataDirPath, isStateReady, pluginDataDir, initState, initFilepaths, init, pyShell, agent, };
+export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, promptfilePath, dataDirPath, isStateReady, pluginDataDir, initState, initFilepaths, init, 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.103",
+  "version": "0.0.105",
   "scripts": {
     "buildrl": "rm -rf dist/* && rollup -c",
     "build": "rm -rf dist/* && tsc",
@@ -10,17 +10,17 @@
     "watch": "tsc --noCheck -p . -w"
   },
   "dependencies": {
-    "@agent-smith/agent": "^0.2.0",
+    "@agent-smith/agent": "^0.2.1",
     "@agent-smith/task": "^0.2.1",
     "@agent-smith/nodetask": "^0.1.0",
     "@agent-smith/tfm": "^0.2.0",
-    "@inquirer/prompts": "^8.1.0",
+    "@inquirer/prompts": "^8.2.0",
     "@intrinsicai/gbnfgen": "0.12.0",
     "@locallm/api": "^0.7.3",
     "@modelcontextprotocol/sdk": "^1.25.2",
     "@vue/reactivity": "^3.5.26",
     "ansi-colors": "^4.1.3",
-    "better-sqlite3": "^12.5.0",
+    "better-sqlite3": "^12.6.0",
     "clipboardy": "^5.0.2",
     "commander": "^14.0.2",
     "marked-terminal": "^7.3.0",
@@ -29,7 +29,6 @@
     "yaml": "^2.8.2"
   },
   "devDependencies": {
-    "@agent-smith/tmem-jobs": "^0.0.4",
     "@cfworker/json-schema": "^4.1.1",
     "@commander-js/extra-typings": "^14.0.0",
     "@locallm/types": "^0.6.7",
@@ -37,8 +36,8 @@
     "@rollup/plugin-typescript": "^12.3.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/marked-terminal": "^6.1.1",
-    "@types/node": "^25.0.3",
-    "openai": "^6.15.0",
+    "@types/node": "^25.0.8",
+    "openai": "^6.16.0",
     "restmix": "^0.6.1",
     "rollup": "^4.55.1",
     "ts-node": "^10.9.2",