@aiaiaichain/agent 0.1.5 → 0.1.7

package/dist/runner/SwarmRouter.d.ts

@@ -20,4 +20,3 @@ export declare class SwarmRouter {
     runConcurrent(tasks: SubAgentTask[], _sessionCtx: SessionContext): Promise<SubAgentResult[]>;
     private runSingle;
 }
-//# sourceMappingURL=SwarmRouter.d.ts.map

package/dist/runner/SwarmRouter.js

@@ -1,24 +1,20 @@
-/**
- * SwarmRouter — parallel sub-agent orchestration.
- * Routes tasks to appropriate model tiers for parallel execution.
- */
+
 export class SwarmRouter {
-    registry;
-    constructor(registry) {
-        this.registry = registry;
-    }
-    async runConcurrent(tasks, _sessionCtx) {
-        return Promise.all(tasks.map(t => this.runSingle(t)));
-    }
-    async runSingle(task) {
-        try {
-            // For v1, just execute the task via the available tools
-            // This is simplified — real parallel model calls would go through ModelClient
-            return { taskId: task.id, output: `[${task.tier}] ${task.prompt}` };
-        }
-        catch (e) {
-            return { taskId: task.id, output: "", error: e instanceof Error ? e.message : String(e) };
-        }
-    }
+registry;
+constructor(registry) {
+this.registry = registry;
+}
+async runConcurrent(tasks, _sessionCtx) {
+return Promise.all(tasks.map(t => this.runSingle(t)));
+}
+async runSingle(task) {
+try {
+
+
+return { taskId: task.id, output: `[${task.tier}] ${task.prompt}` };
+}
+catch (e) {
+return { taskId: task.id, output: "", error: e instanceof Error ? e.message : String(e) };
+}
+}
 }
-//# sourceMappingURL=SwarmRouter.js.map

package/dist/runner/ToolDispatcher.d.ts

@@ -10,4 +10,3 @@ export declare class ToolDispatcher {
     listTools(): ToolDef[];
     getTool(name: string): ToolDef | undefined;
 }
-//# sourceMappingURL=ToolDispatcher.d.ts.map

package/dist/runner/ToolDispatcher.js

@@ -1,34 +1,31 @@
-/**
- * ToolDispatcher — dispatches tool calls from the AI to registered tool handlers.
- */
+
 export class ToolDispatcher {
-    registry;
-    constructor(registry) {
-        this.registry = registry;
-    }
-    async dispatch(toolName, params) {
-        const tool = this.registry.getTool(toolName);
-        if (!tool) {
-            return {
-                content: [{ type: "text", text: `Unknown tool: "${toolName}"` }],
-                isError: true,
-            };
-        }
-        try {
-            return await tool.execute(`invoke-${Date.now()}`, params);
-        }
-        catch (e) {
-            return {
-                content: [{ type: "text", text: `Tool "${toolName}" error: ${e instanceof Error ? e.message : String(e)}` }],
-                isError: true,
-            };
-        }
-    }
-    listTools() {
-        return this.registry.listTools();
-    }
-    getTool(name) {
-        return this.registry.getTool(name);
-    }
-}
-//# sourceMappingURL=ToolDispatcher.js.map
+registry;
+constructor(registry) {
+this.registry = registry;
+}
+async dispatch(toolName, params) {
+const tool = this.registry.getTool(toolName);
+if (!tool) {
+return {
+content: [{ type: "text", text: `Unknown tool: "${toolName}"` }],
+isError: true,
+};
+}
+try {
+return await tool.execute(`invoke-${Date.now()}`, params);
+}
+catch (e) {
+return {
+content: [{ type: "text", text: `Tool "${toolName}" error: ${e instanceof Error ? e.message : String(e)}` }],
+isError: true,
+};
+}
+}
+listTools() {
+return this.registry.listTools();
+}
+getTool(name) {
+return this.registry.getTool(name);
+}
+}

package/dist/scheduler/AgentScheduler.d.ts

@@ -45,4 +45,3 @@ export declare class AgentScheduler {
     removeTaskTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
 }
 export declare const agentScheduler: AgentScheduler;
-//# sourceMappingURL=AgentScheduler.d.ts.map

package/dist/scheduler/AgentScheduler.js

