arisa 3.0.12 → 3.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "3.0.12",
+  "version": "3.0.14",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",
@@ -30,8 +30,8 @@
     "pi.dev",
     "clasen"
   ],
-  "author": "",
-  "license": "GLP",
+  "author": "Martin Clasen",
+  "license": "MIT",
   "packageManager": "pnpm@10.32.1",
   "dependencies": {
     "@mariozechner/pi-coding-agent": "^0.65.0",

package/src/core/agent/agent-manager.js

@@ -8,10 +8,11 @@ import { arisaInstallDir, buildAgentRuntimeContext } from "./runtime-context.js"
 import { arisaHomeDir } from "../../runtime/paths.js";
 
 export class AgentManager {
-  constructor({ config, artifactStore, toolRegistry, logger }) {
+  constructor({ config, artifactStore, toolRegistry, taskStore, logger }) {
     this.config = config;
     this.artifactStore = artifactStore;
     this.toolRegistry = toolRegistry;
+    this.taskStore = taskStore;
     this.logger = logger;
     this.sessions = new Map();
   }
@@ -65,7 +66,7 @@ export class AgentManager {
     }
 
     this.logger?.log("agent", `creating session for chat ${chatId}`);
-    const customTools = this.createTools(telegram);
+    const customTools = this.createTools(telegram, chatId);
     const { session } = await createAgentSession({
       cwd: arisaInstallDir,
       agentDir: arisaHomeDir,
@@ -87,7 +88,7 @@ export class AgentManager {
     return ctx;
   }
 
-  createTools(telegram) {
+  createTools(telegram, chatId) {
     return [
       defineTool({
         name: "list_tools",
@@ -175,12 +176,72 @@ export class AgentManager {
             await unlink(result.output.filePath).catch(() => {});
           }
 
+          if (result.asyncTask || result.asyncTasks?.length) {
+            const scheduled = await this.taskStore.addMany(
+              result.asyncTasks || [result.asyncTask],
+              {
+                payload: { chatId },
+                source: { type: "tool", toolName: params.name, chatId }
+              }
+            );
+            result.asyncTasks = scheduled;
+            delete result.asyncTask;
+          }
+
           return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
             details: result
           };
         }
       }),
+      defineTool({
+        name: "list_scheduled_tasks",
+        label: "List scheduled tasks",
+        description: "List scheduled async tasks for the current Telegram chat.",
+        parameters: Type.Object({
+          status: Type.Optional(Type.String())
+        }),
+        execute: async (_id, params) => {
+          const tasks = await this.taskStore.list({ chatId, status: params.status });
+          return {
+            content: [{ type: "text", text: JSON.stringify(tasks, null, 2) }],
+            details: { tasks }
+          };
+        }
+      }),
+      defineTool({
+        name: "cancel_scheduled_task",
+        label: "Cancel scheduled task",
+        description: "Cancel one scheduled async task by id for the current Telegram chat.",
+        parameters: Type.Object({ id: Type.String() }),
+        execute: async (_id, params) => {
+          const existing = await this.taskStore.get(params.id);
+          if (!existing || existing.payload?.chatId !== chatId) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ ok: false, error: "Task not found" }) }],
+              details: { ok: false, error: "Task not found" }
+            };
+          }
+          const task = await this.taskStore.cancel(params.id);
+          return {
+            content: [{ type: "text", text: JSON.stringify({ ok: true, task }, null, 2) }],
+            details: { ok: true, task }
+          };
+        }
+      }),
+      defineTool({
+        name: "cancel_all_scheduled_tasks",
+        label: "Cancel all scheduled tasks",
+        description: "Cancel all pending or running async tasks for the current Telegram chat.",
+        parameters: Type.Object({}),
+        execute: async () => {
+          const tasks = await this.taskStore.cancelAll({ chatId });
+          return {
+            content: [{ type: "text", text: JSON.stringify({ ok: true, cancelled: tasks.length }, null, 2) }],
+            details: { ok: true, tasks }
+          };
+        }
+      }),
       defineTool({
         name: "send_media_reply",
         label: "Send media reply",

package/src/core/tasks/task-store.js

@@ -0,0 +1,165 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+import { tasksFile } from "../../runtime/paths.js";
+
+async function loadTasksFile() {
+  try {
+    return JSON.parse(await readFile(tasksFile, "utf8"));
+  } catch {
+    return [];
+  }
+}
+
+async function saveTasksFile(tasks) {
+  await mkdir(path.dirname(tasksFile), { recursive: true });
+  await writeFile(tasksFile, `${JSON.stringify(tasks, null, 2)}\n`, "utf8");
+}
+
+function taskId() {
+  return crypto.randomUUID();
+}
+
+function normalizeTask(task, defaults = {}) {
+  return {
+    id: task.id || taskId(),
+    status: task.status || "pending",
+    createdAt: task.createdAt || new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    kind: task.kind,
+    runAt: task.runAt,
+    payload: {
+      ...(defaults.payload || {}),
+      ...(task.payload || {})
+    },
+    recurrence: task.recurrence || defaults.recurrence || null,
+    source: {
+      ...(defaults.source || {}),
+      ...(task.source || {})
+    }
+  };
+}
+
+function computeNextRunAt(task) {
+  if (task.recurrence?.type === "interval" && Number(task.recurrence.everySeconds) > 0) {
+    return new Date(Date.now() + (Number(task.recurrence.everySeconds) * 1000)).toISOString();
+  }
+  return "";
+}
+
+export class TaskStore {
+  constructor() {
+    this.tasks = null;
+  }
+
+  async init() {
+    if (!this.tasks) this.tasks = await loadTasksFile();
+  }
+
+  async save() {
+    await saveTasksFile(this.tasks || []);
+  }
+
+  async add(task, defaults = {}) {
+    await this.init();
+    const normalized = normalizeTask(task, defaults);
+    this.tasks.push(normalized);
+    await this.save();
+    return normalized;
+  }
+
+  async addMany(tasks = [], defaults = {}) {
+    const created = [];
+    for (const task of tasks) {
+      created.push(await this.add(task, defaults));
+    }
+    return created;
+  }
+
+  async claimDue(limit = 10) {
+    await this.init();
+    const now = Date.now();
+    const due = [];
+
+    for (const task of this.tasks) {
+      if (due.length >= limit) break;
+      if (task.status !== "pending") continue;
+      if (!task.runAt || Number.isNaN(Date.parse(task.runAt))) continue;
+      if (Date.parse(task.runAt) > now) continue;
+      task.status = "running";
+      task.updatedAt = new Date().toISOString();
+      due.push({ ...task });
+    }
+
+    if (due.length) await this.save();
+    return due;
+  }
+
+  async complete(taskId) {
+    await this.init();
+    const task = this.tasks.find((item) => item.id === taskId);
+    if (!task) return null;
+
+    const nextRunAt = computeNextRunAt(task);
+    if (nextRunAt) {
+      task.status = "pending";
+      task.runAt = nextRunAt;
+      task.lastRunAt = new Date().toISOString();
+    } else {
+      task.status = "done";
+      task.completedAt = new Date().toISOString();
+    }
+    task.updatedAt = new Date().toISOString();
+    await this.save();
+    return task;
+  }
+
+  async fail(taskId, error) {
+    await this.init();
+    const task = this.tasks.find((item) => item.id === taskId);
+    if (!task) return null;
+    task.status = "failed";
+    task.error = error;
+    task.updatedAt = new Date().toISOString();
+    await this.save();
+    return task;
+  }
+
+  async list(filter = {}) {
+    await this.init();
+    return this.tasks.filter((task) => {
+      if (filter.chatId && task.payload?.chatId !== filter.chatId) return false;
+      if (filter.status && task.status !== filter.status) return false;
+      if (filter.kind && task.kind !== filter.kind) return false;
+      return true;
+    });
+  }
+
+  async get(taskId) {
+    await this.init();
+    return this.tasks.find((item) => item.id === taskId) || null;
+  }
+
+  async cancel(taskId) {
+    await this.init();
+    const index = this.tasks.findIndex((item) => item.id === taskId);
+    if (index === -1) return null;
+    const [task] = this.tasks.splice(index, 1);
+    await this.save();
+    return task;
+  }
+
+  async cancelAll(filter = {}) {
+    await this.init();
+    const removed = [];
+    this.tasks = this.tasks.filter((task) => {
+      if (filter.chatId && task.payload?.chatId !== filter.chatId) return true;
+      if (filter.status && task.status !== filter.status) return true;
+      if (task.status === "done" || task.status === "failed") return true;
+      removed.push({ ...task });
+      return false;
+    });
+    if (removed.length) await this.save();
+    return removed;
+  }
+}

package/src/core/tools/tool-registry.js

@@ -119,7 +119,11 @@ export class ToolRegistry {
     try {
       const parsed = JSON.parse(result.stdout || result.stderr);
       const normalized = normalizeToolResult(name, parsed);
-      this.logger?.log("tools", `${name} -> ${normalized.ok === false ? normalized.status || "error" : "ok"}`);
+      if (normalized.ok === false) {
+        this.logger?.log("tools", `${name} -> ${normalized.status || "error"}: ${normalized.error || "unknown error"}`);
+      } else {
+        this.logger?.log("tools", `${name} -> ok`);
+      }
       return normalized;
     } catch {
       return normalizeToolResult(name, {

package/src/runtime/create-app.js

@@ -1,6 +1,7 @@
 import { loadConfig, saveConfig, updateConfig } from "../core/config/config-store.js";
 import { ArtifactStore } from "../core/artifacts/artifact-store.js";
 import { ToolRegistry } from "../core/tools/tool-registry.js";
+import { TaskStore } from "../core/tasks/task-store.js";
 import { AgentManager } from "../core/agent/agent-manager.js";
 import { createTelegramBot } from "../transport/telegram/bot.js";
 
@@ -9,11 +10,12 @@ export async function createApp({ logger } = {}) {
   const config = await loadConfig();
   const artifactStore = new ArtifactStore();
   const toolRegistry = new ToolRegistry({ logger });
+  const taskStore = new TaskStore();
   await toolRegistry.load();
   logger?.log("app", `loaded ${toolRegistry.list().length} tools`);
 
-  const agentManager = new AgentManager({ config, artifactStore, toolRegistry, logger });
-  const bot = await createTelegramBot({ config, artifactStore, toolRegistry, agentManager, saveConfig, updateConfig, logger });
+  const agentManager = new AgentManager({ config, artifactStore, toolRegistry, taskStore, logger });
+  const bot = await createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, logger });
 
   return {
     async start() {

package/src/runtime/paths.js

@@ -9,6 +9,7 @@ export const servicePidFile = path.join(stateDir, "arisa.pid");
 export const serviceLogFile = path.join(stateDir, "arisa.log");
 export const artifactsDir = path.join(arisaHomeDir, "artifacts");
 export const artifactsIndexFile = path.join(stateDir, "artifacts.json");
+export const tasksFile = path.join(stateDir, "tasks.json");
 export const toolsDir = path.join(arisaHomeDir, "tools");
 
 export function getToolDir(toolName) {

package/src/transport/telegram/bot.js

@@ -32,14 +32,20 @@ function quotedMessageSummary(message) {
   return parts;
 }
 
+function getTelegramCommand(ctx) {
+  const text = ctx.message?.text || "";
+  const entity = ctx.message?.entities?.[0];
+  if (entity?.type !== "bot_command" || entity.offset !== 0 || !text.startsWith("/")) return "";
+  return text.slice(1, entity.length).split("@")[0].trim().toLowerCase();
+}
+
 function buildPrompt({ ctx, artifact, transcript, toolResult }) {
   const parts = [
-    `New Telegram message.`,
+    `New Session..`,
     `chatId: ${ctx.chat.id}`,
     `userId: ${ctx.from.id}`,
     `username: ${ctx.from.username || "(no username)"}`,
-    `messageId: ${ctx.msg.message_id}`,
-    `preferredTelegramLanguageCode: ${ctx.from?.language_code || "unknown"}`
+    `messageId: ${ctx.msg.message_id}`
   ];
 
   if (ctx.message?.text) parts.push(`text: ${ctx.message.text}`);
@@ -64,6 +70,26 @@ function buildPrompt({ ctx, artifact, transcript, toolResult }) {
   return parts.join("\n");
 }
 
+function buildNewSessionPrompt(ctx) {
+  return [
+    "System event: /new requested.",
+    "Session was reset.",
+    `preferredTelegramLanguageCode: ${ctx.from?.language_code || "unknown"}`,
+    "Reply with a brief, warm confirmation in the user's language."
+  ].join("\n");
+}
+
+function buildAsyncTaskPrompt(task) {
+  return [
+    "Scheduled task fired.",
+    `taskId: ${task.id}`,
+    `chatId: ${task.payload.chatId}`,
+    task.payload.prompt ? `text: ${task.payload.prompt}` : null,
+    "Treat this as a new request for the chat and fulfill it now.",
+    "If needed, use tools."
+  ].filter(Boolean).join("\n");
+}
+
 async function maybeTranscribeIncomingAudio({ artifact, toolRegistry, artifactStore }) {
   if (!artifact || artifact.kind !== "audio") return { transcript: null };
 
@@ -117,7 +143,7 @@ async function withTyping(ctx, work) {
   }
 }
 
-export async function createTelegramBot({ config, artifactStore, toolRegistry, agentManager, saveConfig, updateConfig, logger }) {
+export async function createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, logger }) {
   const bot = new Bot(config.telegram.apiKey);
   const perChatState = new Map();
 
@@ -172,51 +198,58 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, a
     await sendText(renderTelegramHtml(text), { parse_mode: "HTML" });
   }
 
-  async function processPrompt(ctx, prompt) {
-    const telegram = {
+  function createTelegramSessionBridge(chatId) {
+    return {
       sendMedia: async (filePath, { method = "audio", caption } = {}) => {
-        logger?.log("telegram", `sending ${method} reply for chat ${ctx.chat.id}`);
+        logger?.log("telegram", `sending ${method} reply for chat ${chatId}`);
         const input = new InputFile(filePath);
-        if (method === "voice") return ctx.replyWithVoice(input, { caption });
-        if (method === "document") return ctx.replyWithDocument(input, { caption });
-        return ctx.replyWithAudio(input, { caption });
+        if (method === "voice") return bot.api.sendVoice(chatId, input, { caption });
+        if (method === "document") return bot.api.sendDocument(chatId, input, { caption });
+        return bot.api.sendAudio(chatId, input, { caption });
       }
     };
-    return withTyping(ctx, async () => {
-      const { session } = await agentManager.getSessionContext(ctx.chat.id, telegram);
+  }
+
+  async function processPromptForChat({ chatId, prompt, ctx = null }) {
+    const work = async () => {
+      const { session } = await agentManager.getSessionContext(chatId, createTelegramSessionBridge(chatId));
       const text = await collectText(session, prompt);
       if (text) {
         await sendTextReply({
-          sendText: (message, extra) => ctx.reply(message, extra),
-          sendDocument: (file, extra) => ctx.replyWithDocument(file, extra),
-          chatId: ctx.chat.id,
+          sendText: (message, extra) => bot.api.sendMessage(chatId, message, extra),
+          sendDocument: (file, extra) => bot.api.sendDocument(chatId, file, extra),
+          chatId,
           text
         });
       }
-    });
+    };
+
+    if (ctx) return withTyping(ctx, work);
+    return work();
   }
 
-  async function enqueueOrProcess(ctx) {
-    const chatState = getChatState(ctx.chat.id);
-    const incomingPrompt = await buildIncomingPrompt(ctx);
+  async function enqueuePrompt({ chatId, prompt, label, ctx = null }) {
+    const chatState = getChatState(chatId);
 
     if (chatState.processing) {
-      logger?.log("telegram", `chat ${ctx.chat.id} busy, queueing message ${ctx.msg.message_id}`);
+      logger?.log("telegram", `chat ${chatId} busy, queueing ${label}`);
       chatState.nextPrompt = chatState.nextPrompt
-        ? `${chatState.nextPrompt}\n\n${incomingPrompt}`
-        : incomingPrompt;
-      return ctx.reply("Queued. I will process this right after the current task finishes.");
+        ? `${chatState.nextPrompt}\n\n${prompt}`
+        : prompt;
+      return;
     }
 
     chatState.processing = true;
-    logger?.log("telegram", `processing message ${ctx.msg.message_id} in chat ${ctx.chat.id}`);
-    let currentPrompt = incomingPrompt;
+    logger?.log("telegram", `processing ${label} in chat ${chatId}`);
+    let currentPrompt = prompt;
+    let currentCtx = ctx;
 
     while (currentPrompt) {
       try {
-        logger?.log("telegram", `prompt dispatch for chat ${ctx.chat.id}`);
-        await processPrompt(ctx, currentPrompt);
+        logger?.log("telegram", `prompt dispatch for chat ${chatId}`);
+        await processPromptForChat({ chatId, prompt: currentPrompt, ctx: currentCtx });
       } finally {
+        currentCtx = null;
         if (chatState.nextPrompt) {
           currentPrompt = chatState.nextPrompt;
           chatState.nextPrompt = "";
@@ -229,6 +262,38 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, a
     chatState.processing = false;
   }
 
+  async function enqueueOrProcess(ctx) {
+    const chatState = getChatState(ctx.chat.id);
+
+    if (chatState.processing) {
+      const incomingPrompt = await buildIncomingPrompt(ctx);
+      return enqueuePrompt({
+        chatId: ctx.chat.id,
+        prompt: incomingPrompt,
+        label: `message ${ctx.msg.message_id}`
+      });
+    }
+
+    const incomingPrompt = await buildIncomingPrompt(ctx);
+    return enqueuePrompt({
+      chatId: ctx.chat.id,
+      prompt: incomingPrompt,
+      label: `message ${ctx.msg.message_id}`,
+      ctx
+    });
+  }
+
+  async function handleNewCommand(ctx) {
+    agentManager.resetSession(ctx.chat.id);
+    perChatState.set(ctx.chat.id, { processing: false, nextPrompt: "" });
+    await enqueuePrompt({
+      chatId: ctx.chat.id,
+      prompt: buildNewSessionPrompt(ctx),
+      label: "new-session command",
+      ctx
+    });
+  }
+
   bot.catch((error) => {
     logger?.error("telegram", `bot error: ${error instanceof Error ? error.message : String(error)}`);
     console.error("Telegram bot error:", error);
@@ -243,15 +308,16 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, a
   bot.command("new", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
-    agentManager.resetSession(ctx.chat.id);
-    perChatState.set(ctx.chat.id, { processing: false, nextPrompt: "" });
-    return ctx.reply("Started a new chat context.");
+    await handleNewCommand(ctx);
   });
 
   bot.on("message", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
 
+    const command = getTelegramCommand(ctx);
+    if (command) return;
+
     try {
       await enqueueOrProcess(ctx);
     } catch (error) {
@@ -269,16 +335,6 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, a
         try {
           logger?.log("telegram", `generating startup message for chat ${chatId}`);
           const chatMeta = config.telegram.chatMeta[chatId] || {};
-          const telegram = {
-            sendMedia: async (filePath, { method = "audio", caption } = {}) => {
-              logger?.log("telegram", `sending ${method} reply for chat ${chatId}`);
-              const input = new InputFile(filePath);
-              if (method === "voice") return bot.api.sendVoice(chatId, input, { caption });
-              if (method === "document") return bot.api.sendDocument(chatId, input, { caption });
-              return bot.api.sendAudio(chatId, input, { caption });
-            }
-          };
-          const { session } = await agentManager.getSessionContext(chatId, telegram);
           const welcomePrompt = [
             "System event: Arisa has just started.",
             `chatId: ${chatId}`,
@@ -290,15 +346,7 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, a
             "Use the user's Telegram language when possible.",
             "Do not mention internal implementation details."
           ].filter(Boolean).join("\n");
-          const text = await collectText(session, welcomePrompt);
-          if (text) {
-            await sendTextReply({
-              sendText: (message, extra) => bot.api.sendMessage(chatId, message, extra),
-              sendDocument: (file, extra) => bot.api.sendDocument(chatId, file, extra),
-              chatId,
-              text
-            });
-          }
+          await enqueuePrompt({ chatId, prompt: welcomePrompt, label: "startup message" });
         } catch (error) {
           logger?.log("telegram", `startup message failed for chat ${chatId}: ${error instanceof Error ? error.message : String(error)}`);
         }
@@ -306,8 +354,28 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, a
       await bot.api.setMyCommands([
         { command: "new", description: "Start a new chat context" }
       ]);
+      setInterval(async () => {
+        const tasks = await taskStore.claimDue(10);
+        for (const task of tasks) {
+          try {
+            if (task.kind !== "agent_task" || !task.payload?.chatId || !task.payload?.prompt) {
+              await taskStore.fail(task.id, `Unsupported task: ${task.kind}`);
+              continue;
+            }
+            logger?.log("tasks", `running task ${task.id} for chat ${task.payload.chatId}`);
+            await enqueuePrompt({
+              chatId: task.payload.chatId,
+              prompt: buildAsyncTaskPrompt(task),
+              label: `scheduled task ${task.id}`
+            });
+            await taskStore.complete(task.id);
+          } catch (error) {
+            await taskStore.fail(task.id, error instanceof Error ? error.message : String(error));
+          }
+        }
+      }, 1000).unref();
       logger?.log("telegram", "bot polling started");
-      await bot.start();
+      await bot.start({ drop_pending_updates: true });
     }
   };
 }

package/tools/schedule-agent-task/config.js

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

package/tools/schedule-agent-task/index.js

@@ -0,0 +1,68 @@
+import { readFile } from "node:fs/promises";
+import { toolError, toolOk } from "../../src/core/tools/tool-result.js";
+
+function printHelp() {
+  console.log(`schedule-agent-task\n\nUsage:\n  node index.js --help\n  node index.js run --request-file <json>\n\nExpected input:\n  {\n    "text": "tell me the temperature in Toronto",\n    "artifact": { "text": "tell me the temperature in Toronto" },\n    "args": {\n      "prompt": "tell me the temperature in Toronto",\n      "runAt": "2026-04-07T14:00:00.000Z",\n      "delaySeconds": "30",\n      "intervalSeconds": "3600"\n    }\n  }\n\nBehavior:\n  - schedules a future agent task for the current chat\n  - provide either args.runAt or args.delaySeconds\n  - optional args.intervalSeconds makes the task recurring\n`);
+}
+
+function firstNonEmpty(...values) {
+  return values.find((value) => String(value || "").trim()) || "";
+}
+
+function buildRunAt(args = {}) {
+  const runAtValue = firstNonEmpty(args.runAt, args.at, args.when);
+  if (runAtValue) {
+    const parsed = Date.parse(runAtValue);
+    if (Number.isNaN(parsed)) return "";
+    return new Date(parsed).toISOString();
+  }
+
+  const delaySeconds = Number(firstNonEmpty(args.delaySeconds, args.delay, args.seconds));
+  if (Number.isFinite(delaySeconds) && delaySeconds > 0) {
+    return new Date(Date.now() + (delaySeconds * 1000)).toISOString();
+  }
+
+  return "";
+}
+
+async function run(requestFile) {
+  const request = JSON.parse(await readFile(requestFile, "utf8"));
+  const args = request.args || {};
+  const prompt = firstNonEmpty(args.prompt, args.message, args.task, request.text, request.artifact?.text);
+  const runAt = buildRunAt(args);
+  const intervalSeconds = Number(firstNonEmpty(args.intervalSeconds, args.interval, args.everySeconds));
+
+  if (!prompt.trim()) {
+    console.log(JSON.stringify(toolError("prompt/message/task, text, or artifact.text is required")));
+    return;
+  }
+
+  if (!runAt) {
+    console.log(JSON.stringify(toolError("args.runAt/at/when or args.delaySeconds/delay/seconds is required")));
+    return;
+  }
+
+  const asyncTask = {
+    kind: "agent_task",
+    runAt,
+    payload: { prompt },
+    recurrence: Number.isFinite(intervalSeconds) && intervalSeconds > 0
+      ? { type: "interval", everySeconds: intervalSeconds }
+      : null
+  };
+
+  console.log(JSON.stringify(toolOk({ runAt }, {
+    status: "scheduled",
+    asyncTask
+  })));
+}
+
+const args = process.argv.slice(2);
+if (!args.length || args.includes("--help") || args[0] === "help") {
+  printHelp();
+} else if (args[0] === "run") {
+  const fileIndex = args.indexOf("--request-file");
+  await run(args[fileIndex + 1]);
+} else {
+  printHelp();
+}

package/tools/schedule-agent-task/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "schedule-agent-task-cli",
+  "private": true,
+  "type": "module",
+  "version": "1.0.0"
+}

package/tools/schedule-agent-task/tool.manifest.json

@@ -0,0 +1,8 @@
+{
+  "name": "schedule-agent-task",
+  "description": "Schedule a future Pi Agent task for the current chat.",
+  "entry": "index.js",
+  "input": ["text/plain"],
+  "output": ["application/json"],
+  "configSchema": {}
+}

package/tools/web-browser/index.js

@@ -47,7 +47,7 @@ async function fetchText(url) {
   const response = await fetch(url, {
     headers: {
       "user-agent": "Mozilla/5.0",
-      "accept-language": "es-AR,es;q=0.9,en;q=0.8"
+      "accept-language": "en-US,en;q=0.9"
     },
     redirect: "follow"
   });