@agent-smith/task 0.0.2

package/dist/inferparams.d.ts

@@ -0,0 +1,5 @@
+import { InferenceParams } from "@locallm/types";
+import { PromptTemplate } from "modprompt/dist/cls";
+import { TaskConf } from "./interfaces";
+declare function formatInferParams(ip: InferenceParams, conf: TaskConf, tpl?: PromptTemplate): InferenceParams;
+export { formatInferParams, };

package/dist/inferparams.js

@@ -0,0 +1,17 @@
+function formatInferParams(ip, conf, tpl) {
+    if (!ip?.stop) {
+        ip.stop = [];
+    }
+    if (tpl?.stop) {
+        ip.stop.push(...tpl.stop);
+    }
+    const _ip = ip;
+    // override infer params
+    if (conf?.inferParams) {
+        for (const [k, v] of Object.entries(conf.inferParams)) {
+            _ip[k] = v;
+        }
+    }
+    return _ip;
+}
+export { formatInferParams, };

package/dist/interfaces.d.ts

@@ -0,0 +1,86 @@
+import { InferenceParams, InferenceResult, InferenceOptions, ToolSpec, HistoryTurn, ToolCallSpec } from "@locallm/types";
+import { PromptTemplate } from "modprompt";
+interface ModelSpec {
+    name: string;
+    template?: string;
+    ctx?: number;
+    system?: string;
+    afterSystem?: string;
+    assistant?: string;
+    inferParams?: InferenceParams;
+}
+/**
+ * Represents the input configuration for a language model task.
+ *
+ * @interface TaskInput
+ * @param {string} prompt - The user's input prompt for the task.
+ */
+interface TaskInput {
+    prompt: string;
+    [key: string]: any;
+}
+/**
+ * Configuration interface for a language model task.
+ *
+ * @interface TaskConf
+ * @param {ModelSpec} [model] - Optional model configuration.
+ * @param {ModelSpec} [modelname] - Optional model name for the task models list.
+ * @param {InferenceParams} [inferParams] - Optional inference parameters.
+ * @param {boolean} [debug] - Optional debug flag.
+ * @param {boolean} [quiet] - Optional quiet flag.
+ */
+interface TaskConf {
+    model?: ModelSpec;
+    modelname?: string;
+    inferParams?: InferenceParams;
+    options?: InferenceOptions;
+    debug?: boolean;
+    verbose?: boolean;
+    onToolCall?: (tc: ToolCallSpec) => void;
+    onToolCallEnd?: (tr: any) => void;
+}
+/**
+ * Represents a template specification for a language model task.
+ *
+ * @interface TemplateSpec
+ * @param {string} [system] - The system message for the template.
+ * @param {Array<string>} [stop] - Extra stop sequences for the template.
+ * @param {string} [assistant] - The assistant start message for the template.
+ * @example
+ * const template: TemplateSpec = {
+ *   system: "You are a helpful AI",
+ *   stop: ["\n", "</s>"],
+ * };
+ */
+interface TemplateSpec {
+    system?: string;
+    afterSystem?: string;
+    stop?: Array<string>;
+    assistant?: string;
+}
+interface TaskVariableDef {
+    type: string | Array<string>;
+    description: string;
+}
+interface TaskDef {
+    name: string;
+    description: string;
+    prompt: string;
+    template?: TemplateSpec;
+    inferParams?: InferenceParams;
+    model: ModelSpec;
+    models?: Record<string, ModelSpec>;
+    shots?: Array<HistoryTurn>;
+    variables?: {
+        required?: Record<string, TaskVariableDef>;
+        optional?: Record<string, TaskVariableDef>;
+    };
+    tools?: Array<ToolSpec>;
+    toolsList?: Array<string>;
+}
+interface TaskOutput {
+    answer: InferenceResult;
+    errors: Record<string, string>;
+    template?: PromptTemplate;
+}
+export { ModelSpec, TaskInput, TaskDef, TemplateSpec, TaskConf, TaskOutput, TaskVariableDef, };

package/dist/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/main.d.ts

@@ -0,0 +1,3 @@
+import { Task } from "./task.js";
+import { ModelSpec, TaskInput, TaskDef, TemplateSpec, TaskConf, TaskOutput, TaskVariableDef } from "./interfaces.js";
+export { Task, ModelSpec, TaskInput, TaskDef, TemplateSpec, TaskConf, TaskOutput, TaskVariableDef, };

package/dist/main.js

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

package/dist/task.d.ts

