arisa 3.0.12 → 3.1.2

package/src/transport/telegram/bot.js

@@ -1,8 +1,9 @@
-import { Bot, InputFile } from "grammy";
+import { Bot, InputFile, webhookCallback } from "grammy";
 import path from "node:path";
 import { authorizeChat } from "./auth.js";
 import { captureIncomingArtifact } from "./media.js";
 import { renderTelegramHtml } from "./text-format.js";
+import { normalizeArtifactForReasoning } from "../../core/artifacts/normalize-for-reasoning.js";
 
 function quotedMessageSummary(message) {
   if (!message) return [];
@@ -32,17 +33,28 @@ 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 getIncomingMessageText(message) {
+  return message?.text || message?.caption || "";
+}
+
 function buildPrompt({ ctx, artifact, transcript, toolResult }) {
   const parts = [
-    `New Telegram message.`,
+    `Incoming Telegram message.`,
     `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}`);
+  const messageText = getIncomingMessageText(ctx.message);
+  if (messageText) parts.push(`text: ${messageText}`);
   parts.push(...quotedMessageSummary(ctx.message?.reply_to_message));
   if (artifact?.path) parts.push(`artifactPath: ${artifact.path}`);
   if (artifact?.id) parts.push(`artifactId: ${artifact.id}`);
@@ -64,32 +76,70 @@ function buildPrompt({ ctx, artifact, transcript, toolResult }) {
   return parts.join("\n");
 }
 
-async function maybeTranscribeIncomingAudio({ artifact, toolRegistry, artifactStore }) {
-  if (!artifact || artifact.kind !== "audio") return { transcript: null };
+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");
+}
 
-  const result = await toolRegistry.run({
-    name: "openai-transcribe",
-    request: {
-      artifact,
-      args: {}
-    }
-  });
+async function buildAsyncTaskPrompt({ task, artifactStore, toolRegistry, logger }) {
+  const parts = [
+    "Scheduled task fired.",
+    `taskId: ${task.id}`,
+    `chatId: ${task.payload.chatId}`,
+    task.payload.prompt ? `text: ${task.payload.prompt}` : null
+  ];
 
-  if (!result.ok) {
-    return { transcript: null, toolResult: result };
-  }
+  if (task.payload.artifactId) {
+    const chatArtifactStore = artifactStore.forChat(task.payload.chatId);
+    const artifact = await chatArtifactStore.get(task.payload.artifactId);
+    if (artifact) {
+      parts.push(`artifactPath: ${artifact.path || ""}`);
+      parts.push(`artifactId: ${artifact.id}`);
+      parts.push(`mimeType: ${artifact.mimeType}`);
+      parts.push(`kind: ${artifact.kind}`);
+
+      const { normalizedArtifact, toolResult } = await normalizeArtifactForReasoning({
+        artifact,
+        desiredMimeType: "text/plain",
+        toolRegistry,
+        chatArtifactStore,
+        chatId: task.payload.chatId
+      });
 
-  if (!result.output?.text) {
-    return { transcript: null, toolResult: { ok: false, status: "failed", error: "Transcription returned no text." } };
+      if (normalizedArtifact) {
+        logger?.log("tasks", `artifact ${artifact.id} normalized to ${normalizedArtifact.id}`);
+        parts.push(`transcriptArtifactId: ${normalizedArtifact.id}`);
+        parts.push(`transcriptText: ${normalizedArtifact.text}`);
+        parts.push("Important: the attached audio artifact has already been normalized for reasoning. Use the transcript as the message content.");
+      } else if (artifact.kind === "audio" && toolResult) {
+        parts.push(`audioNormalizationResult: ${JSON.stringify(toolResult)}`);
+        parts.push("Important: pre-reasoning audio normalization could not be completed, so you do not have a transcript for this audio artifact.");
+      }
+    } else {
+      parts.push(`artifactId: ${task.payload.artifactId}`);
+      parts.push("Important: referenced artifact was not found.");
+    }
   }
 
-  const transcript = await artifactStore.createText({
-    text: result.output.text,
-    source: { type: "tool", toolName: "openai-transcribe" },
-    metadata: { fromArtifactId: artifact.id, tool: "openai-transcribe" }
-  });
+  parts.push("Treat this as a new request for the chat and fulfill it now.");
+  parts.push("If needed, use tools.");
+  return parts.filter(Boolean).join("\n");
+}
 
-  return { transcript, toolResult: result };
+async function normalizeIncomingArtifact({ artifact, toolRegistry, chatArtifactStore, chatId }) {
+  if (!artifact) return { transcript: null, toolResult: null };
+  const { normalizedArtifact, toolResult } = await normalizeArtifactForReasoning({
+    artifact,
+    desiredMimeType: "text/plain",
+    toolRegistry,
+    chatArtifactStore,
+    chatId
+  });
+  return { transcript: normalizedArtifact, toolResult };
 }
 
 async function collectText(session, prompt) {
@@ -117,8 +167,8 @@ async function withTyping(ctx, work) {
   }
 }
 
-export async function createTelegramBot({ config, artifactStore, toolRegistry, agentManager, saveConfig, updateConfig, logger }) {
-  const bot = new Bot(config.telegram.apiKey);
+export async function createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, logger, webhookUrl, setHttpRequestHandler }) {
+  const bot = new Bot(config.telegram.token);
   const perChatState = new Map();
 
   function getIncomingChatMeta(ctx) {
@@ -138,10 +188,12 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, a
   }
 
   async function buildIncomingPrompt(ctx) {
-    logger?.log("telegram", `message ${ctx.msg.message_id} in chat ${ctx.chat.id}`);
+    const chatId = ctx.chat.id;
+    logger?.log("telegram", `message ${ctx.msg.message_id} in chat ${chatId}`);
+    const chatArtifactStore = artifactStore.forChat(chatId);
     const artifact = await captureIncomingArtifact(ctx, artifactStore);
     if (artifact) logger?.log("telegram", `captured artifact ${artifact.kind}${artifact.id ? ` ${artifact.id}` : ""}`);
-    const { transcript, toolResult } = await maybeTranscribeIncomingAudio({ artifact, toolRegistry, artifactStore });
+    const { transcript, toolResult } = await normalizeIncomingArtifact({ artifact, toolRegistry, chatArtifactStore, chatId });
     if (transcript) logger?.log("telegram", `audio transcribed to artifact ${transcript.id}`);
     if (artifact?.kind === "audio" && !transcript) {
       logger?.log("telegram", `audio normalization unavailable for chat ${ctx.chat.id}: ${toolResult?.error || toolResult?.missingConfig?.join(", ") || "unknown error"}`);
@@ -154,7 +206,8 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, a
 
     if (text.length > maxInlineReplyLength) {
       logger?.log("telegram", `sending long reply as markdown attachment for chat ${chatId}`);
-      const artifact = await artifactStore.createGeneratedFile({
+      const chatArtifactStore = artifactStore.forChat(chatId);
+      const artifact = await chatArtifactStore.createGeneratedFile({
         fileName: `reply-${Date.now()}.md`,
         content: text,
         kind: "document",
@@ -172,51 +225,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 +289,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 +335,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 +362,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 +373,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 +381,46 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, a
       await bot.api.setMyCommands([
         { command: "new", description: "Start a new chat context" }
       ]);
-      logger?.log("telegram", "bot polling started");
-      await bot.start();
+      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: await buildAsyncTaskPrompt({ task, artifactStore, toolRegistry, logger }),
+              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();
+      if (webhookUrl && setHttpRequestHandler) {
+        const webhookPath = `/telegram-${config.telegram.token.slice(-8)}`;
+        const handleUpdate = webhookCallback(bot, "http", {
+          timeoutMilliseconds: 60_000,
+          onTimeout: "return",
+        });
+        setHttpRequestHandler((req, res) => {
+          const parsed = new URL(req.url, "http://localhost");
+          if (req.method === "POST" && parsed.pathname === webhookPath) {
+            return handleUpdate(req, res);
+          }
+          res.writeHead(200, { "Content-Type": "text/plain" });
+          res.end("ok");
+        });
+        await bot.api.setWebhook(`${webhookUrl}${webhookPath}`);
+        logger?.log("telegram", `webhook mode: ${webhookUrl}${webhookPath}`);
+      } else {
+        logger?.log("telegram", "bot polling started");
+        await bot.start({ drop_pending_updates: true });
+      }
     }
   };
 }

package/src/transport/telegram/media.js

@@ -6,56 +6,62 @@ async function downloadToBuffer(ctx, fileId) {
   return Buffer.from(await response.arrayBuffer());
 }
 
+function incomingCaptionMetadata(ctx) {
+  return ctx.message?.caption ? { caption: ctx.message.caption } : {};
+}
+
 export async function captureIncomingArtifact(ctx, artifactStore) {
+  const chatId = ctx.chat.id;
+  const store = artifactStore.forChat(chatId);
   const baseSource = {
     type: "telegram",
-    chatId: ctx.chat.id,
+    chatId,
     messageId: ctx.msg.message_id,
     userId: ctx.from.id
   };
 
   if (ctx.message?.voice) {
-    const fileName = `${ctx.chat.id}-${ctx.msg.message_id}.ogg`;
+    const fileName = `${chatId}-${ctx.msg.message_id}.ogg`;
     const content = await downloadToBuffer(ctx, ctx.message.voice.file_id);
-    return artifactStore.createGeneratedFile({
+    return store.createGeneratedFile({
       fileName,
       content,
       kind: "audio",
       mimeType: "audio/ogg",
       source: baseSource,
-      metadata: { duration: ctx.message.voice.duration }
+      metadata: { duration: ctx.message.voice.duration, ...incomingCaptionMetadata(ctx) }
     });
   }
 
   if (ctx.message?.document) {
-    const fileName = ctx.message.document.file_name || `${ctx.chat.id}-${ctx.msg.message_id}`;
+    const fileName = ctx.message.document.file_name || `${chatId}-${ctx.msg.message_id}`;
     const content = await downloadToBuffer(ctx, ctx.message.document.file_id);
-    return artifactStore.createGeneratedFile({
+    return store.createGeneratedFile({
       fileName,
       content,
       kind: "document",
       mimeType: ctx.message.document.mime_type || "application/octet-stream",
       source: baseSource,
-      metadata: {}
+      metadata: incomingCaptionMetadata(ctx)
     });
   }
 
   if (ctx.message?.photo?.length) {
     const photo = ctx.message.photo.at(-1);
-    const fileName = `${ctx.chat.id}-${ctx.msg.message_id}.jpg`;
+    const fileName = `${chatId}-${ctx.msg.message_id}.jpg`;
     const content = await downloadToBuffer(ctx, photo.file_id);
-    return artifactStore.createGeneratedFile({
+    return store.createGeneratedFile({
       fileName,
       content,
       kind: "image",
       mimeType: "image/jpeg",
       source: baseSource,
-      metadata: { width: photo.width, height: photo.height }
+      metadata: { width: photo.width, height: photo.height, ...incomingCaptionMetadata(ctx) }
     });
   }
 
   if (ctx.message?.text) {
-    return artifactStore.createText({
+    return store.createText({
       text: ctx.message.text,
       source: baseSource,
       metadata: {}

package/tools/openai-transcribe/index.js

@@ -9,7 +9,7 @@ const toolName = "openai-transcribe";
 const config = await loadToolConfig(toolName, defaults);
 
 function printHelp() {
-  console.log(`openai-transcribe\n\nUsage:\n  node index.js --help\n  node index.js run --request-file <json>\n\nExpected input:\n  {\n    \"artifact\": { \"path\": \"/abs/audio.ogg\", \"mimeType\": \"audio/ogg\" },\n    \"args\": {}\n  }\n\nConfig at ${getToolConfigPath(toolName)}:\n  OPENAI_API_KEY\n  MODEL\n`);
+  console.log(`openai-transcribe\n\nUsage:\n  node index.js --help\n  node index.js run --request-file <json>\n\nExpected input:\n  {\n    "artifact": { "path": "/abs/audio.ogg", "mimeType": "audio/ogg" },\n    "args": {}\n  }\n\nConfig at ${getToolConfigPath(toolName)}:\n  OPENAI_API_KEY\n  MODEL\n`);
 }
 
 async function run(requestFile) {

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"
   });