arisa 4.1.8 → 4.1.10

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 caption are derived from the artifact (its `delivery` hint, `kind`, and stored name); internal local paths are never exposed. 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.10",
   "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,31 @@ 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/*"));
+function resolveMediaCaption({ caption, output, method }) {
+  if (caption && !containsAbsolutePath(caption)) return caption;
+  if (method === "document" && output?.fileName) return output.fileName;
+  if (output?.text && !containsAbsolutePath(output.text)) return output.text;
+  if (output?.fileName) return output.fileName;
+  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, output: { fileName }, method: resolvedMethod });
+  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 +239,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 +338,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 +364,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 +426,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, caption, and filename are derived from the artifact (its delivery hint, kind, and stored name); internal local paths are never exposed. Set `caption` for a 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 +439,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 });