@agent-smith/server 0.0.2

package/dist/main.d.ts

@@ -0,0 +1,4 @@
+import { baseRoutes } from "./routes/index.js";
+import type Router from "@koa/router";
+declare function runServer(routes?: ((r: Router) => void)[], staticDir?: string): void;
+export { runServer, baseRoutes, };

package/dist/main.js

@@ -0,0 +1,7 @@
+import { runserver } from "./server/server.js";
+import { baseRoutes } from "./routes/index.js";
+function runServer(routes, staticDir) {
+    const r = routes ? [...baseRoutes, ...routes] : baseRoutes;
+    runserver(r, staticDir);
+}
+export { runServer, baseRoutes, };

package/dist/routes/index.d.ts

@@ -0,0 +1,3 @@
+import { Router } from "@koa/router";
+declare const baseRoutes: ((r: Router) => void)[];
+export { baseRoutes };

package/dist/routes/index.js

@@ -0,0 +1,4 @@
+import { getModelsCmd } from "./models.js";
+import { getTaskSettingsCmd, updateTaskSettingsCmd } from "./task_settings.js";
+const baseRoutes = new Array(getModelsCmd, getTaskSettingsCmd, updateTaskSettingsCmd);
+export { baseRoutes };

package/dist/routes/models.d.ts

@@ -0,0 +1,3 @@
+import type Router from '@koa/router';
+declare function getModelsCmd(r: Router): void;
+export { getModelsCmd, };

package/dist/routes/models.js

@@ -0,0 +1,38 @@
+import { backend } from '@agent-smith/cli';
+function getModelsCmd(r) {
+    r.get('/models', async (ctx, next) => {
+        let mi;
+        try {
+            mi = await backend.value?.modelsInfo();
+        }
+        catch (e) {
+            ctx.body = "error reading the models";
+            ctx.status = 502;
+            await next();
+            return;
+        }
+        const ms = {};
+        mi?.forEach(m => {
+            let prevArg = "";
+            let ctx = 0;
+            if (backend.value?.providerType == "openai") {
+                ms[m.name] = { status: "unknown", ctx: m?.ctx ?? ctx };
+            }
+            else {
+                //@ts-ignore            
+                m.extra.status.args.forEach(a => {
+                    if (prevArg == "--ctx-size") {
+                        ctx = parseInt(a);
+                    }
+                    //@ts-ignore
+                    ms[m.name] = { status: m.extra.status.value, ctx: ctx };
+                    prevArg = a;
+                });
+            }
+        });
+        ctx.body = ms;
+        ctx.status = 200;
+        await next();
+    });
+}
+export { getModelsCmd, };

package/dist/routes/task_settings.d.ts

@@ -0,0 +1,4 @@
+import type Router from '@koa/router';
+declare function getTaskSettingsCmd(r: Router): void;
+declare function updateTaskSettingsCmd(r: Router): void;
+export { getTaskSettingsCmd, updateTaskSettingsCmd, };

package/dist/routes/task_settings.js

@@ -0,0 +1,23 @@
+import { db } from '@agent-smith/cli';
+function getTaskSettingsCmd(r) {
+    r.get('/tasks/settings', async (ctx, next) => {
+        const ts = db.getTaskSettings();
+        ctx.body = ts;
+        ctx.status = 200;
+        await next();
+    });
+}
+function updateTaskSettingsCmd(r) {
+    r.post('/tasks/settings/update', async (ctx, next) => {
+        const data = ctx.request.body;
+        //console.log("DATA", data);
+        const name = data.name;
+        const settings = data.settings;
+        const ts = db.upsertTaskSettings(name, settings);
+        db.getTaskSettings(true);
+        ctx.body = ts;
+        ctx.status = 200;
+        await next();
+    });
+}
+export { getTaskSettingsCmd, updateTaskSettingsCmd, };

package/dist/server/router.d.ts

@@ -0,0 +1,3 @@
+import Router from '@koa/router';
+declare const useRouter: (routes?: Array<(r: Router) => void>) => Router<import("koa").DefaultState, import("koa").DefaultContext>;
+export { useRouter };

