arisa 4.0.0 → 4.0.3

package/package.json

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

package/src/core/agent/auth-flow.js

@@ -0,0 +1,94 @@
+import { createPiRuntime, hasProviderAuth, supportsProviderOAuth } from "./pi-runtime.js";
+
+const authInvalidatedPatterns = [
+  /authentication token has been invalidated/i,
+  /token (?:has been )?invalidated/i,
+  /try signing in again/i,
+  /auth(?:entication)? token (?:expired|revoked|invalid)/i
+];
+
+const missingAuthPatterns = [
+  /no auth found/i,
+  /auth(?:entication)? .*missing/i
+];
+
+export function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function getPiAuthIssue(error) {
+  const message = getErrorMessage(error);
+  if (!message) return null;
+
+  if (authInvalidatedPatterns.some((pattern) => pattern.test(message))) {
+    return { kind: "invalidated-token", message };
+  }
+
+  if (missingAuthPatterns.some((pattern) => pattern.test(message))) {
+    return { kind: "missing-auth", message };
+  }
+
+  return null;
+}
+
+export function getPiAuthStatus(config) {
+  const runtime = createPiRuntime({
+    provider: config.pi.provider,
+    apiKey: config.pi.apiKey
+  });
+
+  return {
+    provider: config.pi.provider,
+    model: config.pi.model,
+    hasApiKey: Boolean(config.pi.apiKey),
+    hasStoredAuth: hasProviderAuth(config.pi.provider, runtime),
+    supportsOAuth: supportsProviderOAuth(config.pi.provider, runtime)
+  };
+}
+
+export function buildPiAuthTelegramMessage({ config, issue = null, verified = false }) {
+  const status = getPiAuthStatus(config);
+  let title = `Pi authentication status for ${status.provider}/${status.model}.`;
+  if (issue) {
+    title = `Pi authentication needs attention for ${status.provider}/${status.model}.`;
+  } else if (verified) {
+    title = `Pi authentication is working for ${status.provider}/${status.model}.`;
+  }
+  const lines = [title];
+
+  if (issue?.kind === "invalidated-token") {
+    lines.push("The provider says the current authentication token was invalidated.");
+  } else if (issue?.kind === "missing-auth") {
+    lines.push("Arisa could not find usable authentication for this provider.");
+  } else if (issue?.kind === "validation-failed") {
+    lines.push("Arisa could not validate the current Pi authentication.");
+  } else if (verified) {
+    lines.push(status.hasApiKey
+      ? "The configured Pi API key was accepted by the provider."
+      : "The stored auth was accepted by the provider.");
+  } else {
+    lines.push(`Stored auth record: ${status.hasStoredAuth ? "detected" : "not detected"}.`);
+    lines.push("This only checks whether credentials are stored, not whether the provider will accept them.");
+  }
+
+  if (issue?.message) {
+    lines.push(`Details: ${issue.message}`);
+  }
+
+  if (verified) {
+    lines.push("No action needed.");
+  } else if (!issue) {
+    lines.push("Run `/auth` to validate these credentials against the provider.");
+  } else if (status.hasApiKey) {
+    lines.push("A Pi API key is configured, but the provider rejected the current request. Update the key and restart Arisa.");
+  } else if (status.supportsOAuth) {
+    lines.push("For now, re-run `arisa --bootstrap` on the host and complete Pi login again.");
+  } else {
+    lines.push("This provider needs a Pi API key. Re-run `arisa --bootstrap`, provide a key, and restart Arisa.");
+  }
+
+  if (issue) {
+    lines.push("Telegram-based renewal is not wired yet, but this /auth path is ready for that flow.");
+  }
+  return lines.join("\n");
+}

package/src/runtime/create-app.js

