arisa 3.0.14 → 3.1.4

package/src/runtime/paths.js

@@ -7,10 +7,30 @@ export const stateDir = path.join(arisaHomeDir, "state");
 export const configFile = path.join(stateDir, "config.json");
 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 const chatsDir = path.join(arisaHomeDir, "chats");
+export const toolStateDir = path.join(stateDir, "tools");
+
+export function getChatDir(chatId) {
+  return path.join(chatsDir, String(chatId));
+}
+
+export function getChatArtifactsDir(chatId) {
+  return path.join(getChatDir(chatId), "artifacts");
+}
+
+export function getChatArtifactsIndexFile(chatId) {
+  return path.join(getChatDir(chatId), "state", "artifacts.json");
+}
+
+export function getChatToolStateDir(chatId, toolName) {
+  return path.join(getChatDir(chatId), "state", "tools", toolName);
+}
+
+export function getChatPiSessionsDir(chatId) {
+  return path.join(getChatDir(chatId), "state", "pi-sessions");
+}
 
 export function getToolDir(toolName) {
   return path.join(toolsDir, toolName);
@@ -20,21 +40,33 @@ export function getToolConfigPath(toolName) {
   return path.join(getToolDir(toolName), "config.js");
 }
 
-export function getToolRuntimeDir(toolName) {
-  return getToolDir(toolName);
+export function getChatConfigDir(chatId) {
+  return path.join(getChatDir(chatId), "config");
+}
+
+export function getChatTmpDir(chatId) {
+  return path.join(getChatDir(chatId), "tmp");
 }
 
-export function getToolOutDir(toolName) {
-  return path.join(getToolRuntimeDir(toolName), "out");
+export function getChatToolConfigPath(chatId, toolName) {
+  return path.join(getChatConfigDir(chatId), "tools", toolName, "config.js");
+}
+
+export function getToolStateDir(toolName) {
+  return path.join(toolStateDir, toolName);
 }
 
 export function getToolTmpDir(toolName) {
-  return path.join(getToolRuntimeDir(toolName), "tmp");
+  return path.join(getToolStateDir(toolName), "tmp");
+}
+
+export function getChatToolTmpDir(chatId, toolName) {
+  return path.join(getChatTmpDir(chatId), "tools", toolName);
 }
 
 export async function ensureArisaHome() {
   await mkdir(stateDir, { recursive: true });
-  await mkdir(artifactsDir, { recursive: true });
   await mkdir(toolsDir, { recursive: true });
+  await mkdir(chatsDir, { recursive: true });
 }
 

package/src/runtime/service-manager.js

@@ -36,7 +36,7 @@ export async function getServiceStatus() {
   return { running: true, pid };
 }
 
-export async function startService({ verbose = false } = {}) {
+export async function startService({ verbose = false, cliArgs = [] } = {}) {
   await ensureArisaHome();
   const status = await getServiceStatus();
   if (status.running) {
@@ -44,7 +44,7 @@ export async function startService({ verbose = false } = {}) {
   }
 
   const logHandle = await open(serviceLogFile, "a");
-  const args = [entryFile, "--service-runner"];
+  const args = [entryFile, "--service-runner", ...cliArgs];
   if (verbose) args.push("--verbose");
 
   const child = spawn(process.execPath, args, {

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, shouldNormalizeArtifactToText } from "../../core/artifacts/normalize-for-reasoning.js";
 
 function quotedMessageSummary(message) {
   if (!message) return [];
@@ -39,16 +40,21 @@ function getTelegramCommand(ctx) {
   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 Session..`,
+    `Incoming Telegram message.`,
     `chatId: ${ctx.chat.id}`,
     `userId: ${ctx.from.id}`,
     `username: ${ctx.from.username || "(no username)"}`,
     `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}`);
@@ -57,11 +63,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.`);
@@ -79,43 +85,73 @@ function buildNewSessionPrompt(ctx) {
   ].join("\n");
 }
 
-function buildAsyncTaskPrompt(task) {
-  return [
+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,
-    "Treat this as a new request for the chat and fulfill it now.",
-    "If needed, use tools."
-  ].filter(Boolean).join("\n");
-}
+    task.payload.prompt ? `text: ${task.payload.prompt}` : null
+  ];
 
-async function maybeTranscribeIncomingAudio({ artifact, toolRegistry, artifactStore }) {
-  if (!artifact || artifact.kind !== "audio") return { transcript: null };
+  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
+      });
 
-  const result = await toolRegistry.run({
-    name: "openai-transcribe",
-    request: {
-      artifact,
-      args: {}
+      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 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}`);
+      parts.push("Important: referenced artifact was not found.");
     }
-  });
-
-  if (!result.ok) {
-    return { transcript: null, toolResult: result };
   }
 
-  if (!result.output?.text) {
-    return { transcript: null, toolResult: { ok: false, status: "failed", error: "Transcription returned no text." } };
-  }
+  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");
+}
 
-  const transcript = await artifactStore.createText({
-    text: result.output.text,
-    source: { type: "tool", toolName: "openai-transcribe" },
-    metadata: { fromArtifactId: artifact.id, tool: "openai-transcribe" }
-  });
+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");
+}
 
-  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) {
@@ -143,8 +179,8 @@ async function withTyping(ctx, work) {
   }
 }
 
-export async function createTelegramBot({ config, artifactStore, toolRegistry, taskStore, 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) {
@@ -164,13 +200,15 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
   }
 
   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 });
-    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"}`);
+    const { transcript, toolResult } = await normalizeIncomingArtifact({ artifact, toolRegistry, chatArtifactStore, chatId });
+    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 });
   }
@@ -180,7 +218,8 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
 
     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",
@@ -283,6 +322,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: "" });
@@ -354,28 +460,31 @@ 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: 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));
-          }
-        }
+      setInterval(() => {
+        dispatchDueTasks().catch((error) => {
+          logger?.error("tasks", `dispatch failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
       }, 1000).unref();
-      logger?.log("telegram", "bot polling started");
-      await bot.start({ drop_pending_updates: true });
+      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,82 @@ 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?.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 || `${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/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": {