pretticlaw 0.1.0

package/dist/agent/loop.js

@@ -0,0 +1,244 @@
+import path from "node:path";
+import { ContextBuilder } from "./context.js";
+import { MemoryStore } from "./memory.js";
+import { SubagentManager } from "./subagent.js";
+import { ReadFileTool, WriteFileTool, EditFileTool, ListDirTool } from "./tools/filesystem.js";
+import { ExecTool } from "./tools/shell.js";
+import { WebSearchTool, WebFetchTool } from "./tools/web.js";
+import { MessageTool } from "./tools/message.js";
+import { SpawnTool } from "./tools/spawn.js";
+import { CronTool } from "./tools/cron.js";
+import { ToolRegistry } from "./tools/registry.js";
+import { sessionKey as getSessionKey } from "../bus/events.js";
+import { SessionManager } from "../session/manager.js";
+function stripThink(text) {
+    if (!text)
+        return null;
+    return text.replace(/<think>[\s\S]*?<\/think>/g, "").trim() || null;
+}
+export class AgentLoop {
+    input;
+    context;
+    sessions;
+    tools;
+    subagents;
+    running = false;
+    consolidating = new Set();
+    activeTasks = new Map();
+    processing = Promise.resolve();
+    static TOOL_RESULT_MAX_CHARS = 500;
+    constructor(input) {
+        this.input = input;
+        const workspace = path.resolve(input.workspace);
+        this.context = new ContextBuilder(workspace);
+        this.sessions = input.sessionManager ?? new SessionManager(workspace);
+        this.tools = new ToolRegistry();
+        const model = input.model ?? input.provider.getDefaultModel();
+        this.subagents = new SubagentManager(input.provider, workspace, input.bus, model, input.temperature ?? 0.1, input.maxTokens ?? 4096, input.braveApiKey ?? null, input.execConfig ?? { timeout: 60, pathAppend: "" }, !!input.restrictToWorkspace);
+        this.registerDefaultTools();
+    }
+    get model() {
+        return this.input.model ?? this.input.provider.getDefaultModel();
+    }
+    get channelsConfig() {
+        return this.input.channelsConfig;
+    }
+    registerDefaultTools() {
+        const workspace = path.resolve(this.input.workspace);
+        const allowed = this.input.restrictToWorkspace ? workspace : undefined;
+        this.tools.register(new ReadFileTool(workspace, allowed));
+        this.tools.register(new WriteFileTool(workspace, allowed));
+        this.tools.register(new EditFileTool(workspace, allowed));
+        this.tools.register(new ListDirTool(workspace, allowed));
+        this.tools.register(new ExecTool(this.input.execConfig?.timeout ?? 60, workspace, !!this.input.restrictToWorkspace, this.input.execConfig?.pathAppend ?? ""));
+        this.tools.register(new WebSearchTool(this.input.braveApiKey ?? null));
+        this.tools.register(new WebFetchTool());
+        this.tools.register(new MessageTool((msg) => this.input.bus.publishOutbound(msg)));
+        this.tools.register(new SpawnTool(this.subagents));
+        if (this.input.cronService)
+            this.tools.register(new CronTool(this.input.cronService));
+    }
+    setToolContext(channel, chatId, messageId) {
+        const message = this.tools.get("message");
+        if (message && message instanceof MessageTool)
+            message.setContext(channel, chatId, messageId);
+        const spawn = this.tools.get("spawn");
+        if (spawn?.setContext)
+            spawn.setContext(channel, chatId);
+        const cron = this.tools.get("cron");
+        if (cron?.setContext)
+            cron.setContext(channel, chatId);
+    }
+    toolHint(toolCalls) {
+        return toolCalls.map((tc) => {
+            const val = Object.values(tc.arguments ?? {})[0];
+            if (typeof val !== "string")
+                return tc.name;
+            return val.length > 40 ? `${tc.name}("${val.slice(0, 40)}...")` : `${tc.name}("${val}")`;
+        }).join(", ");
+    }
+    async runAgentLoop(initialMessages, onProgress) {
+        const messages = [...initialMessages];
+        let finalContent = null;
+        const toolsUsed = [];
+        const maxIterations = this.input.maxIterations ?? 40;
+        for (let iteration = 0; iteration < maxIterations; iteration++) {
+            const response = await this.input.provider.chat({
+                messages,
+                tools: this.tools.getDefinitions(),
+                model: this.model,
+                temperature: this.input.temperature ?? 0.1,
+                maxTokens: this.input.maxTokens ?? 4096,
+            });
+            if (response.toolCalls.length) {
+                if (onProgress) {
+                    const clean = stripThink(response.content);
+                    if (clean)
+                        await onProgress(clean, { toolHint: false });
+                    await onProgress(this.toolHint(response.toolCalls), { toolHint: true });
+                }
+                const toolCallDicts = response.toolCalls.map((tc) => ({ id: tc.id, type: "function", function: { name: tc.name, arguments: JSON.stringify(tc.arguments) } }));
+                this.context.addAssistantMessage(messages, response.content, toolCallDicts, response.reasoningContent);
+                for (const call of response.toolCalls) {
+                    toolsUsed.push(call.name);
+                    const result = await this.tools.execute(call.name, call.arguments);
+                    this.context.addToolResult(messages, call.id, call.name, result);
+                }
+            }
+            else {
+                finalContent = stripThink(response.content);
+                this.context.addAssistantMessage(messages, finalContent, undefined, response.reasoningContent);
+                break;
+            }
+        }
+        if (finalContent == null) {
+            finalContent = `I reached the maximum number of tool call iterations (${maxIterations}) without completing the task.`;
+        }
+        return { finalContent, toolsUsed, messages };
+    }
+    async run() {
+        this.running = true;
+        while (this.running) {
+            const msg = await this.input.bus.consumeInbound();
+            if (msg.content.trim().toLowerCase() === "/stop") {
+                await this.handleStop(msg);
+                continue;
+            }
+            const session = getSessionKey(msg);
+            const task = this.dispatch(msg).finally(() => {
+                const set = this.activeTasks.get(session);
+                if (!set)
+                    return;
+                set.delete(task);
+                if (!set.size)
+                    this.activeTasks.delete(session);
+            });
+            if (!this.activeTasks.has(session))
+                this.activeTasks.set(session, new Set());
+            this.activeTasks.get(session).add(task);
+        }
+    }
+    stop() {
+        this.running = false;
+    }
+    async processDirect(content, session = "cli:direct", channel = "cli", chatId = "direct", onProgress) {
+        const msg = { channel, senderId: "user", chatId, content };
+        const out = await this.processMessage(msg, session, onProgress);
+        return out?.content ?? "";
+    }
+    async dispatch(msg) {
+        this.processing = this.processing.then(async () => {
+            try {
+                const response = await this.processMessage(msg);
+                if (response) {
+                    await this.input.bus.publishOutbound(response);
+                }
+                else if (msg.channel === "cli") {
+                    await this.input.bus.publishOutbound({ channel: msg.channel, chatId: msg.chatId, content: "", metadata: msg.metadata ?? {} });
+                }
+            }
+            catch {
+                await this.input.bus.publishOutbound({ channel: msg.channel, chatId: msg.chatId, content: "Sorry, I encountered an error." });
+            }
+        });
+        return this.processing;
+    }
+    async handleStop(msg) {
+        const key = getSessionKey(msg);
+        const tasks = [...(this.activeTasks.get(key) ?? [])];
+        const subCancelled = await this.subagents.cancelBySession(key);
+        const total = tasks.length + subCancelled;
+        await this.input.bus.publishOutbound({ channel: msg.channel, chatId: msg.chatId, content: total ? `Stopped ${total} task(s).` : "No active task to stop." });
+    }
+    async consolidateMemory(session, archiveAll = false) {
+        return new MemoryStore(this.input.workspace).consolidate(session, this.input.provider, this.model, { archiveAll, memoryWindow: this.input.memoryWindow ?? 100 });
+    }
+    saveTurn(session, messages, skip) {
+        for (const m of messages.slice(skip)) {
+            const entry = { ...m };
+            delete entry.reasoning_content;
+            if (entry.role === "tool" && typeof entry.content === "string" && entry.content.length > AgentLoop.TOOL_RESULT_MAX_CHARS) {
+                entry.content = `${entry.content.slice(0, AgentLoop.TOOL_RESULT_MAX_CHARS)}\n... (truncated)`;
+            }
+            if (entry.role === "user" && typeof entry.content === "string" && entry.content.startsWith(ContextBuilder.RUNTIME_CONTEXT_TAG))
+                continue;
+            if (!entry.timestamp)
+                entry.timestamp = new Date().toISOString();
+            session.messages.push(entry);
+        }
+        session.updatedAt = new Date().toISOString();
+    }
+    async processMessage(msg, sessionKeyOverride, onProgress) {
+        if (msg.channel === "system") {
+            const [channel, chatId] = String(msg.chatId).includes(":") ? String(msg.chatId).split(/:(.*)/s, 2) : ["cli", String(msg.chatId)];
+            const key = `${channel}:${chatId}`;
+            const session = this.sessions.getOrCreate(key);
+            this.setToolContext(channel, chatId, msg.metadata?.message_id);
+            const history = session.getHistory(this.input.memoryWindow ?? 100);
+            const messages = this.context.buildMessages({ history, currentMessage: msg.content, channel, chatId });
+            const { finalContent, messages: allMsgs } = await this.runAgentLoop(messages);
+            this.saveTurn(session, allMsgs, 1 + history.length);
+            this.sessions.save(session);
+            return { channel, chatId, content: finalContent ?? "Background task completed." };
+        }
+        const key = sessionKeyOverride ?? getSessionKey(msg);
+        const session = this.sessions.getOrCreate(key);
+        const cmd = msg.content.trim().toLowerCase();
+        if (cmd === "/new") {
+            if (session.messages.length) {
+                const ok = await this.consolidateMemory(session, true);
+                if (!ok)
+                    return { channel: msg.channel, chatId: msg.chatId, content: "Memory archival failed, session not cleared. Please try again." };
+            }
+            session.clear();
+            this.sessions.save(session);
+            this.sessions.invalidate(session.key);
+            return { channel: msg.channel, chatId: msg.chatId, content: "New session started." };
+        }
+        if (cmd === "/help") {
+            return { channel: msg.channel, chatId: msg.chatId, content: "pretticlaw commands:\n/new - Start a new conversation\n/stop - Stop the current task\n/help - Show available commands" };
+        }
+        const unconsolidated = session.messages.length - session.lastConsolidated;
+        if (unconsolidated >= (this.input.memoryWindow ?? 100) && !this.consolidating.has(session.key)) {
+            this.consolidating.add(session.key);
+            void this.consolidateMemory(session).finally(() => this.consolidating.delete(session.key));
+        }
+        this.setToolContext(msg.channel, msg.chatId, msg.metadata?.message_id);
+        const messageTool = this.tools.get("message");
+        if (messageTool instanceof MessageTool)
+            messageTool.startTurn();
+        const history = session.getHistory(this.input.memoryWindow ?? 100);
+        const initialMessages = this.context.buildMessages({ history, currentMessage: msg.content, media: msg.media, channel: msg.channel, chatId: msg.chatId });
+        const busProgress = async (content, meta) => {
+            const metadata = { ...(msg.metadata ?? {}), _progress: true, _tool_hint: !!meta?.toolHint };
+            await this.input.bus.publishOutbound({ channel: msg.channel, chatId: msg.chatId, content, metadata });
+        };
+        const { finalContent, messages: allMsgs } = await this.runAgentLoop(initialMessages, onProgress ?? busProgress);
+        const out = finalContent ?? "I've completed processing but have no response to give.";
+        this.saveTurn(session, allMsgs, 1 + history.length);
+        this.sessions.save(session);
+        if (messageTool instanceof MessageTool && messageTool.sentInTurn)
+            return null;
+        return { channel: msg.channel, chatId: msg.chatId, content: out, metadata: msg.metadata ?? {} };
+    }
+}