@@ -0,0 +1,12 @@
+import { ToolSpec } from '@locallm/types';
+import { Agent } from "../../agent/dist/agent.js";
+import { TaskConf, TaskDef, TaskInput, TaskOutput } from "./interfaces.js";
+declare class Task {
+    def: TaskDef;
+    agent: Agent;
+    constructor(agent: Agent, def: TaskDef);
+    static fromYaml(agent: Agent, txt: string): Task;
+    run(params: TaskInput, conf?: TaskConf): Promise<TaskOutput>;
+    addTools(tools: Array<ToolSpec>): Task;
+}
+export { Task };

package/dist/task.js

@@ -0,0 +1,108 @@
+import { PromptTemplate } from 'modprompt';
+import YAML from 'yaml';
+import { formatInferParams } from './inferparams.js';
+import { formatTaskTemplate } from './templates.js';
+import { applyVariables } from './variables.js';
+class Task {
+    def;
+    agent;
+    constructor(agent, def) {
+        this.agent = agent;
+        this.def = def;
+    }
+    static fromYaml(agent, txt) {
+        const data = YAML.parse(txt);
+        return new Task(agent, data);
+    }
+    async run(params, conf) {
+        //console.log("P", params);
+        //console.log("TOOLS", this.agent.tools);
+        if (!params?.prompt) {
+            throw new Error("Please provide a prompt parameter");
+        }
+        let model = this.def.model;
+        const useTemplates = this.agent.lm.providerType !== "openai";
+        if (conf) {
+            if (conf?.model) {
+                model = conf.model;
+            }
+            if (conf?.modelname) {
+                let found = false;
+                if (this.def?.models) {
+                    for (const [modelName, _mod] of Object.entries(this.def.models)) {
+                        if (modelName == conf.modelname) {
+                            found = true;
+                            const m = _mod;
+                            model = m;
+                            break;
+                        }
+                    }
+                }
+                if (!found) {
+                    throw new Error(`No model found for ${conf.modelname}. Available models:\n${params?.models}`);
+                }
+            }
+        }
+        if (this.agent.lm.providerType == "ollama") {
+            await this.agent.lm.loadModel(model.name, model.ctx);
+        }
+        this.def = applyVariables(this.def, params);
+        let tpl = new PromptTemplate("none");
+        let finalPrompt;
+        const options = {};
+        const agentToolsList = Object.values(this.agent.tools);
+        if (useTemplates) {
+            tpl = formatTaskTemplate(this.def, model?.template ? model.template : undefined);
+            this.def.inferParams = formatInferParams(this.def.inferParams ?? {}, conf ?? {}, tpl);
+            tpl.replacePrompt(this.def.prompt);
+            if (agentToolsList.length > 0) {
+                if (!tpl?.toolsDef) {
+                    throw new Error(`The template ${tpl.name} does not have tools and the task ${this.def.name} specifies some`);
+                }
+                agentToolsList.forEach((t) => tpl.addTool(t));
+            }
+            ;
+            finalPrompt = tpl.prompt(params.prompt);
+        }
+        else {
+            this.def.inferParams = formatInferParams(this.def.inferParams ?? {}, conf ?? {});
+            finalPrompt = this.def.prompt.replace("{prompt}", params.prompt);
+        }
+        if (agentToolsList.length > 0) {
+            options.tools = agentToolsList;
+        }
+        if (conf?.debug) {
+            console.log("-----------", model.name, "/", model.template, "-----------");
+            console.log(finalPrompt);
+            console.log("----------------------------------------------");
+            console.log("Infer params:", this.def.inferParams);
+            console.log("----------------------------------------------");
+        }
+        if (!this.def.inferParams?.extra) {
+            this.def.inferParams["extra"] = {};
+        }
+        if (this.agent.lm.providerType == "ollama") {
+            // tell Ollama to apply no template
+            this.def.inferParams["extra"]["raw"] = true;
+        }
+        let answer;
+        if (!useTemplates) {
+            if (this.def.template?.system) {
+                options.system = this.def.template.system;
+            }
+            if (this.def?.shots) {
+                options.history = this.def.shots;
+            }
+            answer = await this.agent.run(finalPrompt, this.def.inferParams, options);
+        }
+        else {
+            answer = await this.agent.run(finalPrompt, this.def.inferParams, options, tpl);
+        }
+        return { answer: answer, errors: {}, template: useTemplates ? tpl : undefined };
+    }
+    addTools(tools) {
+        tools.forEach(t => this.agent.tools[t.name] = t);
+        return this;
+    }
+}
+export { Task };

package/dist/templates.d.ts