package/dist/server/router.js

@@ -0,0 +1,12 @@
+import Router from '@koa/router';
+const useRouter = (routes = []) => {
+    const router = new Router();
+    routes.forEach((f) => f(router));
+    router.get('/ping', async (ctx, next) => {
+        ctx.body = { ok: true };
+        ctx.status = 200;
+        await next();
+    });
+    return router;
+};
+export { useRouter };

package/dist/server/server.d.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { Router } from "@koa/router";
+declare function runserver(routes?: ((r: Router) => void)[], staticDir?: string): void;
+export { runserver };

package/dist/server/server.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+import { default as color } from "ansi-colors";
+import Koa from 'koa';
+import bodyParser from "koa-bodyparser";
+import cors from '@koa/cors';
+import { useRouter } from './router.js';
+import websockify from 'koa-websocket';
+import route from 'koa-route';
+import serve from "koa-static";
+import { executeTask, executeWorkflow, init } from '@agent-smith/cli';
+/* import { argv } from 'process';
+
+let env = "production";
+
+if (argv.length > 2) {
+  for (const arg of argv.slice(2, argv.length)) {
+    if (arg == "-d") {
+      env = "dev"
+    }
+  }
+}*/
+const logger = async (ctx, next) => {
+    const start = Date.now();
+    await next();
+    const duration = Date.now() - start;
+    console.log(`${ctx.method} ${ctx.url} - ${ctx.status} - ${duration}ms`);
+};
+const app = websockify(new Koa());
+app.use(bodyParser());
+app.use(logger);
+app.use(cors({
+    credentials: true
+}));
+app.ws.use(function (ctx, next) {
+    return next();
+});
+function createManualPromise() {
+    let resolveFn;
+    let rejectFn;
+    const promise = new Promise((resolve, reject) => {
+        resolveFn = resolve;
+        rejectFn = reject;
+    });
+    return {
+        promise,
+        resolve: resolveFn,
+        reject: rejectFn
+    };
+}
+function runserver(routes, staticDir) {
+    if (staticDir) {
+        app.use(serve(staticDir));
+    }
+    const router = useRouter(routes);
+    const sendTokensInterval = 100;
+    const confirmToolCalls = {};
+    app.ws.use(route.all('/ws', function (ctx) {
+        //ctx.websocket.send('Hello World');
+        let abort = new AbortController();
+        ctx.websocket.on('message', async function (message) {
+            const msg = JSON.parse(message);
+            if (!msg?.options) {
+                msg.options = {};
+            }
+            //console.log("ABO", abort);
+            msg.options.abort = abort;
+            //console.log(msg)
+            if (msg.type == "system") {
+                if (msg.command == "stop") {
+                    //console.log("STOP CMD");
+                    abort.abort("stopped");
+                    abort = new AbortController();
+                    return;
+                }
+                else if (msg.command == "confirmtool") {
+                    if (!(msg.payload.id in confirmToolCalls)) {
+                        const rsm = {
+                            type: "error",
+                            msg: `can not confirm tool call: unknown tool id ${msg.payload.id}`,
+                        };
+                        ctx.websocket.send(JSON.stringify(rsm));
+                        return;
+                    }
+                    if (msg.payload.confirm == true) {
+                        confirmToolCalls[msg.payload.id](true);
+                    }
+                    else {
+                        confirmToolCalls[msg.payload.id](false);
+                    }
+                    delete confirmToolCalls[msg.payload.id];
+                }
+                else {
+                    console.error(`unknown system command ${msg.payload}`);
+                }
+            }
+            else {
+                if (!msg?.payload) {
+                    const rsm = {
+                        type: "error",
+                        msg: "provide a payload",
+                    };
+                    ctx.websocket.send(JSON.stringify(rsm));
+                    return;
+                }
+                await init();
+                if (msg.feature == "task") {
+                    let buf = "";
+                    msg.options.onToken = (t) => {
+                        buf += t;
+                        process.stdout.write(t);
+                    };
+                    try {
+                        const it = setInterval(() => {
+                            const rsm = {
+                                type: "token",
+                                msg: buf,
+                            };
+                            ctx.websocket.send(JSON.stringify(rsm));
+                            buf = "";
+                        }, sendTokensInterval);
+                        const res = await executeTask(msg.command, msg.payload, msg.options);
+                        setTimeout(() => {
+                            clearInterval(it);
+                        }, sendTokensInterval);
+                        //console.dir(res, { depth: 3 });
+                        let r;
+                        if (res.template.id == "none") {
+                            r = { assistant: res.answer.text };
+                        }
+                        else {
+                            r = res.template.history.pop();
+                        }
+                        const rsm = {
+                            type: "finalresult",
+                            msg: JSON.stringify(r),
+                        };
+                        ctx.websocket.send(JSON.stringify(rsm));
+                    }
+                    catch (e) {
+                        const rsm = {
+                            type: "error",
+                            msg: `${e}`,
+                        };
+                        ctx.websocket.send(JSON.stringify(rsm));
+                    }
+                }
+                else if (msg.feature == "agent") {
+                    msg.options.onToolsTurnStart = (tcs) => {
+                        const rsm = {
+                            type: "finalresult",
+                            msg: JSON.stringify(tcs),
+                        };
+                        ctx.websocket.send(JSON.stringify(rsm));
+                    };
+                    msg.options.onToolsTurnEnd = (tr) => {
+                        const rsm = {
+                            type: "toolsturnend",
+                            msg: JSON.stringify(tr),
+                        };
+                        ctx.websocket.send(JSON.stringify(rsm));
+                    };
+                    msg.options.onTurnEnd = (ht) => {
+                        const rsm = {
+                            type: "turnend",
+                            msg: JSON.stringify(ht),
+                        };
+                        ctx.websocket.send(JSON.stringify(rsm));
+                    };
+                    msg.options.onAssistant = (txt) => {
+                        const rsm = {
+                            type: "assistant",
+                            msg: txt,
+                        };
+                        ctx.websocket.send(JSON.stringify(rsm));
+                    };
+                    msg.options.onToolCall = (tc) => {
+                        if (!tc?.id) {
+                            tc.id = crypto.randomUUID();
+                        }
+                        const rsm = {
+                            type: "toolcall",
+                            msg: JSON.stringify(tc),
+                        };
+                        ctx.websocket.send(JSON.stringify(rsm));
+                        console.log("\n⚒️ ", color.bold(msg.command), "=>", `${color.yellowBright(tc.name)}`, tc.arguments);
+                    };
+                    msg.options.onToolCallEnd = (id, tr) => {
+                        let toolResData;
+                        if (typeof tr == 'object') {
+                            if (tr?.answer?.text) {
+                                // comes from an inference task
+                                toolResData = tr.answer.text;
+                            }
+                            else {
+                                toolResData = JSON.stringify(tr);
+                            }
+                        }
+                        else {
+                            toolResData = tr.toString();
+                        }
+                        const rsm = {
+                            type: "toolcallend",
+                            msg: `${id}<|xtool_call_id|>` + toolResData,
+                        };
+                        ctx.websocket.send(JSON.stringify(rsm));
+                    };
+                    msg.options.confirmToolUsage = async (tc) => {
+                        if (!tc?.id) {
+                            tc.id = crypto.randomUUID();
+                        }
+                        const rsm = {
+                            type: "toolcallconfirm",
+                            msg: JSON.stringify(tc),
+                        };
+                        const { promise, resolve } = createManualPromise();
+                        confirmToolCalls[tc.id] = resolve;
+                        ctx.websocket.send(JSON.stringify(rsm));
+                        const res = await promise;
+                        return res;
+                    };
+                    msg.options.isAgent = true;
+                    try {
+                        let buf = "";
+                        msg.options.onToken = (t) => {
+                            buf += t;
+                            process.stdout.write(t);
+                        };
+                        const it = setInterval(() => {
+                            if (buf == "") {
+                                return;
+                            }
+                            ;
+                            const rsm = {
+                                type: "token",
+                                msg: buf,
+                            };
+                            ctx.websocket.send(JSON.stringify(rsm));
+                            buf = "";
+                        }, sendTokensInterval);
+                        const res = await executeTask(msg.command, msg.payload, msg.options);
+                        setTimeout(() => {
+                            clearInterval(it);
+                        }, sendTokensInterval);
+                        const ht = JSON.stringify(res.template.history.pop());
+                        //console.log("FINAL MSG", ht)
+                        const rsm = {
+                            type: "finalresult",
+                            msg: ht,
+                        };
+                        ctx.websocket.send(JSON.stringify(rsm));
+                    }
+                    catch (e) {
+                        const rsm = {
+                            type: "error",
+                            msg: `${e}`
+                        };
+                        ctx.websocket.send(JSON.stringify(rsm));
+                    }
+                }
+                else if (msg.feature == "workflow") {
+                    try {
+                        const res = await executeWorkflow(msg.command, msg.payload, msg.options);
+                        const rsm = {
+                            type: "finalresult",
+                            msg: res,
+                        };
+                        ctx.websocket.send(JSON.stringify(rsm));
+                    }
+                    catch (e) {
+                        const rsm = {
+                            type: "error",
+                            msg: `${e}`
+                        };
+                        ctx.websocket.send(JSON.stringify(rsm));
+                    }
+                }
+                /*else if (msg.type == "cmd") {
+                  await init();
+                  msg.options.onToken = (t: string) => {
+                    process.stdout.write(t);
+                    ctx.websocket.send(t);
+                  };
+                  await executeCmd(msg.name, msg.payload, msg.options);
+                }*/
+                else {
+                    const rsm = {
+                        type: "error",
+                        msg: "command type " + msg.feature + " not supported"
+                    };
+                    ctx.websocket.send(JSON.stringify(rsm));
+                }
+            }
+            abort = new AbortController();
+        });
+    }));
+    app.use(router.routes()).use(router.allowedMethods());
+    app.listen(5184, () => {
+        console.log('Please open localhost:5184 in a browser');
+    });
+}
+export { runserver };