@@ -1,111 +1,107 @@
-/**
- * AgentScheduler — cron and price-triggered scheduled tasks.
- * Persisted to ~/.aiaiai/memory/schedule.json
- */
+
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { Type } from "@sinclair/typebox";
 import { AgentDir } from "../core/AgentDir.js";
 const SCHEDULE_PATH = resolve(AgentDir.getHome(), "memory", "schedule.json");
 export class AgentScheduler {
-    tasks = [];
-    interval = null;
-    onTask;
-    constructor() {
-        this.load();
-    }
-    load() {
-        try {
-            if (existsSync(SCHEDULE_PATH)) {
-                this.tasks = JSON.parse(readFileSync(SCHEDULE_PATH, "utf-8"));
-            }
-        }
-        catch {
-            this.tasks = [];
-        }
-    }
-    save() {
-        try {
-            writeFileSync(SCHEDULE_PATH, JSON.stringify(this.tasks, null, 2), "utf-8");
-        }
-        catch { /* non-fatal */ }
-    }
-    addTask(name, prompt, intervalSeconds) {
-        const task = {
-            id: `task-${Date.now()}-${Math.random().toString(36).slice(2, 5)}`,
-            name,
-            prompt,
-            cron: intervalSeconds ? String(intervalSeconds) : undefined,
-            enabled: true,
-            createdAt: Date.now(),
-        };
-        this.tasks.push(task);
-        this.save();
-        return task;
-    }
-    removeTask(id) {
-        const idx = this.tasks.findIndex(t => t.id === id);
-        if (idx === -1)
-            return false;
-        this.tasks.splice(idx, 1);
-        this.save();
-        return true;
-    }
-    listTasks() {
-        return [...this.tasks];
-    }
-    start(onTask) {
-        this.onTask = onTask;
-        if (this.interval)
-            clearInterval(this.interval);
-        this.interval = setInterval(() => {
-            const now = Date.now();
-            for (const task of this.tasks) {
-                if (!task.enabled || !task.cron)
-                    continue;
-                const interval = parseInt(task.cron) * 1000;
-                if (!task.lastRun || (now - task.lastRun) >= interval) {
-                    task.lastRun = now;
-                    this.save();
-                    this.onTask?.(task);
-                }
-            }
-        }, 10_000); // Check every 10 seconds
-    }
-    stop() {
-        if (this.interval) {
-            clearInterval(this.interval);
-            this.interval = null;
-        }
-    }
-    // ── Tools ───────────────────────────────────────────────────────────────
-    addTaskParams = Type.Object({
-        name: Type.String({ description: "Task name" }),
-        prompt: Type.String({ description: "Prompt to run when task fires" }),
-        interval: Type.Optional(Type.Number({ description: "Run every N seconds" })),
-    });
-    listTasksParams = Type.Object({
-        enabled_only: Type.Optional(Type.Boolean({ default: false })),
-    });
-    removeTaskParams = Type.Object({
-        id: Type.String({ description: "Task ID to remove" }),
-    });
-    async addTaskTool(_id, params) {
-        const task = this.addTask(params.name, params.prompt, params.interval);
-        return { content: [{ type: "text", text: `Task "${task.name}" created (${task.id})` }] };
-    }
-    async listTasksTool(_id, params) {
-        const enabledOnly = params.enabled_only || false;
-        const tasks = enabledOnly ? this.tasks.filter(t => t.enabled) : this.tasks;
-        if (tasks.length === 0)
-            return { content: [{ type: "text", text: "No scheduled tasks." }] };
-        const lines = tasks.map(t => `  ${t.enabled ? "🟢" : "⏸️"} ${t.id} — ${t.name}${t.cron ? ` (every ${t.cron}s)` : ""}`);
-        return { content: [{ type: "text", text: `Scheduled Tasks (${tasks.length}):\n${lines.join("\n")}` }] };
-    }
-    async removeTaskTool(_id, params) {
-        const ok = this.removeTask(params.id);
-        return { content: [{ type: "text", text: ok ? `Task ${params.id} removed` : `Task ${params.id} not found` }] };
-    }
+tasks = [];
+interval = null;
+onTask;
+constructor() {
+this.load();
+}
+load() {
+try {
+if (existsSync(SCHEDULE_PATH)) {
+this.tasks = JSON.parse(readFileSync(SCHEDULE_PATH, "utf-8"));
+}
+}
+catch {
+this.tasks = [];
+}
+}
+save() {
+try {
+writeFileSync(SCHEDULE_PATH, JSON.stringify(this.tasks, null, 2), "utf-8");
+}
+catch {  }
+}
+addTask(name, prompt, intervalSeconds) {
+const task = {
+id: `task-${Date.now()}-${Math.random().toString(36).slice(2, 5)}`,
+name,
+prompt,
+cron: intervalSeconds ? String(intervalSeconds) : undefined,
+enabled: true,
+createdAt: Date.now(),
+};
+this.tasks.push(task);
+this.save();
+return task;
+}
+removeTask(id) {
+const idx = this.tasks.findIndex(t => t.id === id);
+if (idx === -1)
+return false;
+this.tasks.splice(idx, 1);
+this.save();
+return true;
+}
+listTasks() {
+return [...this.tasks];
+}
+start(onTask) {
+this.onTask = onTask;
+if (this.interval)
+clearInterval(this.interval);
+this.interval = setInterval(() => {
+const now = Date.now();
+for (const task of this.tasks) {
+if (!task.enabled || !task.cron)
+continue;
+const interval = parseInt(task.cron) * 1000;
+if (!task.lastRun || (now - task.lastRun) >= interval) {
+task.lastRun = now;
+this.save();
+this.onTask?.(task);
+}
+}
+}, 10_000); 
+}
+stop() {
+if (this.interval) {
+clearInterval(this.interval);
+this.interval = null;
+}
+}
+
+addTaskParams = Type.Object({
+name: Type.String({ description: "Task name" }),
+prompt: Type.String({ description: "Prompt to run when task fires" }),
+interval: Type.Optional(Type.Number({ description: "Run every N seconds" })),
+});
+listTasksParams = Type.Object({
+enabled_only: Type.Optional(Type.Boolean({ default: false })),
+});
+removeTaskParams = Type.Object({
+id: Type.String({ description: "Task ID to remove" }),
+});
+async addTaskTool(_id, params) {
+const task = this.addTask(params.name, params.prompt, params.interval);
+return { content: [{ type: "text", text: `Task "${task.name}" created (${task.id})` }] };
+}
+async listTasksTool(_id, params) {
+const enabledOnly = params.enabled_only || false;
+const tasks = enabledOnly ? this.tasks.filter(t => t.enabled) : this.tasks;
+if (tasks.length === 0)
+return { content: [{ type: "text", text: "No scheduled tasks." }] };
+const lines = tasks.map(t => `  ${t.enabled ? "🟢" : "⏸️"} ${t.id} — ${t.name}${t.cron ? ` (every ${t.cron}s)` : ""}`);
+return { content: [{ type: "text", text: `Scheduled Tasks (${tasks.length}):\n${lines.join("\n")}` }] };
+}
+async removeTaskTool(_id, params) {
+const ok = this.removeTask(params.id);
+return { content: [{ type: "text", text: ok ? `Task ${params.id} removed` : `Task ${params.id} not found` }] };
+}
 }
 export const agentScheduler = new AgentScheduler();
