arisa 3.1.2 → 3.1.6

package/src/transport/telegram/bot.js

@@ -3,7 +3,10 @@ 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";
+import { withTimeout } from "../../core/agent/prompt-timeout.js";
+import { normalizeArtifactForReasoning, shouldNormalizeArtifactToText } from "../../core/artifacts/normalize-for-reasoning.js";
+
+const promptTimeoutMs = 300_000;
 
 function quotedMessageSummary(message) {
   if (!message) return [];
@@ -63,11 +66,11 @@ function buildPrompt({ ctx, artifact, transcript, toolResult }) {
   if (transcript) {
     parts.push(`transcriptArtifactId: ${transcript.id}`);
     parts.push(`transcriptText: ${transcript.text}`);
-    parts.push(`Important: the incoming audio has already been transcribed. Use the transcript as the user message content. Do not answer with a raw transcription unless the user explicitly asked for one.`);
+    parts.push(`Important: the incoming media has already been transcribed. Use the transcript as the user message content. Do not answer with a raw transcription unless the user explicitly asked for one.`);
   }
-  if (artifact?.kind === "audio" && !transcript && 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 voice/audio message.`);
+  if (shouldNormalizeArtifactToText(artifact) && !transcript && toolResult) {
+    parts.push(`mediaNormalizationResult: ${JSON.stringify(toolResult)}`);
+    parts.push(`Important: pre-reasoning media normalization could not be completed, so you do not have a transcript for this audio/video message.`);
   }
 
   parts.push(`If you need a CLI tool, use list_tools/tool_help/run_tool.`);
@@ -114,10 +117,10 @@ async function buildAsyncTaskPrompt({ task, artifactStore, toolRegistry, logger
         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.");
+        parts.push("Important: the attached media artifact has already been normalized for reasoning. Use the transcript as the message content.");
+      } else if (shouldNormalizeArtifactToText(artifact) && toolResult) {
+        parts.push(`mediaNormalizationResult: ${JSON.stringify(toolResult)}`);
+        parts.push("Important: pre-reasoning media normalization could not be completed, so you do not have a transcript for this audio/video artifact.");
       }
     } else {
       parts.push(`artifactId: ${task.payload.artifactId}`);
@@ -130,6 +133,18 @@ async function buildAsyncTaskPrompt({ task, artifactStore, toolRegistry, logger
   return parts.filter(Boolean).join("\n");
 }
 
+function buildAsyncEventPrompt(task) {
+  return [
+    "External event arrived.",
+    `taskId: ${task.id}`,
+    `chatId: ${task.payload.chatId}`,
+    task.payload.prompt ? `event: ${task.payload.prompt}` : null,
+    "A polling checker detected this external event. Evaluate it and decide the next action.",
+    "If it warrants no action, you may stay silent.",
+    "If needed, use tools."
+  ].filter(Boolean).join("\n");
+}
+
 async function normalizeIncomingArtifact({ artifact, toolRegistry, chatArtifactStore, chatId }) {
   if (!artifact) return { transcript: null, toolResult: null };
   const { normalizedArtifact, toolResult } = await normalizeArtifactForReasoning({
@@ -142,15 +157,52 @@ async function normalizeIncomingArtifact({ artifact, toolRegistry, chatArtifactS
   return { transcript: normalizedArtifact, toolResult };
 }
 
-async function collectText(session, prompt) {
+function sessionEventLogMessage(event) {
+  if (event.type === "tool_execution_start") {
+    return `tool ${event.toolName} started`;
+  }
+  if (event.type === "tool_execution_end") {
+    return `tool ${event.toolName} ${event.isError ? "failed" : "finished"}`;
+  }
+  if (event.type === "auto_retry_start") {
+    return `auto retry ${event.attempt}/${event.maxAttempts} in ${event.delayMs}ms: ${event.errorMessage}`;
+  }
+  if (event.type === "auto_retry_end") {
+    return event.success
+      ? `auto retry succeeded after ${event.attempt} attempt(s)`
+      : `auto retry failed after ${event.attempt} attempt(s): ${event.finalError || "unknown error"}`;
+  }
+  if (event.type === "compaction_start") {
+    return `compaction started (${event.reason})`;
+  }
+  if (event.type === "compaction_end") {
+    return `compaction ${event.aborted ? "aborted" : "finished"} (${event.reason})`;
+  }
+  if (event.type === "message_end" && event.message?.stopReason === "error") {
+    return `assistant message ended with error: ${event.message.errorMessage || "unknown error"}`;
+  }
+  return "";
+}
+
+async function collectText(session, prompt, { logger, chatId } = {}) {
   let text = "";
   const unsubscribe = session.subscribe((event) => {
     if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
       text += event.assistantMessageEvent.delta;
     }
+    const logMessage = sessionEventLogMessage(event);
+    if (logMessage) logger?.log("agent", `chat ${chatId} ${logMessage}`);
   });
-  await session.prompt(prompt);
-  unsubscribe();
+
+  try {
+    await withTimeout(session.prompt(prompt), {
+      timeoutMs: promptTimeoutMs,
+      label: `Telegram prompt for chat ${chatId}`
+    });
+  } finally {
+    unsubscribe();
+  }
+
   return text.trim();
 }
 
@@ -170,6 +222,7 @@ async function withTyping(ctx, work) {
 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();
+  let taskTimer = null;
 
   function getIncomingChatMeta(ctx) {
     return {
@@ -194,9 +247,9 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     const artifact = await captureIncomingArtifact(ctx, artifactStore);
     if (artifact) logger?.log("telegram", `captured artifact ${artifact.kind}${artifact.id ? ` ${artifact.id}` : ""}`);
     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"}`);
+    if (transcript) logger?.log("telegram", `media transcribed to artifact ${transcript.id}`);
+    if (shouldNormalizeArtifactToText(artifact) && !transcript) {
+      logger?.log("telegram", `media normalization unavailable for chat ${ctx.chat.id}: ${toolResult?.error || toolResult?.missingConfig?.join(", ") || "unknown error"}`);
     }
     return buildPrompt({ ctx, artifact, transcript, toolResult });
   }
@@ -240,7 +293,13 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
   async function processPromptForChat({ chatId, prompt, ctx = null }) {
     const work = async () => {
       const { session } = await agentManager.getSessionContext(chatId, createTelegramSessionBridge(chatId));
-      const text = await collectText(session, prompt);
+      let text = "";
+      try {
+        text = await collectText(session, prompt, { logger, chatId });
+      } catch (error) {
+        agentManager.resetSession(chatId);
+        throw error;
+      }
       if (text) {
         await sendTextReply({
           sendText: (message, extra) => bot.api.sendMessage(chatId, message, extra),
@@ -271,12 +330,19 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     let currentPrompt = prompt;
     let currentCtx = ctx;
 
-    while (currentPrompt) {
-      try {
-        logger?.log("telegram", `prompt dispatch for chat ${chatId}`);
-        await processPromptForChat({ chatId, prompt: currentPrompt, ctx: currentCtx });
-      } finally {
-        currentCtx = null;
+    try {
+      while (currentPrompt) {
+        try {
+          logger?.log("telegram", `prompt dispatch for chat ${chatId}`);
+          await processPromptForChat({ chatId, prompt: currentPrompt, ctx: currentCtx });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          logger?.error("telegram", `${label} failed for chat ${chatId}: ${message}`);
+          throw error;
+        } finally {
+          currentCtx = null;
+        }
+
         if (chatState.nextPrompt) {
           currentPrompt = chatState.nextPrompt;
           chatState.nextPrompt = "";
@@ -284,9 +350,9 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
           currentPrompt = "";
         }
       }
+    } finally {
+      chatState.processing = false;
     }
-
-    chatState.processing = false;
   }
 
   async function enqueueOrProcess(ctx) {
@@ -310,6 +376,73 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     });
   }
 
+  async function dispatchTask(task) {
+    const chatId = task.payload?.chatId;
+    if (!chatId) {
+      await taskStore.fail(task.id, `Task missing chatId: ${task.kind}`);
+      return;
+    }
+
+    if (task.kind === "agent_task") {
+      if (!task.payload.prompt) {
+        await taskStore.fail(task.id, "agent_task missing prompt");
+        return;
+      }
+      logger?.log("tasks", `running task ${task.id} for chat ${chatId}`);
+      await enqueuePrompt({
+        chatId,
+        prompt: await buildAsyncTaskPrompt({ task, artifactStore, toolRegistry, logger }),
+        label: `scheduled task ${task.id}`
+      });
+      await taskStore.complete(task.id);
+      return;
+    }
+
+    if (task.kind === "agent_event") {
+      logger?.log("tasks", `agent event ${task.id} for chat ${chatId}`);
+      await enqueuePrompt({
+        chatId,
+        prompt: buildAsyncEventPrompt(task),
+        label: `agent event ${task.id}`
+      });
+      await taskStore.complete(task.id);
+      return;
+    }
+
+    if (task.kind === "poll_tool") {
+      const toolName = task.payload?.toolName;
+      if (!toolName) {
+        await taskStore.fail(task.id, "poll_tool missing toolName");
+        return;
+      }
+      logger?.log("tasks", `polling tool ${toolName} (task ${task.id}) for chat ${chatId}`);
+      try {
+        await agentManager.runTool({
+          name: toolName,
+          request: { args: task.payload.args || {} },
+          chatId
+        });
+      } catch (error) {
+        logger?.log("tasks", `poll_tool ${toolName} failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      await taskStore.complete(task.id);
+      return;
+    }
+
+    await taskStore.fail(task.id, `Unsupported task: ${task.kind}`);
+  }
+
+  async function dispatchDueTasks() {
+    const tasks = await taskStore.claimDue(10);
+    for (const task of tasks) {
+      try {
+        await dispatchTask(task);
+      } catch (error) {
+        await taskStore.fail(task.id, error instanceof Error ? error.message : String(error));
+      }
+    }
+  }
+
   async function handleNewCommand(ctx) {
     agentManager.resetSession(ctx.chat.id);
     perChatState.set(ctx.chat.id, { processing: false, nextPrompt: "" });
@@ -381,26 +514,14 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
       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: 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 (!taskTimer) {
+        taskTimer = setInterval(() => {
+          dispatchDueTasks().catch((error) => {
+            logger?.error("tasks", `dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+          });
+        }, 1000);
+        taskTimer.unref();
+      }
       if (webhookUrl && setHttpRequestHandler) {
         const webhookPath = `/telegram-${config.telegram.token.slice(-8)}`;
         const handleUpdate = webhookCallback(bot, "http", {
@@ -421,6 +542,14 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
         logger?.log("telegram", "bot polling started");
         await bot.start({ drop_pending_updates: true });
       }
+    },
+
+    async stop() {
+      if (taskTimer) clearInterval(taskTimer);
+      taskTimer = null;
+      try {
+        bot.stop();
+      } catch {}
     }
   };
 }

package/src/transport/telegram/media.js

@@ -33,6 +33,26 @@ export async function captureIncomingArtifact(ctx, artifactStore) {
     });
   }
 
+  if (ctx.message?.video) {
+    const video = ctx.message.video;
+    const fileName = video.file_name || `${chatId}-${ctx.msg.message_id}.mp4`;
+    const content = await downloadToBuffer(ctx, video.file_id);
+    return store.createGeneratedFile({
+      fileName,
+      content,
+      kind: "video",
+      mimeType: video.mime_type || "video/mp4",
+      source: baseSource,
+      metadata: {
+        duration: video.duration,
+        width: video.width,
+        height: video.height,
+        fileSize: video.file_size,
+        ...incomingCaptionMetadata(ctx)
+      }
+    });
+  }
+
   if (ctx.message?.document) {
     const fileName = ctx.message.document.file_name || `${chatId}-${ctx.msg.message_id}`;
     const content = await downloadToBuffer(ctx, ctx.message.document.file_id);

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/media.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/openai-transcribe/tool.manifest.json

@@ -1,8 +1,8 @@
 {
   "name": "openai-transcribe",
-  "description": "Transcribe audio files with OpenAI audio transcription API.",
+  "description": "Transcribe audio files and video audio tracks with OpenAI audio transcription API.",
   "entry": "index.js",
-  "input": ["audio/ogg", "audio/mpeg", "audio/wav", "audio/mp4"],
+  "input": ["audio/ogg", "audio/mpeg", "audio/wav", "audio/mp4", "video/mp4"],
   "output": ["text/plain"],
   "configSchema": {
     "OPENAI_API_KEY": {

package/tools/openai-tts/index.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import defaults from "./config.js";
 import { loadToolConfig } from "../../src/core/tools/tool-config.js";
 import { toolError, toolNeedsConfig, toolOk } from "../../src/core/tools/tool-result.js";
-import { getToolConfigPath, getToolOutDir } from "../../src/runtime/paths.js";
+import { getChatToolTmpDir, getToolConfigPath, getToolTmpDir } from "../../src/runtime/paths.js";
 
 const toolName = "openai-tts";
 const config = await loadToolConfig(toolName, defaults);
@@ -49,7 +49,9 @@ async function run(requestFile) {
     return;
   }
 
-  const outDir = getToolOutDir(toolName);
+  const outDir = request.chatId != null
+    ? getChatToolTmpDir(request.chatId, toolName)
+    : getToolTmpDir(toolName);
   await mkdir(outDir, { recursive: true });
   const filePath = path.join(outDir, `speech-${Date.now()}.ogg`);
   const buffer = Buffer.from(await response.arrayBuffer());

package/docs/async-event-queue-flow.md

@@ -1,68 +0,0 @@
-# Flow genérico de eventos asíncronos para tools
-
-> Estado: propuesta / no implementado. Guardado como referencia.
-> La implementación actual (timer) se mantiene; este documento describe una evolución posible.
-
-## Problema
-
-Hoy la única re-entrada asíncrona al agente es por tiempo: una tool devuelve `asyncTask` con `runAt` y el poller de 1s en `src/transport/telegram/bot.js` lo dispara como prompt. Eso obliga a resolver con timer (polling crudo, latencia fija, re-spawn de la tool y un turno completo del agente en cada chequeo). Falta una **cola de eventos entrantes** que despierte al agente solo cuando hay algo que evaluar.
-
-## Solución (polling ordenado por cola, reusando TaskStore)
-
-Dos nuevos `kind` de tarea, drenados por el mismo poller hacia el mismo `enqueuePrompt`:
-
-- `poll_tool`: tarea recurrente que el poller **ejecuta directamente como tool** (no gasta turno del agente). El checker mantiene su propio cursor de estado en su config/tmp por chat. Si hay novedad, emite un `agent_event`.
-- `agent_event`: evento entrante que se dispara de inmediato. El poller lo entrega como prompt para que Pi lo evalúe y decida.
-
-```mermaid
-flowchart LR
-  Tool[Tool run normal] -->|asyncTask poll_tool| TS[TaskStore]
-  TS --> Poller[1s poller dispatcher]
-  Poller -->|kind poll_tool| Run[agentManager.runTool checker]
-  Run -->|si hay novedad: asyncTask agent_event| TS
-  Poller -->|kind agent_event| EP[enqueuePrompt]
-  Poller -->|kind agent_task| EP
-  EP --> Pi[Pi evalua y decide]
-```
-
-## Cambios
-
-### 1. TaskStore: eventos/polls sin hora se disparan ya
-
-`src/core/tasks/task-store.js` - en `normalizeTask`, default `runAt` a `now` cuando no viene (los `agent_event` y el primer disparo de `poll_tool` deben ser inmediatos; `computeNextRunAt` ya reprograma `poll_tool` por su `recurrence`). Cambio de una línea, no rompe `agent_task` (siempre trae `runAt`).
-
-### 2. AgentManager: extraer "run + materializar" (DRY)
-
-`src/core/agent/agent-manager.js` - hoy el `execute` de `run_tool` (líneas ~184-242) hace: correr la tool, convertir `output.text`/`output.filePath` en artifacts y mandar `asyncTask(s)` al `TaskStore` con el `chatId`. Extraer eso a un método reusable `runTool({ name, request, chatId })`. El Pi tool `run_tool` pasa a llamarlo. Así el poller puede correr tools con la **misma** lógica de materialización (incluido el alta de `agent_event` que emita el checker).
-
-### 3. Poller -> dispatcher por kind
-
-`src/transport/telegram/bot.js` - reemplazar el handler de un solo kind dentro del `setInterval` (líneas ~361-380) por un dispatcher:
-
-- `agent_task` -> `enqueuePrompt(buildAsyncTaskPrompt(task))` + `complete` (igual que hoy).
-- `agent_event` -> `enqueuePrompt(buildAsyncEventPrompt(task))` + `complete`.
-- `poll_tool` -> `agentManager.runTool({ name: task.payload.toolName, request: { args: task.payload.args || {} }, chatId })`; los `agent_event` que emita el checker quedan encolados para el próximo tick; luego `complete` (la `recurrence` reprograma el poll). Si la tool falla: log + `complete` para no matar el poll.
-
-Agregar `buildAsyncEventPrompt(task)` junto a `buildAsyncTaskPrompt` (línea ~82), con framing de "llegó un evento externo, evalualo y decidí la próxima acción". Si el branch queda denso, extraer `dispatchDueTasks(...)` a una función para mantener `bot.js` como transporte.
-
-### 4. Documentar el flow
-
-`AGENTS.md` - sección nueva (en inglés) explicando: cómo una tool arma su auto-polling devolviendo un `asyncTask` kind `poll_tool` con `recurrence`, cómo emite novedades con `asyncTask` kind `agent_event`, que el checker guarda su cursor en su config/tmp por chat, y que el agente razona sobre el `agent_event` para decidir. `list_scheduled_tasks`/`cancel_scheduled_task` ya sirven (son kind-agnostic) para ver/cancelar polls.
-
-## Contrato del checker tool (sin nuevas Pi tools)
-
-Todo pasa por el campo `asyncTasks` que el pipeline ya soporta:
-
-- Arranque del poll (desde el `run` de cualquier tool): `asyncTasks: [{ kind: "poll_tool", payload: { toolName, args }, recurrence: { type: "interval", everySeconds: N } }]`.
-- Novedad (desde el `run` del checker): `asyncTasks: [{ kind: "agent_event", payload: { prompt: "<contenido a evaluar>" } }]`.
-
-## No-goals (por ahora)
-
-- No se agrega listener persistente (`node index.js listen`) ni proceso de fondo con IPC.
-- No se agrega endpoint HTTP entrante para eventos.
-- No se resuelve el caso de conexión sostenida (tipo cliente logueado): los checkers son one-shot y persisten su cursor entre corridas.
-
-## Alternativas consideradas (descartadas para esta versión)
-
-- **Listener tools**: la tool corre como proceso de larga duración (`node index.js listen`) y emite eventos por stdout que Arisa drena a la cola. Más general y realtime, pero agrega ciclo de vida de proceso a la service e IPC.
-- **Webhook entrante**: Arisa expone un endpoint HTTP interno donde sistemas externos hacen POST de eventos. Bueno para callbacks; no sirve para los que requieren sostener una conexión.

package/src/core/agent/project-instructions.js

@@ -1,11 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { fileURLToPath } from "node:url";
-
-const instructionsPath = fileURLToPath(new URL("../../../AGENTS.md", import.meta.url));
-let cachedInstructions = null;
-
-export async function loadProjectInstructions() {
-  if (cachedInstructions !== null) return cachedInstructions;
-  cachedInstructions = await readFile(instructionsPath, "utf8");
-  return cachedInstructions;
-}