package/dist/agent/memory.d.ts

@@ -0,0 +1,16 @@
+import type { LLMProvider } from "../providers/base.js";
+import type { Session } from "../session/manager.js";
+export declare class MemoryStore {
+    readonly memoryDir: string;
+    readonly memoryFile: string;
+    readonly historyFile: string;
+    constructor(workspace: string);
+    readLongTerm(): string;
+    writeLongTerm(content: string): void;
+    appendHistory(entry: string): void;
+    getMemoryContext(): string;
+    consolidate(session: Session, provider: LLMProvider, model: string, opts?: {
+        archiveAll?: boolean;
+        memoryWindow?: number;
+    }): Promise<boolean>;
+}

package/dist/agent/memory.js

@@ -0,0 +1,98 @@
+import fs from "node:fs";
+import path from "node:path";
+const SAVE_MEMORY_TOOL = [{
+        type: "function",
+        function: {
+            name: "save_memory",
+            description: "Save the memory consolidation result to persistent storage.",
+            parameters: {
+                type: "object",
+                properties: {
+                    history_entry: { type: "string" },
+                    memory_update: { type: "string" },
+                },
+                required: ["history_entry", "memory_update"],
+            },
+        },
+    }];
+export class MemoryStore {
+    memoryDir;
+    memoryFile;
+    historyFile;
+    constructor(workspace) {
+        this.memoryDir = path.join(workspace, "memory");
+        fs.mkdirSync(this.memoryDir, { recursive: true });
+        this.memoryFile = path.join(this.memoryDir, "MEMORY.md");
+        this.historyFile = path.join(this.memoryDir, "HISTORY.md");
+    }
+    readLongTerm() {
+        return fs.existsSync(this.memoryFile) ? fs.readFileSync(this.memoryFile, "utf8") : "";
+    }
+    writeLongTerm(content) {
+        fs.writeFileSync(this.memoryFile, content, "utf8");
+    }
+    appendHistory(entry) {
+        fs.appendFileSync(this.historyFile, `${entry.trim()}\n\n`, "utf8");
+    }
+    getMemoryContext() {
+        const longTerm = this.readLongTerm();
+        return longTerm ? `## Long-term Memory\n${longTerm}` : "";
+    }
+    async consolidate(session, provider, model, opts) {
+        const archiveAll = opts?.archiveAll ?? false;
+        const memoryWindow = opts?.memoryWindow ?? 50;
+        let oldMessages = [];
+        let keepCount = 0;
+        if (archiveAll) {
+            oldMessages = session.messages;
+            keepCount = 0;
+        }
+        else {
+            keepCount = Math.floor(memoryWindow / 2);
+            if (session.messages.length <= keepCount)
+                return true;
+            if (session.messages.length - session.lastConsolidated <= 0)
+                return true;
+            oldMessages = session.messages.slice(session.lastConsolidated, session.messages.length - keepCount);
+            if (!oldMessages.length)
+                return true;
+        }
+        const lines = [];
+        for (const m of oldMessages) {
+            if (!m.content)
+                continue;
+            const tools = Array.isArray(m.tools_used) && m.tools_used.length ? ` [tools: ${m.tools_used.join(", ")}]` : "";
+            lines.push(`[${String(m.timestamp ?? "?").slice(0, 16)}] ${String(m.role).toUpperCase()}${tools}: ${String(m.content)}`);
+        }
+        const currentMemory = this.readLongTerm();
+        const prompt = `Process this conversation and call the save_memory tool with your consolidation.\n\n## Current Long-term Memory\n${currentMemory || "(empty)"}\n\n## Conversation to Process\n${lines.join("\n")}`;
+        try {
+            const response = await provider.chat({
+                model,
+                messages: [
+                    { role: "system", content: "You are a memory consolidation agent. Call the save_memory tool." },
+                    { role: "user", content: prompt },
+                ],
+                tools: SAVE_MEMORY_TOOL,
+            });
+            if (!response.toolCalls.length)
+                return false;
+            const call = response.toolCalls[0];
+            const args = call.arguments ?? {};
+            const entry = args.history_entry;
+            const update = args.memory_update;
+            if (entry != null)
+                this.appendHistory(typeof entry === "string" ? entry : JSON.stringify(entry));
+            if (update != null) {
+                const text = typeof update === "string" ? update : JSON.stringify(update);
+                if (text !== currentMemory)
+                    this.writeLongTerm(text);
+            }
+            session.lastConsolidated = archiveAll ? 0 : session.messages.length - keepCount;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/agent/skills.d.ts

@@ -0,0 +1,18 @@
+export declare class SkillsLoader {
+    private readonly workspaceSkills;
+    private readonly builtinSkills;
+    constructor(workspace: string, builtinSkillsDir?: string);
+    listSkills(filterUnavailable?: boolean): Array<{
+        name: string;
+        path: string;
+        source: string;
+    }>;
+    loadSkill(name: string): string | null;
+    loadSkillsForContext(skillNames: string[]): string;
+    buildSkillsSummary(): string;
+    getAlwaysSkills(): string[];
+    getSkillMetadata(name: string): Record<string, unknown> | null;
+    private stripFrontmatter;
+    private getSkillMeta;
+    private checkRequirements;
+}

package/dist/agent/skills.js

@@ -0,0 +1,121 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const BUILTIN_SKILLS_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../skills");
+export class SkillsLoader {
+    workspaceSkills;
+    builtinSkills;
+    constructor(workspace, builtinSkillsDir = BUILTIN_SKILLS_DIR) {
+        this.workspaceSkills = path.join(workspace, "skills");
+        this.builtinSkills = builtinSkillsDir;
+    }
+    listSkills(filterUnavailable = true) {
+        const skills = [];
+        const load = (root, source) => {
+            if (!fs.existsSync(root))
+                return;
+            for (const name of fs.readdirSync(root)) {
+                const skillFile = path.join(root, name, "SKILL.md");
+                if (!fs.existsSync(skillFile))
+                    continue;
+                if (skills.some((s) => s.name === name))
+                    continue;
+                skills.push({ name, path: skillFile, source });
+            }
+        };
+        load(this.workspaceSkills, "workspace");
+        load(this.builtinSkills, "builtin");
+        if (!filterUnavailable)
+            return skills;
+        return skills.filter((s) => this.checkRequirements(this.getSkillMeta(s.name)));
+    }
+    loadSkill(name) {
+        const workspace = path.join(this.workspaceSkills, name, "SKILL.md");
+        if (fs.existsSync(workspace))
+            return fs.readFileSync(workspace, "utf8");
+        const builtin = path.join(this.builtinSkills, name, "SKILL.md");
+        if (fs.existsSync(builtin))
+            return fs.readFileSync(builtin, "utf8");
+        return null;
+    }
+    loadSkillsForContext(skillNames) {
+        const parts = [];
+        for (const name of skillNames) {
+            const c = this.loadSkill(name);
+            if (c)
+                parts.push(`### Skill: ${name}\n\n${this.stripFrontmatter(c)}`);
+        }
+        return parts.join("\n\n---\n\n");
+    }
+    buildSkillsSummary() {
+        const all = this.listSkills(false);
+        if (!all.length)
+            return "";
+        const esc = (s) => s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+        const lines = ["<skills>"];
+        for (const s of all) {
+            const meta = this.getSkillMetadata(s.name) ?? {};
+            const prettiMeta = this.getSkillMeta(s.name);
+            const available = this.checkRequirements(prettiMeta);
+            lines.push(`  <skill available="${available}">`);
+            lines.push(`    <name>${esc(s.name)}</name>`);
+            lines.push(`    <description>${esc(meta.description || s.name)}</description>`);
+            lines.push(`    <location>${s.path}</location>`);
+            lines.push("  </skill>");
+        }
+        lines.push("</skills>");
+        return lines.join("\n");
+    }
+    getAlwaysSkills() {
+        const out = [];
+        for (const s of this.listSkills(true)) {
+            const meta = this.getSkillMetadata(s.name) ?? {};
+            const m = this.getSkillMeta(s.name);
+            if (m.always || meta.always)
+                out.push(s.name);
+        }
+        return out;
+    }
+    getSkillMetadata(name) {
+        const content = this.loadSkill(name);
+        if (!content?.startsWith("---"))
+            return null;
+        const m = content.match(/^---\n([\s\S]*?)\n---/);
+        if (!m)
+            return null;
+        const out = {};
+        for (const line of m[1].split(/\r?\n/)) {
+            const idx = line.indexOf(":");
+            if (idx <= 0)
+                continue;
+            out[line.slice(0, idx).trim()] = line.slice(idx + 1).trim().replace(/^['"]|['"]$/g, "");
+        }
+        return out;
+    }
+    stripFrontmatter(content) {
+        const m = content.match(/^---\n[\s\S]*?\n---\n?/);
+        return m ? content.slice(m[0].length).trim() : content;
+    }
+    getSkillMeta(name) {
+        const meta = this.getSkillMetadata(name) ?? {};
+        const raw = typeof meta.metadata === "string" ? meta.metadata : "{}";
+        try {
+            const data = JSON.parse(raw);
+            return data.pretticlaw || data.openclaw || {};
+        }
+        catch {
+            return {};
+        }
+    }
+    checkRequirements(skillMeta) {
+        const req = skillMeta.requires ?? {};
+        const bins = req.bins ?? [];
+        const env = req.env ?? [];
+        const hasBin = (name) => {
+            const pathEntries = (process.env.PATH ?? "").split(path.delimiter);
+            const exts = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
+            return pathEntries.some((p) => exts.some((e) => fs.existsSync(path.join(p, `${name}${e}`))));
+        };
+        return bins.every(hasBin) && env.every((k) => !!process.env[k]);
+    }
+}

package/dist/agent/subagent.d.ts

@@ -0,0 +1,30 @@
+import type { MessageBus } from "../bus/queue.js";
+import type { LLMProvider } from "../providers/base.js";
+export declare class SubagentManager {
+    private readonly provider;
+    private readonly workspace;
+    private readonly bus;
+    private readonly model;
+    private readonly temperature;
+    private readonly maxTokens;
+    private readonly braveApiKey;
+    private readonly execConfig;
+    private readonly restrictToWorkspace;
+    private running;
+    private sessionTasks;
+    constructor(provider: LLMProvider, workspace: string, bus: MessageBus, model: string, temperature: number, maxTokens: number, braveApiKey: string | null, execConfig: {
+        timeout: number;
+        pathAppend: string;
+    }, restrictToWorkspace: boolean);
+    spawn(input: {
+        task: string;
+        label: string | null;
+        originChannel: string;
+        originChatId: string;
+        sessionKey: string;
+    }): Promise<string>;
+    private runSubagent;
+    private buildSubagentPrompt;
+    cancelBySession(sessionKey: string): Promise<number>;
+    getRunningCount(): number;
+}

package/dist/agent/subagent.js

@@ -0,0 +1,92 @@
+import { randomUUID } from "node:crypto";
+import { ToolRegistry } from "./tools/registry.js";
+import { ReadFileTool, WriteFileTool, EditFileTool, ListDirTool } from "./tools/filesystem.js";
+import { ExecTool } from "./tools/shell.js";
+import { WebSearchTool, WebFetchTool } from "./tools/web.js";
+export class SubagentManager {
+    provider;
+    workspace;
+    bus;
+    model;
+    temperature;
+    maxTokens;
+    braveApiKey;
+    execConfig;
+    restrictToWorkspace;
+    running = new Map();
+    sessionTasks = new Map();
+    constructor(provider, workspace, bus, model, temperature, maxTokens, braveApiKey, execConfig, restrictToWorkspace) {
+        this.provider = provider;
+        this.workspace = workspace;
+        this.bus = bus;
+        this.model = model;
+        this.temperature = temperature;
+        this.maxTokens = maxTokens;
+        this.braveApiKey = braveApiKey;
+        this.execConfig = execConfig;
+        this.restrictToWorkspace = restrictToWorkspace;
+    }
+    async spawn(input) {
+        const taskId = randomUUID().slice(0, 8);
+        const label = input.label ?? (input.task.length > 30 ? `${input.task.slice(0, 30)}...` : input.task);
+        const p = this.runSubagent(taskId, input.task, label, { channel: input.originChannel, chatId: input.originChatId })
+            .finally(() => {
+            this.running.delete(taskId);
+            const ids = this.sessionTasks.get(input.sessionKey);
+            if (ids) {
+                ids.delete(taskId);
+                if (!ids.size)
+                    this.sessionTasks.delete(input.sessionKey);
+            }
+        });
+        this.running.set(taskId, p);
+        if (!this.sessionTasks.has(input.sessionKey))
+            this.sessionTasks.set(input.sessionKey, new Set());
+        this.sessionTasks.get(input.sessionKey).add(taskId);
+        return `Subagent [${label}] started (id: ${taskId}). I'll notify you when it completes.`;
+    }
+    async runSubagent(taskId, task, label, origin) {
+        const tools = new ToolRegistry();
+        const allowedDir = this.restrictToWorkspace ? this.workspace : undefined;
+        tools.register(new ReadFileTool(this.workspace, allowedDir));
+        tools.register(new WriteFileTool(this.workspace, allowedDir));
+        tools.register(new EditFileTool(this.workspace, allowedDir));
+        tools.register(new ListDirTool(this.workspace, allowedDir));
+        tools.register(new ExecTool(this.execConfig.timeout, this.workspace, this.restrictToWorkspace, this.execConfig.pathAppend));
+        tools.register(new WebSearchTool(this.braveApiKey));
+        tools.register(new WebFetchTool());
+        let messages = [
+            { role: "system", content: this.buildSubagentPrompt() },
+            { role: "user", content: task },
+        ];
+        let finalResult = "Task completed but no final response was generated.";
+        for (let i = 0; i < 15; i++) {
+            const response = await this.provider.chat({ messages, tools: tools.getDefinitions(), model: this.model, temperature: this.temperature, maxTokens: this.maxTokens });
+            if (response.toolCalls.length) {
+                messages.push({ role: "assistant", content: response.content ?? "", tool_calls: response.toolCalls.map((tc) => ({ id: tc.id, type: "function", function: { name: tc.name, arguments: JSON.stringify(tc.arguments) } })) });
+                for (const tc of response.toolCalls) {
+                    const result = await tools.execute(tc.name, tc.arguments);
+                    messages.push({ role: "tool", tool_call_id: tc.id, name: tc.name, content: result });
+                }
+            }
+            else {
+                finalResult = response.content ?? finalResult;
+                break;
+            }
+        }
+        const announceContent = `[Subagent '${label}' completed successfully]\n\nTask: ${task}\n\nResult:\n${finalResult}\n\nSummarize this naturally for the user. Keep it brief (1-2 sentences).`;
+        const msg = { channel: "system", senderId: "subagent", chatId: `${origin.channel}:${origin.chatId}`, content: announceContent };
+        await this.bus.publishInbound(msg);
+    }
+    buildSubagentPrompt() {
+        const now = new Date().toLocaleString();
+        return `# Subagent\n\nCurrent Time: ${now}\n\nYou are a subagent spawned by the main agent to complete a specific task. Stay focused and concise.`;
+    }
+    async cancelBySession(sessionKey) {
+        const ids = [...(this.sessionTasks.get(sessionKey) ?? [])];
+        return ids.filter((id) => this.running.has(id)).length;
+    }
+    getRunningCount() {
+        return this.running.size;
+    }
+}

package/dist/agent/tools/base.d.ts

@@ -0,0 +1,10 @@
+export declare abstract class Tool {
+    protected static typeMap: Record<string, (v: unknown) => boolean>;
+    abstract readonly name: string;
+    abstract readonly description: string;
+    abstract readonly parameters: Record<string, unknown>;
+    abstract execute(args: Record<string, unknown>): Promise<string>;
+    validateParams(params: Record<string, unknown>): string[];
+    private validateValue;
+    toSchema(): Record<string, unknown>;
+}