package/dist/server/state.d.ts

@@ -0,0 +1,2 @@
+declare const dirpath: string;
+export { dirpath };

package/dist/server/state.js

@@ -0,0 +1,5 @@
+import { fileURLToPath } from 'url';
+import path from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const dirpath = path.dirname(__filename);
+export { dirpath };

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@agent-smith/server",
+  "version": "0.0.2",
+  "description": "Agent Smith Nodejs server",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "rm -rf dist && tsc",
+    "start": "node dist/index.js",
+    "server": "node --loader ts-node/esm src/index.ts",
+    "devserver": "node  --loader ts-node/esm --watch src/index.ts"
+  },
+  "type": "module",
+  "dependencies": {
+    "@agent-smith/cli": "^0.0.111",
+    "@koa/cors": "^5.0.0",
+    "@koa/router": "^15.3.0",
+    "ansi-colors": "^4.1.3",
+    "koa": "^3.1.1",
+    "koa-bodyparser": "^4.4.1",
+    "koa-route": "^4.0.1",
+    "koa-static": "^5.0.0",
+    "koa-websocket": "^7.0.0"
+  },
+  "devDependencies": {
+    "@agent-smith/types": "^0.0.2",
+    "@locallm/types": "^0.7.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/koa": "^3.0.1",
+    "@types/koa__cors": "^5.0.1",
+    "@types/koa-bodyparser": "^4.3.13",
+    "@types/koa-route": "^3.2.9",
+    "@types/koa-static": "^4.0.4",
+    "@types/koa-websocket": "^5.0.11",
+    "@types/node": "^25.3.0",
+    "ts-node": "^10.9.2",
+    "tslib": "2.8.1",
+    "typescript": "^5.9.3"
+  },
+  "preferGlobal": true,
+  "main": "./dist/main.js",
+  "types": "./dist/main.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/main.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "agentserver": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "license": "MIT"
+}