@agent-smith/agent 0.0.1

package/dist/agent.d.ts

@@ -0,0 +1,16 @@
+import { Lm } from "@locallm/api";
+import { InferenceParams, ToolSpec, HistoryTurn, InferenceOptions, InferenceResult } from "@locallm/types";
+import { PromptTemplate } from 'modprompt';
+declare class Agent {
+    lm: Lm;
+    tools: Record<string, ToolSpec>;
+    history: Array<HistoryTurn>;
+    constructor(lm: Lm);
+    run(prompt: string, params: InferenceParams, options?: InferenceOptions, template?: PromptTemplate): Promise<InferenceResult>;
+    runAgentNoTemplate(it: number, prompt: string, params: InferenceParams, options?: InferenceOptions): Promise<InferenceResult>;
+    runAgentWithTemplate(it: number, prompt: string, params: InferenceParams, options: InferenceOptions | undefined, tpl: PromptTemplate): Promise<{
+        inferenceResult: InferenceResult;
+        template: PromptTemplate;
+    }>;
+}
+export { Agent, };

package/dist/agent.js

@@ -0,0 +1,143 @@
+class Agent {
+    lm;
+    tools = {};
+    history = [];
+    constructor(lm) {
+        this.lm = lm;
+    }
+    async run(prompt, params, options = {}, template) {
+        this.tools = {};
+        if (options?.tools) {
+            options.tools.forEach(t => {
+                this.tools[t.name] = t;
+                if (template) {
+                    template = template.addTool(t);
+                }
+            });
+        }
+        if (this.lm.providerType == "openai") {
+            return await this.runAgentNoTemplate(1, prompt, params, options);
+        }
+        else {
+            if (!template) {
+                throw new Error(`A template is required for provider ${this.lm.provider.name}`);
+            }
+            return (await this.runAgentWithTemplate(1, prompt, params, options, template)).inferenceResult;
+        }
+    }
+    async runAgentNoTemplate(it, prompt, params, options = {}) {
+        const res = await this.lm.infer(prompt, params, options);
+        this.history.push({ user: prompt });
+        let _res = res;
+        if (res?.toolCalls) {
+            const toolsResults = new Array();
+            const toolNames = Object.keys(this.tools);
+            for (const tc of res.toolCalls) {
+                if (!toolNames.includes(tc.name)) {
+                    throw new Error(`Inexistant tool ${tc.name} called (available tools: ${toolNames})`);
+                }
+                const tool = this.tools[tc.name];
+                let canRun = true;
+                if (tool?.canRun) {
+                    canRun = await tool.canRun(tool);
+                }
+                if (canRun) {
+                    const toolCallResult = await tool.execute(tc.arguments);
+                    if (options?.debug || options?.verbose) {
+                        console.log("[x] Executed tool", tool.name + ":", toolCallResult);
+                    }
+                    toolsResults.push({ call: tc, response: toolCallResult });
+                }
+                else {
+                    if (options?.debug || options?.verbose) {
+                        console.log("[-] Tool", tool.name, "execution refused");
+                    }
+                }
+            }
+            this.history.push({ tools: toolsResults });
+            if (options?.tools) {
+                options.tools = Object.values(this.tools);
+            }
+            const nit = it + 1;
+            if (nit > 1 && options?.debug) {
+                options.debug = false;
+                options.verbose = true;
+            }
+            options.history = this.history;
+            _res = await this.runAgentNoTemplate(nit, " ", params, options);
+        }
+        else {
+            this.history.push({ assistant: res.text });
+        }
+        return _res;
+    }
+    async runAgentWithTemplate(it, prompt, params, options = {}, tpl) {
+        let res = await this.lm.infer(tpl.prompt(prompt), params, options);
+        const toolResponseStart = tpl.toolsDef?.response.split("{tools_response}")[0];
+        const toolCallStart = tpl.toolsDef?.response.split("{tool}")[0];
+        if (!toolCallStart || !toolResponseStart) {
+            throw new Error(`Tool definition malformed in template ${tpl.name}`);
+        }
+        const { isToolCall, toolsCall, error } = tpl.processAnswer(res.text);
+        if (error) {
+            throw new Error(`error processing tool call answer:\n, ${error}`);
+        }
+        console.log("\nProcessed answer", isToolCall, toolsCall, error);
+        const toolResults = new Array();
+        if (isToolCall) {
+            for (const toolCall of toolsCall) {
+                if (!("name" in toolCall)) {
+                    throw new Error(`tool call does not includes a name in it's response:\n${toolCall}`);
+                }
+                if (!("arguments" in toolCall)) {
+                    toolCall.arguments = {};
+                }
+                const tool = toolCall.name in this.tools ? this.tools[toolCall.name] : null;
+                if (!tool) {
+                    const buf = new Array(`wrong tool call ${toolCall.name} from the model:`, JSON.stringify(toolCall, null, "  "), `It does not exist in the tools list:. Available tools:`, JSON.stringify(Object.keys(this.tools), null, "  "));
+                    throw new Error(buf.join("\n"));
+                }
+                if (options?.debug === true) {
+                    console.log("\n* Calling tool", tool.name + ":", toolCall.arguments);
+                }
+                const toolResp = await tool.execute(toolCall.arguments);
+                if (options?.debug || options?.verbose) {
+                    console.log("[x] Executed tool", tool.name + ":", toolResp);
+                }
+                toolResults.push({
+                    call: toolCall,
+                    response: toolResp
+                });
+            }
+            if (it == 1) {
+                tpl.pushToHistory({
+                    user: prompt.replace("{prompt}", prompt),
+                    assistant: res.text,
+                    tools: toolResults,
+                });
+            }
+            else {
+                tpl.pushToHistory({
+                    assistant: res.text,
+                    tools: toolResults,
+                });
+            }
+            return await this.runAgentWithTemplate(it + 1, prompt, params, options, tpl);
+        }
+        else {
+            if (it == 1) {
+                tpl.pushToHistory({
+                    user: prompt.replace("{prompt}", prompt),
+                    assistant: res.text,
+                });
+            }
+            else {
+                tpl.pushToHistory({
+                    assistant: res.text,
+                });
+            }
+            return { inferenceResult: res, template: tpl };
+        }
+    }
+}
+export { Agent, };

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+import { Agent } from "./agent.js";
+export { Agent, };

package/dist/main.js

@@ -0,0 +1,2 @@
+import { Agent } from "./agent.js";
+export { Agent, };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@agent-smith/agent",
+  "description": "Agent Smith: agent runtime",
+  "repository": "https://github.com/synw/agent-smith",
+  "version": "0.0.1",
+  "scripts": {
+    "buildrl": "rm -rf dist/* && rollup -c",
+    "build": "rm -rf dist/* && tsc"
+  },
+  "dependencies": {
+    "@locallm/api": "^0.4.2",
+    "modprompt": "^0.12.0"
+  },
+  "devDependencies": {
+    "@locallm/types": "^0.4.2",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-typescript": "^12.1.4",
+    "@types/node": "^24.3.1",
+    "rollup": "^4.50.1",
+    "ts-node": "^10.9.2",
+    "tslib": "2.8.1",
+    "typescript": "^5.9.2"
+  },
+  "type": "module",
+  "main": "./dist/main.js",
+  "exports": {
+    ".": {
+      "import": "./dist/main.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "license": "MIT"
+}