arisa 4.1.8 → 4.1.12

package/AGENTS.md

@@ -121,7 +121,9 @@ To run a pipe, the agent should:
 Example manual pipe:
 1. `run_tool(openai-transcribe, artifact audio)`
 2. take the returned text `artifactId`
-3. `run_tool(openai-tts, artifact text)` or `send_media_reply(text)`
+3. `run_tool(openai-tts, artifact text)` to generate audio, then `send_artifact(artifactId)` to deliver it (or `run_tool(openai-tts, artifact text, deliver: true)` to generate and send in one step)
+
+Delivery is generic: any `run_tool` output that produces a file becomes an artifact, and `send_artifact(artifactId)` delivers it to the chat. The delivery method and filename are derived from the artifact (its `delivery` hint, `kind`, and stored name); internal local paths are never exposed. No caption is sent by default: the filename already appears on the attachment, so it is never duplicated into the caption text (which would let Telegram autolink a filename like `example.md` as a URL). A caption is shown only when an explicit one is passed. Tools declare their delivery intent by returning `delivery: { method }` in their output; they do not deliver to the transport themselves. As a shortcut, `run_tool` accepts `deliver: true` to generate and deliver in a single step; use it only when the user should receive the file now, not for intermediate pipe steps.
 
 ## Async event queue flow
 Beyond time-based scheduling, tools can drive an event queue that wakes the agent only when there is something to evaluate. Everything goes through the `asyncTask` (single) or `asyncTasks` (array) field the pipeline already supports; no new Pi tools are needed. The 1s poller drains tasks by `kind`:
@@ -195,6 +197,8 @@ Tools may declare skills in `tool.manifest.json`:
 
 The tool registry resolves these from the installed skills directory and injects them into the tool request as `skills`. `list_tools` exposes the hints and `tool_help` shows their resolution status. Skills are guidance for the agent/tool; they are not separate runtime dependencies.
 
+If a tool executes deterministic logic over skill content, bundle the required skill assets inside the tool package and treat injected `skills` only as an optional override. A catalog tool must still work when the hinted skill is not installed on the target Arisa instance.
+
 ## Safety
 - Prefer tool manifests and CLI help over assumptions.
 - Keep config and runtime data inside the user runtime area through the path helpers above.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "4.1.8",
+  "version": "4.1.12",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",

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

@@ -19,7 +19,7 @@ const arisaToolNames = [
   "list_scheduled_tasks",
   "cancel_scheduled_task",
   "cancel_all_scheduled_tasks",
-  "send_media_reply"
+  "send_artifact"
 ];
 
 function isLocalBaseUrl(value) {
@@ -55,30 +55,28 @@ async function promptAndThrowOnAssistantError(session, prompt) {
   }
 }
 
