@agent-smith/agent 0.0.1 → 0.0.3

package/dist/agent.d.ts

@@ -6,11 +6,12 @@ declare class Agent {
     tools: Record<string, ToolSpec>;
     history: Array<HistoryTurn>;
     constructor(lm: Lm);
-    run(prompt: string, params: InferenceParams, options?: InferenceOptions, template?: PromptTemplate): Promise<InferenceResult>;
+    run(prompt: string, params: InferenceParams, options?: InferenceOptions, template?: PromptTemplate | string): 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;
     }>;
+    abort(): Promise<void>;
 }
 export { Agent, };

package/dist/agent.js

@@ -1,3 +1,4 @@
+import { PromptTemplate } from 'modprompt';
 class Agent {
     lm;
     tools = {};
@@ -6,23 +7,41 @@ class Agent {
         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);
-                }
-            });
+        let tpl;
+        if (options?.debug) {
+            console.log("Agent inference params:", params);
+            console.log("Agent options:", options);
+            console.log("Agent template:", template);
+            console.log("Prompt:", prompt);
         }
         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}`);
+                if (params?.template) {
+                    tpl = new PromptTemplate(params.template);
+                }
+                else {
+                    throw new Error(`A template is required for provider ${this.lm.provider.name}`);
+                }
+            }
+            else {
+                if (typeof template == "string") {
+                    tpl = new PromptTemplate(template);
+                }
+                else {
+                    tpl = template;
+                }
+            }
+            this.tools = {};
+            if (options?.tools) {
+                options.tools.forEach(t => {
+                    this.tools[t.name] = t;
+                    tpl = tpl.addTool(t);
+                });
             }
-            return (await this.runAgentWithTemplate(1, prompt, params, options, template)).inferenceResult;
+            return (await this.runAgentWithTemplate(1, prompt, params, options, tpl)).inferenceResult;
         }
     }
     async runAgentNoTemplate(it, prompt, params, options = {}) {
@@ -72,17 +91,18 @@ class Agent {
         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}`);
+        console.log("Provider:", this.lm.provider);
+        if (this.lm.providerType == "ollama") {
+            if (!params?.model) {
+                throw new Error("A model inference parameters is required for provider Ollama");
+            }
+            await this.lm.loadModel(params.model.name, params.model.ctx);
         }
+        let res = await this.lm.infer(tpl.prompt(prompt), params, options);
         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) {
@@ -139,5 +159,8 @@ class Agent {
             return { inferenceResult: res, template: tpl };
         }
     }
+    async abort() {
+        this.lm.abort();
+    }
 }
 export { Agent, };

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@agent-smith/agent",
   "description": "Agent Smith: agent runtime",
-  "repository": "https://github.com/synw/agent-smith",
-  "version": "0.0.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/synw/agent-smith.git"
+  },
+  "version": "0.0.3",
   "scripts": {
     "buildrl": "rm -rf dist/* && rollup -c",
     "build": "rm -rf dist/* && tsc"
@@ -15,7 +18,7 @@
     "@locallm/types": "^0.4.2",
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-typescript": "^12.1.4",
-    "@types/node": "^24.3.1",
+    "@types/node": "^24.4.0",
     "rollup": "^4.50.1",
     "ts-node": "^10.9.2",
     "tslib": "2.8.1",