@@ -0,0 +1,4 @@
+import { PromptTemplate } from "modprompt";
+import { TaskDef } from "./interfaces.js";
+declare function formatTaskTemplate(taskDef: TaskDef, templateName?: string): PromptTemplate;
+export { formatTaskTemplate, };

package/dist/templates.js

@@ -0,0 +1,43 @@
+import { PromptTemplate } from "modprompt";
+import { useTemplateForModel } from "@agent-smith/tfm";
+const tfm = useTemplateForModel();
+function formatTaskTemplate(taskDef, templateName) {
+    if ((!taskDef.model?.template)) {
+        const gt = tfm.guess(taskDef.model.name);
+        if (gt == "none") {
+            throw new Error(`Unable to guess the template for ${taskDef.model}: please provide a template in the taskDef definition`);
+        }
+        taskDef.model.template = gt;
+    }
+    const tpl = new PromptTemplate(templateName ?? taskDef.model.template);
+    if (taskDef?.template) {
+        if (taskDef.template?.system) {
+            tpl.replaceSystem(taskDef.template.system);
+        }
+        if (taskDef.template?.afterSystem) {
+            tpl.afterSystem(taskDef.template.afterSystem);
+        }
+        if (taskDef.template?.assistant) {
+            tpl.afterAssistant(" " + taskDef.template.assistant);
+        }
+    }
+    // model overrides
+    if (taskDef.model?.system) {
+        tpl.replaceSystem(taskDef.model.system);
+    }
+    if (taskDef.model?.afterSystem) {
+        tpl.afterSystem(taskDef.model.afterSystem);
+    }
+    if (taskDef.model?.assistant) {
+        tpl.afterAssistant(taskDef.model.assistant);
+    }
+    // shots
+    if (taskDef?.shots) {
+        taskDef.shots.forEach((s) => {
+            //console.log("** SHOT", s);
+            tpl.addShot(s);
+        });
+    }
+    return tpl;
+}
+export { formatTaskTemplate, };

package/dist/variables.d.ts

@@ -0,0 +1,3 @@
+import { TaskDef, TaskInput } from "./interfaces.js";
+declare function applyVariables(taskDef: TaskDef, taskInput: TaskInput): TaskDef;
+export { applyVariables, };

package/dist/variables.js

@@ -0,0 +1,25 @@
+function applyVariables(taskDef, taskInput) {
+    // check taskDef variables
+    if (taskDef?.variables) {
+        if (taskDef.variables?.required) {
+            for (const name of Object.keys(taskDef.variables.required)) {
+                if (!(name in taskInput)) {
+                    throw new Error(`The variable ${name} is required to run this taskDef`);
+                }
+            }
+        }
+        if (taskDef.variables?.optional) {
+            for (const name of Object.keys(taskDef.variables.optional)) {
+                if (!(name in taskInput)) {
+                    taskDef.prompt = taskDef.prompt.replaceAll(`{${name}}`, "");
+                }
+            }
+        }
+    }
+    // apply variables
+    for (const [k, v] of Object.entries(taskInput)) {
+        taskDef.prompt = taskDef.prompt.replaceAll(`{${k}}`, v);
+    }
+    return taskDef;
+}
+export { applyVariables, };

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@agent-smith/task",
+  "version": "0.0.2",
+  "description": "A toolkit to create human friendly agents: the language model tasks module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/synw/agent-smith.git"
+  },
+  "scripts": {
+    "buildrl": "rm -rf dist/* && rollup -c",
+    "build": "rm -rf dist/* && tsc",
+    "watch": "tsc -w",
+    "test": "jest --coverage",
+    "docs": "typedoc --entryPointStrategy expand"
+  },
+  "dependencies": {
+    "@agent-smith/agent": "^0.0.2",
+    "@agent-smith/tfm": "^0.1.2",
+    "@locallm/api": "0.4.2",
+    "modprompt": "^0.12.0",
+    "yaml": "^2.8.1"
+  },
+  "devDependencies": {
+    "@locallm/types": "^0.4.2",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.1.4",
+    "@types/node": "^24.4.0",
+    "markdown-it-replace-link": "^1.2.2",
+    "restmix": "^0.5.0",
+    "rollup": "^4.50.1",
+    "tslib": "^2.8.1",
+    "typedoc": "^0.28.12",
+    "typedoc-plugin-markdown": "^4.8.1",
+    "typedoc-plugin-rename-defaults": "^0.7.3",
+    "typescript": "^5.9.2"
+  },
+  "files": [
+    "dist"
+  ],
+  "module": "./dist/main.js",
+  "types": "./dist/main.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/main.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "license": "MIT"
+}