-function mimeMatches(pattern, mimeType = "") {
-  if (!pattern || !mimeType) return false;
-  if (pattern === mimeType) return true;
-  if (pattern.endsWith("/*")) return mimeType.startsWith(`${pattern.slice(0, -2)}/`);
-  return false;
+function inferDeliveryMethod(artifact) {
+  if (artifact.kind === "audio" || (artifact.mimeType || "").startsWith("audio/")) return "audio";
+  return "document";
 }
 
-function toolSupportsTextInput(tool) {
-  return (tool.input || []).some((input) => mimeMatches(input, "text/plain"));
+function containsAbsolutePath(value) {
+  if (typeof value !== "string") return false;
+  return /(^|\s)(\/[^\s]|[A-Za-z]:[\\/])/.test(value);
 }
 
-function toolProducesAudio(tool) {
-  return (tool.output || []).some((output) => mimeMatches(output, "audio/ogg") || mimeMatches(output, "audio/*"));
+export function resolveMediaCaption(caption) {
+  if (caption && !containsAbsolutePath(caption)) return caption;
+  return undefined;
 }
 
-function looksLikeTextToSpeechTool(tool) {
-  return /tts|text.?to.?speech|speech.?audio|speech/i.test(`${tool.name} ${tool.description || ""}`);
-}
-
-function selectMediaReplyTool(toolRegistry) {
-  const tools = toolRegistry.list()
-    .filter(toolSupportsTextInput)
-    .filter(toolProducesAudio);
-  return tools.find(looksLikeTextToSpeechTool) || tools[0] || null;
+async function deliverArtifactToChat({ artifact, telegram, caption, method, logger }) {
+  const resolvedMethod = method || artifact.metadata?.delivery?.method || inferDeliveryMethod(artifact);
+  const fileName = path.basename(artifact.path);
+  const resolvedCaption = resolveMediaCaption(caption);
+  logger?.log("agent", `deliver artifact ${artifact.id} as ${resolvedMethod}`);
+  await telegram.sendMedia(artifact.path, { method: resolvedMethod, caption: resolvedCaption, filename: fileName });
+  return { method: resolvedMethod, fileName, artifactId: artifact.id };
 }
 
 async function assertDirectory(dir, label) {
@@ -238,7 +236,7 @@ export class AgentManager {
         kind: result.output.kind || "file",
         mimeType: result.output.mimeType || "application/octet-stream",
         source: { type: "tool", toolName: name },
-        metadata: { tool: name }
+        metadata: { tool: name, delivery: result.output.delivery }
       });
       result.output.artifactId = generated.id;
       await unlink(result.output.filePath).catch(() => {});
@@ -337,12 +335,13 @@ export class AgentManager {
       defineTool({
         name: "run_tool",
         label: "Run tool",
-        description: "Run a CLI tool using text input or an artifactId. Inspect the returned status/resolution fields. If a tool reports missing config, ask the user naturally, use set_tool_config, and retry.",
+        description: "Run a CLI tool using text input or an artifactId. Inspect the returned status/resolution fields. If a tool reports missing config, ask the user naturally, use set_tool_config, and retry. Set `deliver: true` to also send the generated file to the chat in one step (only when you want the user to receive it now, not for intermediate pipe steps).",
         parameters: Type.Object({
           name: Type.String(),
           artifactId: Type.Optional(Type.String()),
           text: Type.Optional(Type.String()),
-          args: Type.Optional(Type.Record(Type.String(), Type.String()))
+          args: Type.Optional(Type.Record(Type.String(), Type.String())),
+          deliver: Type.Optional(Type.Boolean())
         }),
         execute: async (_id, params) => {
           let artifact = null;
@@ -362,6 +361,13 @@ export class AgentManager {
             chatId
           });
 
+          if (params.deliver && result.output?.artifactId) {
+            const generated = await chatArtifactStore.get(result.output.artifactId);
+            if (generated?.path) {
+              result.sent = await deliverArtifactToChat({ artifact: generated, telegram, logger: this.logger });
+            }
+          }
+
           return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
             details: result
@@ -417,12 +423,12 @@ export class AgentManager {
         }
       }),
       defineTool({
-        name: "send_media_reply",
-        label: "Send media reply",
-        description: "Run a CLI tool that generates a file and send it to the current Telegram chat using the tool's delivery hint or an explicit method.",
+        name: "send_artifact",
+        label: "Send artifact",
+        description: "Deliver an existing chat artifact to the current Telegram chat. Pass the `artifactId` returned by run_tool or from an inbound file. The delivery method and filename are derived from the artifact (its delivery hint, kind, and stored name); internal local paths are never exposed. No caption is shown by default, since the filename already appears on the attachment; set `caption` only to add a separate visible label, or `method` to override the delivery method. The artifact is not deleted.",
         parameters: Type.Object({
-          text: Type.String(),
-          toolName: Type.Optional(Type.String()),
+          artifactId: Type.String(),
+          caption: Type.Optional(Type.String()),
           method: Type.Optional(Type.Union([
             Type.Literal("voice"),
             Type.Literal("audio"),
@@ -430,36 +436,25 @@ export class AgentManager {
           ]))
         }),
         execute: async (_id, params) => {
-          await this.toolRegistry.load();
-          const selectedTool = params.toolName
-            ? this.toolRegistry.get(params.toolName)
-            : selectMediaReplyTool(this.toolRegistry);
-          if (!selectedTool) {
-            const result = {
-              ok: false,
-              status: "failed",
-              error: params.toolName
-                ? `Tool not found: ${params.toolName}`
-                : "No registered text-to-speech tool can generate an audio reply."
-            };
+          const artifact = await chatArtifactStore.get(params.artifactId);
+          if (!artifact) {
+            const result = { ok: false, status: "failed", error: `Artifact not found: ${params.artifactId}` };
             return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }], details: result };
           }
-          const toolName = selectedTool.name;
-          this.logger?.log("agent", `send_media_reply via ${toolName}`);
-          const result = await this.toolRegistry.run({
-            name: toolName,
-            request: { text: params.text, args: {} },
-            chatId
-          });
-          if (!result.ok || !result.output?.filePath) {
+          if (!artifact.path) {
+            const result = { ok: false, status: "failed", error: `Artifact ${params.artifactId} has no file to deliver.` };
             return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }], details: result };
           }
-          const method = params.method || result.output?.delivery?.method || "audio";
-          await telegram.sendMedia(result.output.filePath, { method, caption: params.text });
-          await unlink(result.output.filePath).catch(() => {});
+          const sent = await deliverArtifactToChat({
+            artifact,
+            telegram,
+            caption: params.caption,
+            method: params.method,
+            logger: this.logger
+          });
           return {
-            content: [{ type: "text", text: `Media sent to Telegram as ${method}.` }],
-            details: { ...result, sent: { method } }
+            content: [{ type: "text", text: `Media sent to Telegram as ${sent.method}.` }],
+            details: { ok: true, sent }
           };
         }
       })

package/src/transport/telegram/bot.js

@@ -77,7 +77,7 @@ function buildPrompt({ ctx, artifact, transcript, toolResult }) {
   parts.push(`Use read/write/edit for file work in the active workspace, bash for bash-compatible commands, and system_shell for native system commands such as PowerShell on Windows.`);
   parts.push(`If you need an Arisa modular CLI tool, use list_tools/tool_help/run_tool.`);
   parts.push(`If a tool config is missing, ask the user naturally and then use set_tool_config.`);
-  parts.push(`If the user wants a generated media reply, use send_media_reply.`);
+  parts.push(`To deliver a file to the chat: run_tool with deliver:true to generate and send in one step, or send_artifact with an existing artifactId (e.g. an inbound file).`);
   return parts.join("\n");
 }
 
@@ -426,9 +426,9 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
 
   function createTelegramSessionBridge(chatId) {
     return {
-      sendMedia: async (filePath, { method = "audio", caption } = {}) => {
+      sendMedia: async (filePath, { method = "audio", caption, filename } = {}) => {
         logger?.log("telegram", `sending ${method} reply for chat ${chatId}`);
-        const input = new InputFile(filePath);
+        const input = new InputFile(filePath, filename || undefined);
         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 });

package/test/artifact-store.test.js

@@ -0,0 +1,99 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+
+const homeDir = await mkdtemp(path.join(os.tmpdir(), "arisa-artifact-store-home-"));
+process.env.HOME = homeDir;
+process.env.USERPROFILE = homeDir;
+
+const { ArtifactStore } = await import("../src/core/artifacts/artifact-store.js");
+const { arisaHomeDir } = await import("../src/runtime/paths.js");
+
+async function resetHome() {
+  await rm(arisaHomeDir, { recursive: true, force: true });
+}
+
+test("creates, persists, reads, and lists text artifacts by recency", async () => {
+  await resetHome();
+  const store = new ArtifactStore();
+  const chatStore = store.forChat("chat-1");
+
+  const first = await chatStore.createText({
+    text: "first",
+    source: { type: "telegram" },
+    metadata: { index: 1 }
+  });
+  const second = await chatStore.createText({
+    text: "second",
+    mimeType: "text/markdown",
+    source: { type: "tool", toolName: "writer" },
+    metadata: { index: 2 }
+  });
+  const third = await chatStore.createText({
+    text: "third",
+    source: { type: "tool", toolName: "writer" }
+  });
+
+  assert.equal(first.chatId, "chat-1");
+  assert.equal(first.kind, "text");
+  assert.equal(first.mimeType, "text/plain");
+  assert.deepEqual(await chatStore.get(second.id), second);
+  assert.deepEqual((await chatStore.listRecent(2)).map((artifact) => artifact.id), [third.id, second.id]);
+
+  const reloadedStore = new ArtifactStore().forChat("chat-1");
+  assert.deepEqual(await reloadedStore.get(first.id), first);
+});
+
+test("copies file artifacts into the chat artifact directory", async () => {
+  await resetHome();
+  const originalDir = await mkdtemp(path.join(os.tmpdir(), "arisa-source-file-"));
+  const originalPath = path.join(originalDir, "voice.ogg");
+  await writeFile(originalPath, "audio-bytes", "utf8");
+
+  const artifact = await new ArtifactStore().forChat("chat-1").createFromFile({
+    originalPath,
+    fileName: "voice.ogg",
+    kind: "audio",
+    mimeType: "audio/ogg",
+    source: { type: "telegram", fileId: "telegram-file" },
+    metadata: { duration: 3 }
+  });
+
+  assert.equal(artifact.chatId, "chat-1");
+  assert.equal(artifact.kind, "audio");
+  assert.equal(artifact.mimeType, "audio/ogg");
+  assert.equal(path.basename(artifact.path), "voice.ogg");
+  assert.equal(await readFile(artifact.path, "utf8"), "audio-bytes");
+});
+
+test("creates generated file artifacts", async () => {
+  await resetHome();
+  const artifact = await new ArtifactStore().forChat("chat-1").createGeneratedFile({
+    fileName: "reply.md",
+    content: "# Hello\n",
+    kind: "document",
+    mimeType: "text/markdown",
+    source: { type: "assistant" }
+  });
+
+  assert.equal(await readFile(artifact.path, "utf8"), "# Hello\n");
+  assert.equal(artifact.kind, "document");
+  assert.equal(artifact.mimeType, "text/markdown");
+});
+
+test("keeps artifact indexes isolated by chat", async () => {
+  await resetHome();
+  const store = new ArtifactStore();
+  const chatA = store.forChat("chat-a");
+  const chatB = store.forChat("chat-b");
+
+  const aArtifact = await chatA.createText({ text: "for A", source: { type: "test" } });
+  const bArtifact = await chatB.createText({ text: "for B", source: { type: "test" } });
+
+  assert.deepEqual((await chatA.listRecent()).map((artifact) => artifact.id), [aArtifact.id]);
+  assert.deepEqual((await chatB.listRecent()).map((artifact) => artifact.id), [bArtifact.id]);
+  assert.equal(await chatA.get(bArtifact.id), null);
+  assert.equal(await chatB.get(aArtifact.id), null);
+});

package/test/auth-flow.test.js

@@ -0,0 +1,40 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { getErrorMessage, getPiAuthIssue } from "../src/core/agent/auth-flow.js";
+
+test("extracts messages from Error instances and other thrown values", () => {
+  assert.equal(getErrorMessage(new Error("boom")), "boom");
+  assert.equal(getErrorMessage("plain failure"), "plain failure");
+  assert.equal(getErrorMessage(404), "404");
+});
+
+test("classifies invalidated Pi authentication tokens", () => {
+  for (const error of [
+    new Error("authentication token has been invalidated"),
+    new Error("Token invalidated by provider"),
+    new Error("Please try signing in again"),
+    new Error("auth token expired")
+  ]) {
+    assert.deepEqual(getPiAuthIssue(error), {
+      kind: "invalidated-token",
+      message: error.message
+    });
+  }
+});
+
+test("classifies missing Pi authentication", () => {
+  for (const error of [
+    new Error("No auth found for provider"),
+    new Error("authentication credentials are missing")
+  ]) {
+    assert.deepEqual(getPiAuthIssue(error), {
+      kind: "missing-auth",
+      message: error.message
+    });
+  }
+});
+
+test("ignores unrelated Pi errors", () => {
+  assert.equal(getPiAuthIssue(new Error("model rate limit exceeded")), null);
+  assert.equal(getPiAuthIssue(new Error("")), null);
+});

package/test/auth.test.js

@@ -0,0 +1,101 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { authorizeChat } from "../src/transport/telegram/auth.js";
+
+function createConfig(overrides = {}) {
+  return {
+    telegram: {
+      authorizedChatIds: [],
+      maxChatIds: 2,
+      chatMeta: {},
+      ...(overrides.telegram || {})
+    }
+  };
+}
+
+function createSaveConfigSpy() {
+  const calls = [];
+  const saveConfig = async (config) => {
+    calls.push(JSON.parse(JSON.stringify(config)));
+  };
+  return { saveConfig, calls };
+}
+
+test("authorizes a new chat below the configured limit", async () => {
+  const config = createConfig();
+  const { saveConfig, calls } = createSaveConfigSpy();
+
+  const result = await authorizeChat({ config, chatId: 123, saveConfig });
+
+  assert.deepEqual(result, { ok: true, firstTime: true });
+  assert.deepEqual(config.telegram.authorizedChatIds, [123]);
+  assert.equal(calls.length, 1);
+  assert.deepEqual(calls[0].telegram.authorizedChatIds, [123]);
+});
+
+test("keeps an authorized chat id unique", async () => {
+  const config = createConfig({
+    telegram: { authorizedChatIds: [123] }
+  });
+  const { saveConfig, calls } = createSaveConfigSpy();
+
+  const result = await authorizeChat({ config, chatId: 123, saveConfig });
+
+  assert.deepEqual(result, { ok: true, firstTime: false });
+  assert.deepEqual(config.telegram.authorizedChatIds, [123]);
+  assert.equal(calls.length, 0);
+});
+
+test("rejects a new chat when the chat id limit is reached", async () => {
+  const config = createConfig({
+    telegram: { authorizedChatIds: [123, 456], maxChatIds: 2 }
+  });
+  const { saveConfig, calls } = createSaveConfigSpy();
+
+  const result = await authorizeChat({ config, chatId: 789, saveConfig });
+
+  assert.deepEqual(result, { ok: false, reason: "max-chat-ids" });
+  assert.deepEqual(config.telegram.authorizedChatIds, [123, 456]);
+  assert.equal(calls.length, 0);
+});
+
+test("enforces the maxChatIds off-by-one boundary", async () => {
+  const config = createConfig({
+    telegram: { authorizedChatIds: [123], maxChatIds: 1 }
+  });
+  const { saveConfig, calls } = createSaveConfigSpy();
+
+  const result = await authorizeChat({ config, chatId: 456, saveConfig });
+
+  assert.deepEqual(result, { ok: false, reason: "max-chat-ids" });
+  assert.deepEqual(config.telegram.authorizedChatIds, [123]);
+  assert.equal(calls.length, 0);
+});
+
+test("merges chat metadata for an existing authorized chat and persists it", async () => {
+  const config = createConfig({
+    telegram: {
+      authorizedChatIds: [123],
+      chatMeta: {
+        123: { username: "old-name", firstName: "Ada" }
+      }
+    }
+  });
+  const { saveConfig, calls } = createSaveConfigSpy();
+
+  const result = await authorizeChat({
+    config,
+    chatId: 123,
+    saveConfig,
+    chatMeta: { username: "new-name", lastName: "Lovelace" }
+  });
+
+  assert.deepEqual(result, { ok: true, firstTime: false });
+  assert.deepEqual(config.telegram.chatMeta[123], {
+    username: "new-name",
+    firstName: "Ada",
+    lastName: "Lovelace"
+  });
+  assert.equal(calls.length, 1);
+  assert.deepEqual(calls[0].telegram.chatMeta[123], config.telegram.chatMeta[123]);
+});