@agent-smith/cli 0.0.31 → 0.0.34

package/dist/cmd/clicmds/modes.js

@@ -1,4 +1,4 @@
-import { formatMode, inputMode, isChatMode, isDebug, outputMode, runMode } from "../../state/state.js";
+import { formatMode, inputMode, isChatMode, isDebug, isVerbose, outputMode, runMode } from "../../state/state.js";
 const modes = {
     "-d": {
         cmd: async () => {
@@ -9,6 +9,15 @@ const modes = {
         },
         description: "use debug mode",
     },
+    "-v": {
+        cmd: async () => {
+            isVerbose.value = true;
+            if (runMode.value == "cli") {
+                console.log("Verbose mode is on");
+            }
+        },
+        description: "use verbose mode",
+    },
     "-c": {
         cmd: async () => {
             isChatMode.value = true;

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

@@ -1,2 +1,6 @@
+import { AgentTask } from "@agent-smith/jobs";
+import { FeatureType } from "../../interfaces.js";
+declare function systemAction(path: string): AgentTask<FeatureType>;
+declare function pythonAction(path: string): AgentTask<FeatureType>;
 declare function executeActionCmd(args?: Array<string>, options?: any, quiet?: boolean): Promise<any>;
-export { executeActionCmd };
+export { executeActionCmd, systemAction, pythonAction };

package/dist/cmd/lib/execute_action.js

@@ -4,26 +4,29 @@ import { readYmlAction } from "../sys/read_yml_action.js";
 import { execute } from "../sys/execute.js";
 import { runPyScript } from "../sys/run_python.js";
 import { pyShell } from "../../state/state.js";
-import { parseInputOptions, processOutput } from "./utils.js";
-function _systemAction(path) {
+import { createJsAction, parseInputOptions, processOutput } from "./utils.js";
+function systemAction(path) {
     const action = useAgentTask({
         id: "system_action",
         title: "",
         run: async (args) => {
             const actionSpec = readYmlAction(path);
+            if (!actionSpec.data?.args) {
+                actionSpec.data.args = [];
+            }
             const out = await execute(actionSpec.data.cmd, [...actionSpec.data.args, ...args]);
-            return { data: out, error: "", ok: true };
+            return { data: out.trim(), error: "", ok: true };
         }
     });
     return action;
 }
-function _pythonAction(path) {
+function pythonAction(path) {
     const action = useAgentTask({
         id: "python_action",
         title: "",
         run: async (args) => {
             const out = await runPyScript(pyShell, "python3", path, args);
-            return { data: out[0], error: "", ok: true };
+            return { data: out.join("\n"), error: "", ok: true };
         }
     });
     return action;
@@ -40,11 +43,15 @@ async function executeActionCmd(args = [], options = {}, quiet = false) {
             const { action } = await import(path);
             act = action;
             break;
+        case "mjs":
+            const mjsa = await import(path);
+            act = createJsAction(mjsa.action);
+            break;
         case "yml":
-            act = _systemAction(path);
+            act = systemAction(path);
             break;
         case "py":
-            act = _pythonAction(path);
+            act = pythonAction(path);
             break;
         default:
             throw new Error(`Action ext ${ext} not implemented`);
@@ -60,4 +67,4 @@ async function executeActionCmd(args = [], options = {}, quiet = false) {
     await processOutput(res);
     return { ok: true, data: res.data, error: "" };
 }
-export { executeActionCmd };
+export { executeActionCmd, systemAction, pythonAction };

package/dist/cmd/lib/execute_job.js

@@ -3,10 +3,14 @@ import { default as fs } from "fs";
 import { useAgentJob } from "@agent-smith/jobs";
 import { brain, marked, taskBuilder } from '../../agent.js';
 import { getFeatureSpec } from '../../state/features.js';
-import { formatMode, isDebug } from '../../state/state.js';
-import { initTaskConf, initTaskVars, readTask } from './utils.js';
+import { formatMode, isDebug, isVerbose } from '../../state/state.js';
+import { createJsAction, initTaskConf, initTaskParams, initTaskVars, parseInputOptions, readTask } from './utils.js';
+import { pythonAction, systemAction } from './execute_action.js';
 async function executeJobCmd(name, args = [], options = {}) {
     const { job, found } = await _dispatchReadJob(name);
+    if (isDebug.value || isVerbose.value) {
+        console.log("Running job", name, Object.keys(job.tasks).length, "tasks");
+    }
     if (!found) {
         console.log(`Job ${name} not found`);
         return { error: `Job ${name} not found` };
@@ -16,8 +20,10 @@ async function executeJobCmd(name, args = [], options = {}) {
     let params = {};
     brain.backendsForModelsInfo();
     let i = 0;
+    const finalTaskIndex = Object.keys(job.tasks).length - 1;
     for (const [name, task] of Object.entries(job.tasks)) {
         if (task.type == "task") {
+            const chain = task.properties?.chain;
             const { found, path } = getFeatureSpec(name, "task");
             if (!found) {
                 return { ok: false, data: {}, error: `Task ${name} not found` };
@@ -27,11 +33,51 @@ async function executeJobCmd(name, args = [], options = {}) {
                 throw new Error(`Task ${name}, ${path} not found`);
             }
             const taskSpec = taskBuilder.readFromYaml(tres.ymlTask);
-            let { conf, vars } = initTaskVars(args, taskSpec?.inferParams ? taskSpec.inferParams : {});
+            if (params.data?.history?.length > 0) {
+                const taskShots = taskSpec?.shots ?? [];
+                taskSpec.shots = [...taskShots, ...params.data.history];
+            }
+            let conf = {};
+            let vars = {};
+            if (i == 0) {
+                const vs = initTaskVars(args, taskSpec?.inferParams ? taskSpec.inferParams : {});
+                conf = vs.conf;
+                vars = vs.vars;
+                const _pr = await parseInputOptions(options);
+                if (_pr) {
+                    vars.prompt = _pr;
+                }
+            }
+            else {
+                if (!params?.prompt) {
+                    if (params?.text) {
+                        params.prompt = params.text;
+                    }
+                    else {
+                        throw new Error(`No prompt provided for task ${name}.\Params: ${params}`);
+                    }
+                }
+                const vs = initTaskParams(params, taskSpec?.inferParams ? taskSpec.inferParams : {});
+                conf = vs.conf;
+                vars = vs.vars;
+            }
+            const nextParams = {};
+            for (const [k, v] of Object.entries(vars)) {
+                if (taskSpec.variables?.required?.includes(k) || taskSpec.variables?.optional?.includes(k) || k == "prompt") {
+                    continue;
+                }
+                ;
+                nextParams[k] = v;
+                delete vars[k];
+            }
             conf = initTaskConf(conf, taskSpec);
             if (isDebug.value) {
                 console.log("Task conf:", conf);
                 console.log("Task vars:", vars);
+                console.log("Next params:", nextParams);
+            }
+            if (isVerbose.value || isDebug.value) {
+                conf.verbose = true;
             }
             const ex = brain.getOrCreateExpertForModel(conf.model.name, conf.model.template);
             if (!ex) {
@@ -43,29 +89,76 @@ async function executeJobCmd(name, args = [], options = {}) {
             });
             conf["expert"] = ex;
             try {
-                if (isDebug) {
-                    console.log("Running", name);
+                if (isDebug.value || isVerbose.value) {
+                    console.log(i + 1, "Running task", name);
+                }
+                try {
+                    const invars = { ...params, ...vars };
+                    try {
+                        res = await job.runTask(name, invars, conf);
+                    }
+                    catch (e) {
+                        throw new Error(`Error running task ${name}: ${e}`);
+                    }
+                    if (chain) {
+                        const turn = {
+                            user: vars["prompt"],
+                            assistant: res.text
+                        };
+                        if (res.data?.history) {
+                            res.data.history.push(turn);
+                        }
+                        else {
+                            res.data.history = [turn];
+                        }
+                    }
+                    else {
+                        if (res.data?.history) {
+                            res.data.history = [];
+                        }
+                    }
+                }
+                catch (e) {
+                    throw new Error(`Error running job task ${e}`);
+                }
+                if (res?.error) {
+                    return { ok: false, data: "", conf: conf, error: `Error executing job task ${name}: ${res.error}` };
                 }
-                res = await job.runTask(name, { ...params, ...vars }, conf);
                 if ("text" in res) {
                     if (formatMode.value == "markdown") {
                         console.log("\n\n------------------\n");
                         console.log(marked.parse(res.text).trim());
                     }
                 }
-                params = res;
+                params = { ...res, ...nextParams };
             }
             catch (err) {
-                return { error: `Error executing (${task.type}) task ${name}: ${err}` };
+                return { error: `Error executing job task ${name}: ${err}` };
             }
         }
         else {
             try {
-                if (i == 0) {
-                    res = await job.runTask(name, args, options);
+                const _p = i == 0 ? args : params;
+                if (isDebug.value) {
+                    console.log(i + 1, "Running action", name, _p);
+                }
+                else if (isVerbose.value) {
+                    console.log(i + 1, "Running action", name);
+                }
+                try {
+                    res = await job.runTask(name, _p, options);
+                }
+                catch (e) {
+                    throw new Error(`Error executing job action ${e}`);
+                }
+                if (!res.ok) {
+                    return { ok: false, data: "", conf: {}, error: `Error executing action ${name}: ${res?.error}` };
+                }
+                if (i == finalTaskIndex) {
+                    console.log(res.data);
                 }
                 else {
-                    res = await job.runTask(name, params, options);
+                    params = res.data;
                 }
                 params = res.data;
             }
@@ -108,14 +201,32 @@ async function _createJobFromSpec(spec) {
     const tasks = {};
     for (const t of spec.tasks) {
         if (t.type == "action") {
-            const { found, path } = getFeatureSpec(t.name, "action");
+            const { found, path, ext } = getFeatureSpec(t.name, "action");
             if (!found) {
                 return { found: false, job: {} };
             }
-            const { action } = await import(path);
-            const at = action;
-            at.type = "action";
-            tasks[t.name] = at;
+            if (ext == "js") {
+                const { action } = await import(path);
+                const at = action;
+                at.type = "action";
+                tasks[t.name] = at;
+            }
+            else if (ext == "mjs") {
+                const mjsa = await import(path);
+                const act = createJsAction(mjsa.action);
+                act.type = "action";
+                tasks[t.name] = act;
+            }
+            else if (ext == "yml") {
+                const _t = systemAction(path);
+                _t.type = "action";
+                tasks[t.name] = _t;
+            }
+            else if (ext == "py") {
+                const _t = pythonAction(path);
+                _t.type = "action";
+                tasks[t.name] = _t;
+            }
         }
         else {
             const { found, path } = getFeatureSpec(t.name, "task");
@@ -126,8 +237,10 @@ async function _createJobFromSpec(spec) {
             if (!res.found) {
                 throw new Error(`Task ${t.name}, ${path} not found`);
             }
-            const at = taskBuilder.fromYaml(res.ymlTask);
-            at.type = "task";
+            const at = taskBuilder.fromYaml(res.ymlTask, "task");
+            if (t?.chain) {
+                at.properties = { "chain": true };
+            }
             tasks[t.name] = at;
         }
     }

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

@@ -1,2 +1,2 @@
-declare function executeTaskCmd(args?: Array<string>, options?: any): Promise<any>;
+declare function executeTaskCmd(args?: Array<string> | Record<string, any>, options?: any): Promise<any>;
 export { executeTaskCmd };

package/dist/cmd/lib/execute_task.js

@@ -1,24 +1,43 @@
 import { brain, initAgent, taskBuilder } from "../../agent.js";
 import { getFeatureSpec } from "../../state/features.js";
 import { isChatMode, isDebug } from "../../state/state.js";
-import { initTaskConf, initTaskVars, parseInputOptions, readTask } from "./utils.js";
+import { initTaskConf, initTaskParams, initTaskVars, parseInputOptions, readTask } from "./utils.js";
 async function executeTaskCmd(args = [], options = {}) {
     await initAgent();
     if (isDebug.value) {
         console.log("Task args:", args);
         console.log("Task options:", options);
     }
-    const name = args.shift();
-    const params = args.filter((x) => x.length > 0);
-    let pr = await parseInputOptions(options);
-    if (!pr) {
-        const p = params.shift();
-        if (p) {
-            pr = p;
+    const isJob = !Array.isArray(args);
+    let name;
+    let pr;
+    if (!isJob) {
+        name = args.shift();
+        const _pr = await parseInputOptions(options);
+        if (!_pr) {
+            const p = args.shift();
+            if (p) {
+                pr = p;
+            }
+            else {
+                throw new Error("Please provide a prompt");
+            }
+        }
+        else {
+            pr = _pr;
         }
     }
-    if (!pr) {
-        throw new Error("Please provide a prompt");
+    else {
+        if (!args.name) {
+            throw new Error("Provide a task name param");
+        }
+        if (!args.prompt) {
+            throw new Error("Provide a task prompt param");
+        }
+        name = args.name;
+        delete args.name;
+        pr = args.prompt;
+        delete args.prompt;
     }
     const { found, path } = getFeatureSpec(name, "task");
     if (!found) {
@@ -30,7 +49,18 @@ async function executeTaskCmd(args = [], options = {}) {
     }
     const taskSpec = taskBuilder.readFromYaml(res.ymlTask);
     const task = taskBuilder.fromYaml(res.ymlTask);
-    let { conf, vars } = initTaskVars(args, taskSpec?.inferParams ? taskSpec.inferParams : {});
+    let conf = {};
+    let vars = {};
+    if (!isJob) {
+        const tv = initTaskVars(args, taskSpec?.inferParams ? taskSpec.inferParams : {});
+        conf = tv.conf;
+        vars = tv.vars;
+    }
+    else {
+        const tv = initTaskParams(args, taskSpec?.inferParams ? taskSpec.inferParams : {});
+        conf = tv.conf;
+        vars = tv.vars;
+    }
     conf = initTaskConf(conf, taskSpec);
     if (isDebug.value) {
         console.log("Task conf:", conf);
@@ -57,7 +87,7 @@ async function executeTaskCmd(args = [], options = {}) {
     }
     const data = await task.run({ prompt: pr, ...vars }, conf);
     if (data?.error) {
-        return { ok: false, data: "", conf: conf, error: `Error executing task: ${data.error}` };
+        return { ok: false, data: "", conf: conf, error: `Error executing task: ${name} ${data.error}` };
     }
     conf.prompt = pr;
     if (isChatMode.value) {

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

@@ -1,4 +1,6 @@
-import { LmTask } from "@agent-smith/lmtask/dist/interfaces.js";
+import { AgentTask } from "@agent-smith/jobs/dist/jobsinterfaces.js";
+import { LmTask } from "@agent-smith/lmtask";
+import { FeatureType } from "../../interfaces.js";
 declare function setOptions(args: Array<string> | undefined, options: Record<string, any>): Promise<Array<string>>;
 declare function readPromptFile(): string;
 declare function processOutput(res: any): Promise<void>;
@@ -8,9 +10,14 @@ declare function readTask(taskpath: string): {
 };
 declare function readTasksDir(dir: string): Array<string>;
 declare function initTaskConf(conf: Record<string, any>, taskSpec: LmTask): Record<string, any>;
+declare function initTaskParams(params: Record<string, any>, inferParams: Record<string, any>): {
+    conf: Record<string, any>;
+    vars: Record<string, any>;
+};
 declare function initTaskVars(args: Array<any>, inferParams: Record<string, any>): {
     conf: Record<string, any>;
     vars: Record<string, any>;
 };
 declare function parseInputOptions(options: any): Promise<string | null>;
-export { readPromptFile, processOutput, setOptions, readTask, readTasksDir, initTaskVars, initTaskConf, parseInputOptions, };
+declare function createJsAction(action: CallableFunction): AgentTask<FeatureType>;
+export { createJsAction, initTaskConf, initTaskParams, initTaskVars, parseInputOptions, processOutput, readPromptFile, readTask, readTasksDir, setOptions };

package/dist/cmd/lib/utils.js

@@ -1,10 +1,10 @@
+import { useAgentTask } from "@agent-smith/jobs";
+import { useTemplateForModel } from "@agent-smith/tfm";
 import { default as fs } from "fs";
 import { default as path } from "path";
-import { outputMode, promptfile } from "../../state/state.js";
-import { inputMode } from "../../state/state.js";
-import { readClipboard, writeToClipboard } from "../sys/clipboard.js";
+import { inputMode, outputMode, promptfile } from "../../state/state.js";
 import { modes } from "../clicmds/modes.js";
-import { useTemplateForModel } from "@agent-smith/tfm";
+import { readClipboard, writeToClipboard } from "../sys/clipboard.js";
 const tfm = useTemplateForModel();
 async function setOptions(args = [], options) {
     for (const k of Object.keys(options)) {
@@ -44,6 +44,7 @@ async function processOutput(res) {
         let hasOutput = false;
         if (res?.data) {
             data = res.data;
+            0;
             hasOutput = true;
         }
         if (res?.text) {
@@ -58,6 +59,9 @@ async function processOutput(res) {
         data = res;
     }
     if (outputMode.value == "clipboard") {
+        if (typeof data == "object") {
+            data = JSON.stringify(data);
+        }
         await writeToClipboard(data);
     }
 }
@@ -122,6 +126,18 @@ function initTaskConf(conf, taskSpec) {
     }
     return _conf;
 }
+function initTaskParams(params, inferParams) {
+    const conf = { inferParams: inferParams };
+    if (!params?.prompt) {
+        throw new Error(`Error initializing task variable: provide a prompt`);
+    }
+    if (params?.images) {
+        conf.inferParams.images = params.images;
+        delete params.images;
+    }
+    const res = { conf: conf, vars: params };
+    return res;
+}
 function initTaskVars(args, inferParams) {
     const conf = { inferParams: inferParams };
     const vars = {};
@@ -130,27 +146,29 @@ function initTaskVars(args, inferParams) {
             const t = a.split("=");
             const k = t[0];
             const v = t[1];
-            if (k == "m") {
-                if (v.includes("/")) {
-                    const _s = v.split("/");
-                    conf.model = _s[0];
-                    conf.template = _s[1];
-                }
-                else {
-                    conf.model = v;
-                }
-            }
-            else if (k == "ip") {
-                v.split(",").forEach((p) => {
-                    const s = p.split(":");
-                    conf["inferParams"][s[0]] = parseFloat(s[1]);
-                });
-            }
-            else if (k == "s") {
-                conf.size = v;
-            }
-            else {
-                vars[k] = v;
+            switch (k) {
+                case "m":
+                    if (v.includes("/")) {
+                        const _s = v.split("/");
+                        conf.model = _s[0];
+                        conf.template = _s[1];
+                    }
+                    else {
+                        conf.model = v;
+                    }
+                    break;
+                case "ip":
+                    v.split(",").forEach((p) => {
+                        const s = p.split(":");
+                        conf["inferParams"][s[0]] = parseFloat(s[1]);
+                    });
+                    break;
+                case "s":
+                    conf.size = v;
+                    break;
+                default:
+                    vars[k] = v;
+                    break;
             }
         }
     });
@@ -166,4 +184,15 @@ async function parseInputOptions(options) {
     }
     return out;
 }
-export { readPromptFile, processOutput, setOptions, readTask, readTasksDir, initTaskVars, initTaskConf, parseInputOptions, };
+function createJsAction(action) {
+    const task = useAgentTask({
+        id: "",
+        title: "",
+        run: async (args) => {
+            const res = await action(args);
+            return { ok: true, data: res };
+        }
+    });
+    return task;
+}
+export { createJsAction, initTaskConf, initTaskParams, initTaskVars, parseInputOptions, processOutput, readPromptFile, readTask, readTasksDir, setOptions };

package/dist/cmd/sys/read_features.js

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

package/dist/db/schemas.js

@@ -28,7 +28,7 @@ const actions = `CREATE TABLE IF NOT EXISTS action (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     name TEXT UNIQUE NOT NULL,
     path TEXT NOT NULL,
-    ext TEXT NOT NULL CHECK ( ext IN ('yml', 'js', 'py') )
+    ext TEXT NOT NULL CHECK ( ext IN ('yml', 'js', 'py', 'mjs') )
 );`;
 const cmds = `CREATE TABLE IF NOT EXISTS cmd (
     id INTEGER PRIMARY KEY AUTOINCREMENT,

package/dist/interfaces.d.ts

@@ -41,7 +41,7 @@ type OutputMode = "txt" | "clipboard";
 type RunMode = "cli" | "cmd";
 type FormatMode = "text" | "markdown";
 type FeatureType = "task" | "job" | "action" | "cmd";
-type ActionExtension = "js" | "py" | "yml";
+type ActionExtension = "js" | "mjs" | "py" | "yml";
 type TaskExtension = "yml";
 type JobExtension = "yml";
 type CmdExtension = "js";

package/dist/state/state.d.ts

@@ -7,6 +7,7 @@ declare const runMode: import("@vue/reactivity").Ref<RunMode, RunMode>;
 declare const formatMode: import("@vue/reactivity").Ref<FormatMode, FormatMode>;
 declare const isChatMode: import("@vue/reactivity").Ref<boolean, boolean>;
 declare const isDebug: import("@vue/reactivity").Ref<boolean, boolean>;
+declare const isVerbose: import("@vue/reactivity").Ref<boolean, boolean>;
 declare const promptfile: import("@vue/reactivity").Ref<string, string>;
 declare const lastCmd: {
     name: string;
@@ -14,4 +15,4 @@ declare const lastCmd: {
 };
 declare function initFeatures(): Promise<void>;
 declare function initState(): Promise<void>;
-export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, isDebug, promptfile, initState, initFeatures, pyShell, };
+export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, isDebug, isVerbose, promptfile, initState, initFeatures, pyShell, };

package/dist/state/state.js

@@ -12,6 +12,7 @@ const runMode = ref("cmd");
 const formatMode = ref("text");
 const isChatMode = ref(false);
 const isDebug = ref(false);
+const isVerbose = ref(false);
 const promptfile = ref("");
 const lastCmd = reactive({
     name: "",
@@ -37,4 +38,4 @@ async function initState() {
     initConf();
     await initFeatures();
 }
-export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, isDebug, promptfile, initState, initFeatures, pyShell, };
+export { inputMode, outputMode, isChatMode, runMode, formatMode, lastCmd, isDebug, isVerbose, promptfile, initState, initFeatures, pyShell, };

package/package.json

@@ -2,17 +2,17 @@
   "name": "@agent-smith/cli",
   "description": "Agent Smith: terminal client for language model agents",
   "repository": "https://github.com/synw/agent-smith",
-  "version": "0.0.31",
+  "version": "0.0.34",
   "scripts": {
     "buildrl": "rm -rf dist/* && rollup -c",
-    "build": "rm -rf dist/* && tsc",
+    "build": "rm -rf dist/* && tsc --noCheck",
     "cli": "node --loader ts-node/esm bin/index.ts",
-    "watch": "tsc -p . -w"
+    "watch": "tsc --noCheck -p . -w"
   },
   "dependencies": {
-    "@agent-smith/brain": "^0.0.35",
-    "@agent-smith/jobs": "^0.0.11",
-    "@agent-smith/lmtask": "^0.0.28",
+    "@agent-smith/brain": "^0.0.37",
+    "@agent-smith/jobs": "^0.0.12",
+    "@agent-smith/lmtask": "^0.0.29",
     "@agent-smith/tfm": "^0.1.1",
     "@inquirer/prompts": "^7.3.2",
     "@inquirer/select": "^4.0.9",
@@ -21,7 +21,7 @@
     "clipboardy": "^4.0.0",
     "commander": "^13.1.0",
     "marked-terminal": "^7.3.0",
-    "modprompt": "^0.9.5",
+    "modprompt": "^0.10.1",
     "python-shell": "^5.0.0",
     "yaml": "^2.7.0"
   },
@@ -33,12 +33,12 @@
     "@rollup/plugin-typescript": "^12.1.2",
     "@types/better-sqlite3": "^7.6.12",
     "@types/marked-terminal": "^6.1.1",
-    "@types/node": "^22.13.4",
+    "@types/node": "^22.13.9",
     "restmix": "^0.5.0",
-    "rollup": "^4.34.8",
+    "rollup": "^4.34.9",
     "ts-node": "^10.9.2",
     "tslib": "2.8.1",
-    "typescript": "^5.7.3"
+    "typescript": "^5.8.2"
   },
   "type": "module",
   "preferGlobal": true,