-//# sourceMappingURL=AgentScheduler.js.map

package/dist/session/ContextStore.d.ts

@@ -12,6 +12,7 @@ export interface TaskContext {
 }
 export declare class ContextStore {
     private basePath;
+    private activeContexts;
     constructor();
     saveTask(taskId: string, data: Record<string, unknown>): void;
     readTask(taskId: string): TaskContext | null;
@@ -25,4 +26,3 @@ export declare class ContextStore {
     listTasksTool(): Promise<ToolResult>;
 }
 export declare const contextStore: ContextStore;
-//# sourceMappingURL=ContextStore.d.ts.map

package/dist/session/ContextStore.js

@@ -1,85 +1,83 @@
-/**
- * ContextStore — persistent task context folders.
- * Allows multi-step operations to store and retrieve intermediate state.
- */
+
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "node:fs";
 import { resolve } from "node:path";
 import { Type } from "@sinclair/typebox";
 import { AgentDir } from "../core/AgentDir.js";
 export class ContextStore {
-    basePath;
-    constructor() {
-        this.basePath = resolve(AgentDir.getHome(), "sessions", "tasks");
-        if (!existsSync(this.basePath))
-            mkdirSync(this.basePath, { recursive: true });
-    }
-    saveTask(taskId, data) {
-        const ctx = {
-            taskId,
-            data,
-            createdAt: Date.now(),
-            updatedAt: Date.now(),
-        };
-        writeFileSync(resolve(this.basePath, `${taskId}.json`), JSON.stringify(ctx, null, 2), "utf-8");
-    }
-    readTask(taskId) {
-        const p = resolve(this.basePath, `${taskId}.json`);
-        if (!existsSync(p))
-            return null;
-        try {
-            return JSON.parse(readFileSync(p, "utf-8"));
-        }
-        catch {
-            return null;
-        }
-    }
-    listTasks() {
-        if (!existsSync(this.basePath))
-            return [];
-        try {
-            return readdirSync(this.basePath)
-                .filter(f => f.endsWith(".json"))
-                .map(f => {
-                try {
-                    return JSON.parse(readFileSync(resolve(this.basePath, f), "utf-8"));
-                }
-                catch {
-                    return null;
-                }
-            })
-                .filter(Boolean);
-        }
-        catch {
-            return [];
-        }
-    }
-    keepTask(taskId) {
-        const ctx = this.readTask(taskId);
-        if (!ctx)
-            return false;
-        ctx.keep = true;
-        ctx.updatedAt = Date.now();
-        writeFileSync(resolve(this.basePath, `${taskId}.json`), JSON.stringify(ctx, null, 2), "utf-8");
-        return true;
-    }
-    // ── Tools ───────────────────────────────────────────────────────────────
-    readContextParams = Type.Object({
-        taskId: Type.String({ description: "Task ID from a previous multi-step operation" }),
-    });
-    listTasksParams = Type.Object({});
-    async readContextTool(_id, params) {
-        const ctx = this.readTask(params.taskId);
-        if (!ctx)
-            return { content: [{ type: "text", text: `Task "${params.taskId}" not found.` }] };
-        return { content: [{ type: "text", text: JSON.stringify(ctx.data, null, 2) }] };
-    }
-    async listTasksTool() {
-        const tasks = this.listTasks();
-        if (tasks.length === 0)
-            return { content: [{ type: "text", text: "No saved tasks." }] };
-        const lines = tasks.map(t => `  ${t.taskId} — ${Object.keys(t.data).length} keys (${new Date(t.updatedAt).toLocaleString()})${t.keep ? " 🔒" : ""}`);
-        return { content: [{ type: "text", text: `Tasks (${tasks.length}):\n${lines.join("\n")}` }] };
-    }
+basePath;
+
+activeContexts = new Map();
+constructor() {
+this.basePath = resolve(AgentDir.getHome(), "sessions", "tasks");
+if (!existsSync(this.basePath))
+mkdirSync(this.basePath, { recursive: true });
+}
+saveTask(taskId, data) {
+const ctx = {
+taskId,
+data,
+createdAt: Date.now(),
+updatedAt: Date.now(),
+};
+writeFileSync(resolve(this.basePath, `${taskId}.json`), JSON.stringify(ctx, null, 2), "utf-8");
+}
+readTask(taskId) {
+const p = resolve(this.basePath, `${taskId}.json`);
+if (!existsSync(p))
+return null;
+try {
+return JSON.parse(readFileSync(p, "utf-8"));
+}
+catch {
+return null;
+}
+}
+listTasks() {
+if (!existsSync(this.basePath))
+return [];
+try {
+return readdirSync(this.basePath)
+.filter(f => f.endsWith(".json"))
+.map(f => {
+try {
+return JSON.parse(readFileSync(resolve(this.basePath, f), "utf-8"));
+}
+catch {
+return null;
+}
+})
+.filter(Boolean);
+}
+catch {
+return [];
+}
+}
+keepTask(taskId) {
+const ctx = this.readTask(taskId);
+if (!ctx)
+return false;
+ctx.keep = true;
+ctx.updatedAt = Date.now();
+writeFileSync(resolve(this.basePath, `${taskId}.json`), JSON.stringify(ctx, null, 2), "utf-8");
+return true;
+}
+
+readContextParams = Type.Object({
+taskId: Type.String({ description: "Task ID from a previous multi-step operation" }),
+});
+listTasksParams = Type.Object({});
+async readContextTool(_id, params) {
+const ctx = this.readTask(params.taskId);
+if (!ctx)
+return { content: [{ type: "text", text: `Task "${params.taskId}" not found.` }] };
+return { content: [{ type: "text", text: JSON.stringify(ctx.data, null, 2) }] };
+}
+async listTasksTool() {
+const tasks = this.listTasks();
+if (tasks.length === 0)
+return { content: [{ type: "text", text: "No saved tasks." }] };
+const lines = tasks.map(t => `  ${t.taskId} — ${Object.keys(t.data).length} keys (${new Date(t.updatedAt).toLocaleString()})${t.keep ? " 🔒" : ""}`);
+return { content: [{ type: "text", text: `Tasks (${tasks.length}):\n${lines.join("\n")}` }] };
+}
 }
 export const contextStore = new ContextStore();
-//# sourceMappingURL=ContextStore.js.map

package/dist/session/GoalManager.d.ts

@@ -40,4 +40,3 @@ export declare class GoalManager {
     addGoalNoteTool(_id: string, params: Record<string, unknown>): Promise<ToolResult>;
 }
 export declare const goalManager: GoalManager;
-//# sourceMappingURL=GoalManager.d.ts.map