@@ -64,7 +64,12 @@ export async function createApp({ logger, runtimeOverrides, webhookUrl, setHttpR
   return {
     async start() {
       logger?.log("app", `validating Pi model ${config.pi.provider}/${config.pi.model}`);
-      await agentManager.validatePiAgent();
+      try {
+        await agentManager.validatePiAgent();
+      } catch (error) {
+        await bot.notifyPiAuthIssue?.(error);
+        throw error;
+      }
       await toolProcessSupervisor.start();
       logger?.log("app", "starting Telegram bot");
       try {

package/src/transport/telegram/bot.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { authorizeChat } from "./auth.js";
 import { captureIncomingArtifact } from "./media.js";
 import { renderTelegramHtml } from "./text-format.js";
+import { buildPiAuthTelegramMessage, getErrorMessage, getPiAuthIssue } from "../../core/agent/auth-flow.js";
 import { normalizeArtifactForReasoning, shouldNormalizeArtifactToText } from "../../core/artifacts/normalize-for-reasoning.js";
 
 const slowPromptNoticeMs = 300_000;
@@ -185,6 +186,7 @@ function sessionEventLogMessage(event) {
 
 async function collectText(session, prompt, { logger, chatId, onSlowPrompt } = {}) {
   let text = "";
+  let assistantErrorMessage = "";
   let shouldSeparateAssistantMessage = false;
   let slowPromptTimer = null;
   const unsubscribe = session.subscribe((event) => {
@@ -198,6 +200,9 @@ async function collectText(session, prompt, { logger, chatId, onSlowPrompt } = {
       }
       text += event.assistantMessageEvent.delta;
     }
+    if (event.type === "message_end" && event.message?.stopReason === "error") {
+      assistantErrorMessage = event.message.errorMessage || "assistant message ended with error";
+    }
     const logMessage = sessionEventLogMessage(event);
     if (logMessage) logger?.log("agent", `chat ${chatId} ${logMessage}`);
   });
@@ -218,6 +223,10 @@ async function collectText(session, prompt, { logger, chatId, onSlowPrompt } = {
     unsubscribe();
   }
 
+  if (assistantErrorMessage) {
+    throw new Error(assistantErrorMessage);
+  }
+
   return text.trim();
 }
 
@@ -237,8 +246,31 @@ 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();
+  const notifiedPromptErrors = new WeakSet();
   let taskTimer = null;
 
+  function wasPromptErrorNotified(error) {
+    return error instanceof Error && notifiedPromptErrors.has(error);
+  }
+
+  function markPromptErrorNotified(error) {
+    if (error instanceof Error) notifiedPromptErrors.add(error);
+  }
+
+  async function notifyPiAuthIssueIfNeeded(chatId, error) {
+    const issue = getPiAuthIssue(error);
+    if (!issue) return false;
+
+    try {
+      await bot.api.sendMessage(chatId, buildPiAuthTelegramMessage({ config, issue }));
+      markPromptErrorNotified(error);
+      return true;
+    } catch (notifyError) {
+      logger?.error("telegram", `auth issue notice failed for chat ${chatId}: ${getErrorMessage(notifyError)}`);
+      return false;
+    }
+  }
+
   function getIncomingChatMeta(ctx) {
     return {
       languageCode: ctx.from?.language_code || "",
@@ -358,8 +390,9 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
           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);
+          const message = getErrorMessage(error);
           logger?.error("telegram", `${label} failed for chat ${chatId}: ${message}`);
+          await notifyPiAuthIssueIfNeeded(chatId, error);
           throw error;
         } finally {
           currentCtx = null;
@@ -493,6 +526,20 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     await handleNewCommand(ctx);
   });
 
+  bot.command("auth", async (ctx) => {
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
+    if (!auth.ok) return;
+    await withTyping(ctx, async () => {
+      try {
+        await agentManager.validatePiAgent();
+        await ctx.reply(buildPiAuthTelegramMessage({ config, verified: true }));
+      } catch (error) {
+        const issue = getPiAuthIssue(error) || { kind: "validation-failed", message: getErrorMessage(error) };
+        await ctx.reply(buildPiAuthTelegramMessage({ config, issue }));
+      }
+    });
+  });
+
   bot.on("message", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
@@ -505,8 +552,11 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
     } catch (error) {
       const chatState = getChatState(ctx.chat.id);
       chatState.processing = false;
-      const message = error instanceof Error ? error.message : String(error);
-      await ctx.reply(message);
+      if (wasPromptErrorNotified(error)) return;
+      const issue = getPiAuthIssue(error);
+      await ctx.reply(issue
+        ? buildPiAuthTelegramMessage({ config, issue })
+        : getErrorMessage(error));
     }
   });
 
@@ -534,7 +584,8 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
         }
       }
       await bot.api.setMyCommands([
-        { command: "new", description: "Start a new chat context" }
+        { command: "new", description: "Start a new chat context" },
+        { command: "auth", description: "Show Pi authentication status" }
       ]);
       if (!taskTimer) {
         taskTimer = setInterval(() => {
@@ -572,6 +623,14 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
       try {
         bot.stop();
       } catch {}
+    },
+
+    async notifyPiAuthIssue(error) {
+      let notified = false;
+      for (const chatId of config.telegram.authorizedChatIds || []) {
+        notified = await notifyPiAuthIssueIfNeeded(chatId, error) || notified;
+      }
+      return notified;
     }
   };
 }