arisa 3.2.2 → 4.0.2

package/AGENTS.md

@@ -6,6 +6,7 @@
 - Incoming messages and files (text, voice, photo, document) and generated files become artifacts.
 - A tool registry handles tool discovery, help lookup, config writes, and execution.
 - Tools are isolated and each one has its own manifest, entrypoint, and config defaults.
+- No tools ship with the core. All installed tools live under `~/.arisa/tools/<toolName>`; the install directory of Arisa (your working directory) contains only the core. Never create or install tools inside the install directory.
 
 ## Runtime directory rules
 Do not build runtime paths by hand. Use `src/runtime/paths.js`:
@@ -56,6 +57,11 @@ Not every pipe should be decided by Pi Agent at runtime. Some pipes are part of
 If inbound media was normalized before reasoning, Pi Agent should use the normalized result as the actual message content.
 For example, if a voice note was transcribed, Pi Agent should answer the meaning of the transcript, not simply return the raw transcript unless the user explicitly asked for transcription.
 
+## Telegram outbound replies
+- Short textual replies are sent inline as a normal Telegram message.
+- When a textual reply is too large to read comfortably inline, it is delivered as a generated Markdown artifact instead of a long inline message. The transport handles this automatically in `sendTextReply`: replies over the inline length limit become a `reply-<timestamp>.md` artifact sent as a document.
+- This is a transport-layer concern. Pi Agent should write the full answer it wants to deliver and not pre-split or truncate it to fit the chat; the transport decides between inline text and a Markdown attachment.
+
 ## How to inspect CLI tools
 Before using a tool, inspect its help:
 - via the custom tool: `tool_help`
@@ -66,7 +72,7 @@ Every CLI must support (the entrypoint comes from `manifest.entry`, currently al
 - `node index.js run --request-file <json>`
 
 ### Tools that need daemons
-A future tool may need a persistent process, for example to keep a browser session alive or a local model warm. The shared daemon runtime exists for this, but no bundled tool uses it yet.
+A tool may need a persistent process, for example to keep a browser session alive or a local model warm. The shared daemon runtime exists for this (the `whispermix-transcribe` catalog tool uses it).
 When such a tool is built, implement it with the shared daemon runtime instead of custom ad hoc process management:
 - use `src/core/tools/daemon-runtime.js`
 - keep runtime files under the tool state directory (`~/.arisa/state/tools/<toolName>`)
@@ -98,7 +104,7 @@ Beyond time-based scheduling, tools can drive an event queue that wakes the agen
 
 Tasks without a `runAt` fire immediately, so `agent_event` and the first `poll_tool` run on the next tick.
 
-The poller dispatches all three kinds, but only `agent_task` is exercised by a bundled tool today (`schedule-agent-task`). The following is the pattern to follow when a checker tool is built:
+The poller dispatches all three kinds, but only `agent_task` is exercised by a catalog tool today (`schedule-agent-task`). The following is the pattern to follow when a checker tool is built:
 
 How a tool wires its own polling:
 1. From any tool `run`, start the poll by returning an `asyncTask` (or several in `asyncTasks`):
@@ -118,23 +124,45 @@ If `run_tool` returns `missingConfig`, the agent should:
 
 Do not assume a rigid question/answer protocol. Continue the conversation naturally and infer the config value from the user reply when possible.
 
+## Official tool catalog
+The official tool catalog lives at `https://github.com/clasen/Arisa/tree/main/tools`. Each subdirectory is an installable tool following the standard tool contract.
+
+When a capability is missing, check the catalog before building anything:
+1. List the catalog: `curl -s https://api.github.com/repos/clasen/Arisa/contents/tools`.
+2. Read the manifest of any candidate: `https://raw.githubusercontent.com/clasen/Arisa/main/tools/<name>/tool.manifest.json` (the `description`, `input`, and `output` fields tell you whether it solves the need). Also read the catalog `README.md` to check the tool's install footprint.
+3. If a catalog tool solves the problem, decide by install footprint (the `Install footprint` column in the catalog `README.md`):
+   - **Low footprint** (no extra npm dependencies, no external binaries): install it and resolve the user's request in the same turn, without asking first. Favor autonomy here.
+   - **Medium/High footprint** (heavy dependency trees, external binaries, or interactive setup such as a login): propose it to the user, say which tool it is and what it does, and wait for their confirmation in the chat before installing.
+   - A missing config secret (for example an API key) is handled by the missing-config flow and is not, on its own, a reason to ask before installing.
+4. Only when nothing in the catalog fits, fall back to creating a new tool.
+
+### Installing a tool
+After deciding to install (low footprint), after the user confirms, or when the user directly asks to install a tool from any source they choose:
+1. Download the tool directory into `~/.arisa/tools/<name>`. For the official catalog, clone shallowly and copy the subdirectory, for example:
+   `git clone --depth 1 https://github.com/clasen/Arisa /tmp/arisa-catalog && cp -R /tmp/arisa-catalog/tools/<name> ~/.arisa/tools/<name>`.
+2. Install dependencies inside the tool directory (`pnpm install`, fall back to `npm install`).
+3. Run it through `run_tool`; the registry picks up new tools automatically and exposes the Arisa package root through `ARISA_PACKAGE_DIR`. If it returns `missingConfig`, follow the missing config flow.
+
 ## Tool creation
 Reason in terms of capabilities, not tool names.
 
 When the user asks for something new:
 1. check whether an existing registered tool can already satisfy the task
 2. also check whether the task can be satisfied indirectly through an existing capability
-3. only propose creating a new tool when the needed capability is truly missing
+3. check whether a tool in the official catalog satisfies the task and propose installing it
+4. only propose creating a new tool when the needed capability is truly missing
 
 Do not stop at "I cannot do that" when the task is realistically implementable through the tool architecture.
 The default attitude is:
 - identify that no current tool satisfies the request
 - state that the missing capability can be added
-- propose or start creating the needed tool
+- propose installing from the official catalog, or propose or start creating the needed tool
 
 When creating or editing tools:
+- always create tools under `~/.arisa/tools/<toolName>`, never inside the Arisa install directory
 - use the path helpers in `src/runtime/paths.js`
-- follow the existing bundled tools under `tools/` as the reference pattern for new tools
+- import Arisa core helpers dynamically through `ARISA_PACKAGE_DIR` (for example `await importCore("core/tools/tool-result.js")`); never use `../../src/...` or rewritten absolute paths
+- follow the tools in the official catalog as the reference pattern for new tools
 - keep all help text, usage instructions, manifests, and user-facing operational strings in English
 - follow the One Thing Rule: each function or method should do one thing well; if it mixes low-level operations with high-level policy, split it into smaller focused units
 
@@ -158,7 +186,6 @@ Tool dependencies are installed as part of building or running the tool, not del
 - Do not ask the user to do it manually.
 
 ## Safety
-- Do not install or run arbitrary tools outside registered tool manifests in V1.
 - Prefer tool manifests and CLI help over assumptions.
 - Keep tool config and runtime data inside the user runtime area.
 - Be proactive about extending capabilities, but do it through the project's tool architecture, not through ad hoc one-off behavior.

package/README.md

@@ -4,7 +4,7 @@
 
 ## Origin
 
-The initial inspiration was OpenClaw, which has interesting ideas but carries a lot of weight (about **185 MB**) compared to Arisa (**76.7 kB**): when it generates tools they end up disorganized, and the overall framework feels overloaded.
+The initial inspiration was OpenClaw, which has interesting ideas but carries a lot of weight (about **85 MB**, **55 dependencies**) compared to Arisa (**37 kB**, **3 dependencies**): when it generates tools they end up disorganized, and the overall framework feels overloaded.
 
 The real heart of OpenClaw is Pi Agent: a [minimal terminal coding harness](https://www.youtube.com/watch?v=Dli5slNaJu0) that lets an AI agent reason and act with very little infrastructure. That part is genuinely good.
 
@@ -38,15 +38,31 @@ Arisa separates two different kinds of pipes:
 
 This distinction is important. Some transformations belong to the transport/input layer, not to the agent's runtime decision making.
 
+## Zero tools, assembled on demand
+
+A fresh install ships with **zero tools**. The core is only Telegram transport, the Pi Agent reasoning loop, the artifact store, and the tool registry. Out of the box Arisa cannot transcribe audio, browse the web, or speak; it gains each capability only once a tool that provides it is installed.
+
+Arisa assembles its own toolset from real use:
+
+1. A request arrives that the current tools cannot satisfy.
+2. Arisa checks the [official catalog](https://github.com/clasen/Arisa/tree/main/tools) for a tool that fits the need.
+3. If one fits, it installs it: autonomously for low-footprint tools, or after asking you to confirm for heavier ones (extra dependencies, external binaries, or interactive setup such as a login).
+4. If nothing fits, it builds a new tool for the missing capability.
+5. The installed tool stays in `~/.arisa/tools/` and is reused from then on.
+
+The result is a toolset shaped by how you actually use the assistant, not by defaults someone else chose. Two people running the same Arisa build can end up with completely different capabilities.
+
 ## Current behavior
 
 ### Telegram input
 - text messages go directly to Pi Agent
-- audio/voice messages are transcribed first, then passed to Pi Agent as text
+- audio/voice messages are transcribed first when a transcription tool is installed, then passed to Pi Agent as text; otherwise Arisa offers to install one
 - media is stored as artifacts
 
 ### Tool model
-Bundled tools live under `<arisa-install-dir>/tools/<tool-name>` and user-created tools live under `~/.arisa/tools/<tool-name>`.
+No tools ship with the core. All installed tools live under `~/.arisa/tools/<tool-name>`, whether they come from the [official catalog](https://github.com/clasen/Arisa/tree/main/tools), from another source the user chooses, or are created by the agent itself.
+
+When the agent needs a capability it does not have, it checks the official catalog first. Low-footprint tools (no extra dependencies) are installed on the spot so the request is resolved in the same turn; heavier tools (extra dependencies, external binaries, or interactive setup) are proposed for you to confirm before anything is installed.
 
 Each tool folder contains:
 
@@ -59,8 +75,7 @@ Each tool is isolated from the root project and from other tools.
 That isolation is part of the architecture:
 
 - each tool has its own folder
-- bundled tools have a local `config.js` for defaults/template values
-- user-created tools can live entirely inside `~/.arisa/tools/<tool>/`
+- each tool has a local `config.js` for defaults/template values
 - each tool can have its own dependencies
 - one tool can be changed or replaced without tightly coupling the rest of the system
 
@@ -97,8 +112,6 @@ arisa start              # start in background
 arisa stop               # stop background service
 arisa status             # show background service status
 arisa flush              # remove ~/.arisa
-arisa install <source>   # install a Pi package into Arisa's runtime
-arisa remove <source>    # remove a Pi package from Arisa's runtime
 ```
 
 Runtime model override (current process only):
@@ -111,17 +124,6 @@ Notes:
 
 - it only affects the current Arisa process and does not update `~/.arisa/state/config.json`
 
-## Experimental features
-
-### Pi Agent packages
-
-Arisa can install **Pi Agent packages** from the public registry into your user runtime (`~/.arisa/`), using the same package manager as Pi Agent. Browse and discover packages at [pi.dev/packages](https://pi.dev/packages).
-
-- `arisa install <source>` installs a package (by registry name or other source supported by Pi).
-- `arisa remove <source>` removes a previously installed package.
-
-Treat this as **experimental**: the registry, package formats, and install behavior follow Pi Agent and may change. Not every listed package is tailored to Arisa’s Telegram transport and artifact-based tools; prefer packages you understand and verify after install.
-
 ## Bootstrap flow
 
 On first run, Arisa will:
@@ -203,16 +205,15 @@ src/
   runtime/      bootstrap + app startup
   transport/    Telegram integration
   core/         agent, tools, artifacts, config
-tools/
-  openai-transcribe/
-  openai-tts/
 ~/.arisa/
   state/
   artifacts/
-  tools/
+  tools/        installed tools (catalog, user-chosen, or agent-created)
   tmp/
 ```
 
+The official tool catalog lives in the repository under [`tools/`](https://github.com/clasen/Arisa/tree/main/tools) and is not part of the npm package.
+
 ## Philosophy
 
 The agent should not come preloaded with vices or assumptions. It starts minimal and grows through real use: shaped by the user, not by the framework.
@@ -221,9 +222,10 @@ For consistency, the entire Arisa codebase was built using Pi Agent itself, runn
 
 When a capability is missing:
 
-1. check whether an existing tool can solve the task
-2. if not, build the missing tool
-3. keep the solution inside the tool architecture
+1. check whether an installed tool can solve the task
+2. if not, check the official catalog and propose installing the matching tool
+3. if nothing fits, build the missing tool
+4. keep the solution inside the tool architecture
 
 No "I can't do that" when the thing is realistically buildable.
 
@@ -235,14 +237,15 @@ No "I can't do that" when the thing is realistically buildable.
 
 ## Status
 
-This is currently a functional V1 focused on:
+This is currently a functional V1. The core provides:
 
 - Telegram transport
 - Pi Agent integration
 - artifact-based message handling
-- isolated CLI tools
-- audio transcription before reasoning
-- text-to-speech replies
+- the isolated CLI tool registry (starts empty)
+- pre-reasoning and post-reasoning pipes
 - queued follow-up message batching
 
+Concrete capabilities such as audio transcription or text-to-speech are not built in; they are added as tools from the catalog (or built on demand) when a request needs them.
+
 Future capabilities should be added as new tools and pipes, not as tightly coupled one-off code paths.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "3.2.2",
+  "version": "4.0.2",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",
@@ -28,6 +28,14 @@
   ],
   "author": "Martin Clasen",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/clasen/Arisa.git"
+  },
+  "bugs": {
+    "url": "https://github.com/clasen/Arisa/issues"
+  },
+  "homepage": "https://github.com/clasen/Arisa#readme",
   "dependencies": {
     "@mariozechner/pi-coding-agent": "^0.73.1",
     "@sinclair/typebox": "^0.34.41",

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

@@ -0,0 +1,79 @@
+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 }) {
+  const status = getPiAuthStatus(config);
+  const lines = [
+    issue
+      ? `Pi authentication needs attention for ${status.provider}/${status.model}.`
+      : `Pi authentication status for ${status.provider}/${status.model}.`
+  ];
+
+  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 {
+    lines.push(`Stored auth: ${status.hasStoredAuth ? "detected" : "not detected"}.`);
+  }
+
+  if (issue?.message) {
+    lines.push(`Details: ${issue.message}`);
+  }
+
+  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.");
+  }
+
+  lines.push("Telegram-based renewal is not wired yet, but this /auth path is ready for that flow.");
+  return lines.join("\n");
+}

package/src/core/agent/runtime-context.js

@@ -2,13 +2,11 @@ import { fileURLToPath } from "node:url";
 import { arisaHomeDir, chatsDir, stateDir, toolStateDir, toolsDir } from "../../runtime/paths.js";
 
 export const arisaInstallDir = fileURLToPath(new URL("../../..", import.meta.url));
-export const bundledToolsDir = fileURLToPath(new URL("../../../tools", import.meta.url));
 
 export function buildAgentRuntimeContext() {
   return [
     `arisaHomeDir: ${arisaHomeDir}`,
     `arisaInstallDir: ${arisaInstallDir}`,
-    `bundledToolsDir: ${bundledToolsDir}`,
     `userToolsDir: ${toolsDir}`,
     `toolStateDir: ${toolStateDir}`,
     `chatsDir: ${chatsDir}`,

package/src/core/tools/tool-registry.js

@@ -1,17 +1,14 @@
 import { mkdir, readdir, readFile, rmdir, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { spawn } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { getToolConfigPath, getToolTmpDir, getChatToolTmpDir, toolsDir as userToolsRoot } from "../../runtime/paths.js";
+import { arisaPackageDir, getToolConfigPath, getToolTmpDir, getChatToolTmpDir, toolsDir as userToolsRoot } from "../../runtime/paths.js";
 import { loadToolConfig, parseConfigModule, writeToolConfig } from "./tool-config.js";
 import { normalizeToolResult } from "./tool-result.js";
 import { SkillRegistry } from "../skills/skill-registry.js";
 
-const bundledToolsRoot = fileURLToPath(new URL("../../../tools", import.meta.url));
-const toolRoots = [
-  { root: userToolsRoot, kind: "user" },
-  { root: bundledToolsRoot, kind: "bundled" }
-];
+function toolEnv() {
+  return { ...process.env, ARISA_PACKAGE_DIR: arisaPackageDir };
+}
 
 function runProcess(command, args, options = {}) {
   return new Promise((resolve) => {
@@ -34,41 +31,37 @@ export class ToolRegistry {
   async load() {
     this.tools.clear();
 
-    for (const { root, kind } of toolRoots) {
-      let entries = [];
+    let entries = [];
+    try {
+      entries = await readdir(userToolsRoot, { withFileTypes: true });
+    } catch {
+      this.logger?.log("tools", `tools directory not found: ${userToolsRoot}`);
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const toolDir = path.join(userToolsRoot, entry.name);
+      const manifestPath = path.join(toolDir, "tool.manifest.json");
+      const configPath = path.join(toolDir, "config.js");
       try {
-        entries = await readdir(root, { withFileTypes: true });
+        const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+        if (this.tools.has(manifest.name)) continue;
+        const configSource = await readFile(configPath, "utf8");
+        const defaults = parseConfigModule(configSource);
+        const config = await loadToolConfig(manifest.name, defaults);
+        const skillHints = this.skillRegistry.normalizeHints(manifest);
+        this.tools.set(manifest.name, {
+          ...manifest,
+          skillHints,
+          dir: toolDir,
+          entry: path.join(toolDir, manifest.entry || "index.js"),
+          localConfigPath: configPath,
+          configPath: getToolConfigPath(manifest.name),
+          defaults,
+          config
+        });
       } catch {
-        this.logger?.log("tools", `${kind} tools directory not found: ${root}`);
-        continue;
-      }
-
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        const toolDir = path.join(root, entry.name);
-        const manifestPath = path.join(toolDir, "tool.manifest.json");
-        const configPath = path.join(toolDir, "config.js");
-        try {
-          const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
-          if (this.tools.has(manifest.name)) continue;
-          const configSource = await readFile(configPath, "utf8");
-          const defaults = parseConfigModule(configSource);
-          const config = await loadToolConfig(manifest.name, defaults);
-          const skillHints = this.skillRegistry.normalizeHints(manifest);
-          this.tools.set(manifest.name, {
-            ...manifest,
-            skillHints,
-            dir: toolDir,
-            entry: path.join(toolDir, manifest.entry || "index.js"),
-            localConfigPath: configPath,
-            configPath: getToolConfigPath(manifest.name),
-            defaults,
-            config,
-            sourceKind: kind
-          });
-        } catch {
-          // ignore invalid tool dirs in v1
-        }
+        // ignore invalid tool dirs in v1
       }
     }
 
@@ -93,7 +86,7 @@ export class ToolRegistry {
   async help(name) {
     const tool = this.get(name);
     if (!tool) throw new Error(`Tool not found: ${name}`);
-    const result = await runProcess("node", [tool.entry, "--help"], { cwd: tool.dir, env: process.env });
+    const result = await runProcess("node", [tool.entry, "--help"], { cwd: tool.dir, env: toolEnv() });
     const help = result.stdout || result.stderr;
     const skills = await this.resolveSkills(name);
     if (!skills.length) return help;
@@ -153,7 +146,7 @@ export class ToolRegistry {
     await writeFile(requestFile, `${JSON.stringify(enrichedRequest, null, 2)}\n`, "utf8");
     const result = await runProcess("node", [tool.entry, "run", "--request-file", requestFile], {
       cwd: tool.dir,
-      env: process.env
+      env: toolEnv()
     });
     await unlink(requestFile).catch(() => {});
     await rmdir(tmpDir).catch(() => {});

package/src/index.js

@@ -6,7 +6,9 @@ import { createApp } from "./runtime/create-app.js";
 import { createLogger } from "./runtime/logger.js";
 import { getServiceStatus, registerServiceProcess, startService, stopService, unregisterServiceProcess } from "./runtime/service-manager.js";
 import { flushArisaHome } from "./runtime/flush.js";
-import { installPiPackage, removePiPackage } from "./runtime/pi-package-manager.js";
+import { arisaPackageDir } from "./runtime/paths.js";
+
+process.env.ARISA_PACKAGE_DIR = arisaPackageDir;
 
 const args = process.argv.slice(2);
 const cli = parseCliArgs(args);
@@ -208,28 +210,6 @@ async function main() {
     return;
   }
 
-  if (command === "install") {
-    const source = cli.positionals[1];
-    if (!source) {
-      console.log("Usage: arisa install <pi-package-source>");
-      return;
-    }
-    const result = await installPiPackage(source);
-    process.exitCode = result.ok ? 0 : result.code;
-    return;
-  }
-
-  if (command === "remove") {
-    const source = cli.positionals[1];
-    if (!source) {
-      console.log("Usage: arisa remove <pi-package-source>");
-      return;
-    }
-    const result = await removePiPackage(source);
-    process.exitCode = result.ok ? 0 : result.code;
-    return;
-  }
-
   await runForeground();
 }
 

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/runtime/paths.js

@@ -1,7 +1,9 @@
 import { mkdir } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 
+export const arisaPackageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
 export const arisaHomeDir = path.join(os.homedir(), ".arisa");
 export const stateDir = path.join(arisaHomeDir, "state");
 export const configFile = path.join(stateDir, "config.json");

package/src/transport/telegram/bot.js

@@ -3,10 +3,10 @@ import path from "node:path";
 import { authorizeChat } from "./auth.js";
 import { captureIncomingArtifact } from "./media.js";
 import { renderTelegramHtml } from "./text-format.js";
-import { withTimeout } from "../../core/agent/prompt-timeout.js";
+import { buildPiAuthTelegramMessage, getErrorMessage, getPiAuthIssue } from "../../core/agent/auth-flow.js";
 import { normalizeArtifactForReasoning, shouldNormalizeArtifactToText } from "../../core/artifacts/normalize-for-reasoning.js";
 
-const promptTimeoutMs = 300_000;
+const slowPromptNoticeMs = 300_000;
 
 function quotedMessageSummary(message) {
   if (!message) return [];
@@ -184,9 +184,11 @@ function sessionEventLogMessage(event) {
   return "";
 }
 
-async function collectText(session, prompt, { logger, chatId } = {}) {
+async function collectText(session, prompt, { logger, chatId, onSlowPrompt } = {}) {
   let text = "";
+  let assistantErrorMessage = "";
   let shouldSeparateAssistantMessage = false;
+  let slowPromptTimer = null;
   const unsubscribe = session.subscribe((event) => {
     if (event.type === "message_start" && event.message.role === "assistant") {
       shouldSeparateAssistantMessage = text.trim().length > 0;
@@ -198,19 +200,33 @@ async function collectText(session, prompt, { logger, chatId } = {}) {
       }
       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}`);
   });
 
+  if (onSlowPrompt) {
+    slowPromptTimer = setTimeout(() => {
+      logger?.log("telegram", `prompt for chat ${chatId} is still running after ${slowPromptNoticeMs}ms`);
+      onSlowPrompt().catch((error) => {
+        logger?.error("telegram", `slow prompt notice failed for chat ${chatId}: ${error instanceof Error ? error.message : String(error)}`);
+      });
+    }, slowPromptNoticeMs);
+  }
+
   try {
-    await withTimeout(session.prompt(prompt), {
-      timeoutMs: promptTimeoutMs,
-      label: `Telegram prompt for chat ${chatId}`
-    });
+    await session.prompt(prompt);
   } finally {
+    if (slowPromptTimer) clearTimeout(slowPromptTimer);
     unsubscribe();
   }
 
+  if (assistantErrorMessage) {
+    throw new Error(assistantErrorMessage);
+  }
+
   return text.trim();
 }
 
@@ -230,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 || "",
@@ -303,7 +342,14 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
       const { session } = await agentManager.getSessionContext(chatId, createTelegramSessionBridge(chatId));
       let text = "";
       try {
-        text = await collectText(session, prompt, { logger, chatId });
+        text = await collectText(session, prompt, {
+          logger,
+          chatId,
+          onSlowPrompt: () => bot.api.sendMessage(
+            chatId,
+            "This is taking longer than 5 minutes, so I will keep the current session running instead of starting over. Send /new if you want to abandon it and start fresh."
+          )
+        });
       } catch (error) {
         agentManager.resetSession(chatId);
         throw error;
@@ -344,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;
@@ -479,6 +526,12 @@ 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 ctx.reply(buildPiAuthTelegramMessage({ config }));
+  });
+
   bot.on("message", async (ctx) => {
     const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig, chatMeta: getIncomingChatMeta(ctx) });
     if (!auth.ok) return;
@@ -491,8 +544,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));
     }
   });
 
@@ -520,7 +576,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(() => {
@@ -558,6 +615,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;
     }
   };
 }

package/src/runtime/pi-package-manager.js

@@ -1,49 +0,0 @@
-import { DefaultPackageManager, SettingsManager } from "@mariozechner/pi-coding-agent";
-import { arisaHomeDir } from "./paths.js";
-
-function createPackageManager() {
-  const settingsManager = SettingsManager.create(arisaHomeDir, arisaHomeDir);
-  const packageManager = new DefaultPackageManager({
-    cwd: arisaHomeDir,
-    agentDir: arisaHomeDir,
-    settingsManager
-  });
-
-  packageManager.setProgressCallback((event) => {
-    if (event.type === "start") {
-      process.stdout.write(`${event.message}\n`);
-    }
-  });
-
-  return packageManager;
-}
-
-export async function installPiPackage(source) {
-  const packageManager = createPackageManager();
-
-  try {
-    await packageManager.installAndPersist(source, { local: false });
-    console.log(`Installed ${source}`);
-    return { ok: true, code: 0 };
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error));
-    return { ok: false, code: 1 };
-  }
-}
-
-export async function removePiPackage(source) {
-  const packageManager = createPackageManager();
-
-  try {
-    const removed = await packageManager.removeAndPersist(source, { local: false });
-    if (!removed) {
-      console.error(`No matching package found for ${source}`);
-      return { ok: false, code: 1 };
-    }
-    console.log(`Removed ${source}`);
-    return { ok: true, code: 0 };
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error));
-    return { ok: false, code: 1 };
-  }
-}

package/tools/openai-transcribe/config.js

@@ -1,4 +0,0 @@
-export default {
-  OPENAI_API_KEY: "",
-  MODEL: "gpt-4o-mini-transcribe"
-};

package/tools/openai-transcribe/index.js

@@ -1,108 +0,0 @@
-import path from "node:path";
-import { readFile, stat } from "node:fs/promises";
-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 } from "../../src/runtime/paths.js";
-
-const toolName = "openai-transcribe";
-const config = await loadToolConfig(toolName, defaults);
-
-const supportedUploadExtensions = new Set([
-  ".flac",
-  ".m4a",
-  ".mp3",
-  ".mp4",
-  ".mpeg",
-  ".mpga",
-  ".ogg",
-  ".wav",
-  ".webm"
-]);
-
-const mimeUploadExtensions = new Map([
-  ["audio/aac", ".m4a"],
-  ["audio/flac", ".flac"],
-  ["audio/m4a", ".m4a"],
-  ["audio/mp3", ".mp3"],
-  ["audio/mp4", ".m4a"],
-  ["audio/mpeg", ".mp3"],
-  ["audio/mpga", ".mpga"],
-  ["audio/ogg", ".ogg"],
-  ["audio/opus", ".ogg"],
-  ["audio/wav", ".wav"],
-  ["audio/wave", ".wav"],
-  ["audio/webm", ".webm"],
-  ["audio/x-m4a", ".m4a"],
-  ["audio/x-wav", ".wav"],
-  ["video/mp4", ".mp4"],
-  ["video/webm", ".webm"]
-]);
-
-function baseMimeType(mimeType = "") {
-  return mimeType.split(";")[0].trim().toLowerCase();
-}
-
-function uploadFileNameForArtifact(artifact) {
-  const currentName = path.basename(artifact.path);
-  const currentExtension = path.extname(currentName).toLowerCase();
-  if (supportedUploadExtensions.has(currentExtension)) return currentName;
-
-  const extension = mimeUploadExtensions.get(baseMimeType(artifact.mimeType));
-  if (!extension) return currentName;
-
-  const parsed = path.parse(currentName);
-  return `${parsed.name || "audio"}${extension}`;
-}
-
-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/media.ogg", "mimeType": "audio/ogg" },\n    "args": {}\n  }\n\nSupported upload formats include flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, and webm.\n\nConfig at ${getToolConfigPath(toolName)}:\n  OPENAI_API_KEY\n  MODEL\n`);
-}
-
-async function run(requestFile) {
-  if (!config.OPENAI_API_KEY) {
-    console.log(JSON.stringify(toolNeedsConfig({
-      tool: toolName,
-      missingConfig: ["OPENAI_API_KEY"],
-      configPath: getToolConfigPath(toolName)
-    })));
-    return;
-  }
-
-  const request = JSON.parse(await readFile(requestFile, "utf8"));
-  const artifact = request.artifact;
-  if (!artifact?.path) {
-    console.log(JSON.stringify(toolError("artifact.path is required")));
-    return;
-  }
-
-  await stat(artifact.path);
-  const form = new FormData();
-  const data = await readFile(artifact.path);
-  form.append("file", new Blob([data], { type: baseMimeType(artifact.mimeType) || "application/octet-stream" }), uploadFileNameForArtifact(artifact));
-  form.append("model", config.MODEL);
-
-  const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
-    method: "POST",
-    headers: { Authorization: `Bearer ${config.OPENAI_API_KEY}` },
-    body: form
-  });
-
-  const payload = await response.json();
-  if (!response.ok) {
-    console.log(JSON.stringify(toolError(payload.error?.message || "OpenAI transcription failed")));
-    return;
-  }
-
-  console.log(JSON.stringify(toolOk({ text: payload.text || "" })));
-}
-
-const args = process.argv.slice(2);
-if (!args.length || args.includes("--help") || args[0] === "help") {
-  printHelp();
-} else if (args[0] === "run") {
-  const fileIndex = args.indexOf("--request-file");
-  await run(args[fileIndex + 1]);
-} else {
-  printHelp();
-}

package/tools/openai-transcribe/package.json

@@ -1,6 +0,0 @@
-{
-  "name": "openai-transcribe-cli",
-  "private": true,
-  "type": "module",
-  "version": "1.0.0"
-}

package/tools/openai-transcribe/tool.manifest.json

@@ -1,32 +0,0 @@
-{
-  "name": "openai-transcribe",
-  "description": "Transcribe audio files and video audio tracks with OpenAI audio transcription API.",
-  "entry": "index.js",
-  "input": [
-    "audio/aac",
-    "audio/flac",
-    "audio/m4a",
-    "audio/mp3",
-    "audio/mp4",
-    "audio/mpeg",
-    "audio/mpga",
-    "audio/ogg",
-    "audio/opus",
-    "audio/wav",
-    "audio/wave",
-    "audio/webm",
-    "audio/x-m4a",
-    "audio/x-wav",
-    "video/mp4",
-    "video/webm"
-  ],
-  "output": ["text/plain"],
-  "configSchema": {
-    "OPENAI_API_KEY": {
-      "type": "string",
-      "required": true,
-      "secret": true,
-      "prompt": "I need your OPENAI_API_KEY to transcribe audio."
-    }
-  }
-}

package/tools/openai-tts/config.js

@@ -1,5 +0,0 @@
-export default {
-  OPENAI_API_KEY: "",
-  MODEL: "gpt-4o-mini-tts",
-  VOICE: "alloy"
-};

package/tools/openai-tts/index.js

@@ -1,76 +0,0 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
-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 { getChatToolTmpDir, getToolConfigPath, getToolTmpDir } from "../../src/runtime/paths.js";
-
-const toolName = "openai-tts";
-const config = await loadToolConfig(toolName, defaults);
-
-function printHelp() {
-  console.log(`openai-tts\n\nUsage:\n  node index.js --help\n  node index.js run --request-file <json>\n\nExpected input:\n  {\n    \"text\": \"hello\",\n    \"artifact\": { \"text\": \"hello\" },\n    \"args\": { \"voice\": \"alloy\" }\n  }\n\nOutput:\n  - generates OGG/Opus audio\n  - suggests Telegram voice-note delivery via output.delivery.method = \"voice\"\n\nConfig at ${getToolConfigPath(toolName)}:\n  OPENAI_API_KEY\n  MODEL\n  VOICE\n`);
-}
-
-async function run(requestFile) {
-  if (!config.OPENAI_API_KEY) {
-    console.log(JSON.stringify(toolNeedsConfig({
-      tool: toolName,
-      missingConfig: ["OPENAI_API_KEY"],
-      configPath: getToolConfigPath(toolName)
-    })));
-    return;
-  }
-
-  const request = JSON.parse(await readFile(requestFile, "utf8"));
-  const inputText = request.text || request.artifact?.text;
-  if (!inputText) {
-    console.log(JSON.stringify(toolError("text or artifact.text is required")));
-    return;
-  }
-
-  const response = await fetch("https://api.openai.com/v1/audio/speech", {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${config.OPENAI_API_KEY}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      model: config.MODEL,
-      voice: request.args?.voice || config.VOICE,
-      input: inputText,
-      format: "opus"
-    })
-  });
-
-  if (!response.ok) {
-    const payload = await response.text();
-    console.log(JSON.stringify(toolError(payload)));
-    return;
-  }
-
-  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());
-  await writeFile(filePath, buffer);
-  console.log(JSON.stringify(toolOk({
-    filePath,
-    fileName: path.basename(filePath),
-    mimeType: "audio/ogg",
-    kind: "audio",
-    delivery: { method: "voice" }
-  })));
-}
-
-const args = process.argv.slice(2);
-if (!args.length || args.includes("--help") || args[0] === "help") {
-  printHelp();
-} else if (args[0] === "run") {
-  const fileIndex = args.indexOf("--request-file");
-  await run(args[fileIndex + 1]);
-} else {
-  printHelp();
-}

package/tools/openai-tts/package.json

@@ -1,6 +0,0 @@
-{
-  "name": "openai-tts-cli",
-  "private": true,
-  "type": "module",
-  "version": "1.0.0"
-}

package/tools/openai-tts/tool.manifest.json

@@ -1,20 +0,0 @@
-{
-  "name": "openai-tts",
-  "description": "Convert text into OGG/Opus speech audio using the OpenAI speech API.",
-  "entry": "index.js",
-  "input": ["text/plain"],
-  "output": ["audio/ogg"],
-  "configSchema": {
-    "OPENAI_API_KEY": {
-      "type": "string",
-      "required": true,
-      "secret": true,
-      "prompt": "I need your OPENAI_API_KEY to generate speech audio."
-    },
-    "VOICE": {
-      "type": "string",
-      "required": false,
-      "prompt": "Voice to use, for example alloy."
-    }
-  }
-}

package/tools/schedule-agent-task/config.js

@@ -1 +0,0 @@
-export default {};

package/tools/schedule-agent-task/index.js

@@ -1,68 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { toolError, toolOk } from "../../src/core/tools/tool-result.js";
-
-function printHelp() {
-  console.log(`schedule-agent-task\n\nUsage:\n  node index.js --help\n  node index.js run --request-file <json>\n\nExpected input:\n  {\n    "text": "tell me the temperature in Toronto",\n    "artifact": { "text": "tell me the temperature in Toronto" },\n    "args": {\n      "prompt": "tell me the temperature in Toronto",\n      "runAt": "2026-04-07T14:00:00.000Z",\n      "delaySeconds": "30",\n      "intervalSeconds": "3600"\n    }\n  }\n\nBehavior:\n  - schedules a future agent task for the current chat\n  - provide either args.runAt or args.delaySeconds\n  - optional args.intervalSeconds makes the task recurring\n`);
-}
-
-function firstNonEmpty(...values) {
-  return values.find((value) => String(value || "").trim()) || "";
-}
-
-function buildRunAt(args = {}) {
-  const runAtValue = firstNonEmpty(args.runAt, args.at, args.when);
-  if (runAtValue) {
-    const parsed = Date.parse(runAtValue);
-    if (Number.isNaN(parsed)) return "";
-    return new Date(parsed).toISOString();
-  }
-
-  const delaySeconds = Number(firstNonEmpty(args.delaySeconds, args.delay, args.seconds));
-  if (Number.isFinite(delaySeconds) && delaySeconds > 0) {
-    return new Date(Date.now() + (delaySeconds * 1000)).toISOString();
-  }
-
-  return "";
-}
-
-async function run(requestFile) {
-  const request = JSON.parse(await readFile(requestFile, "utf8"));
-  const args = request.args || {};
-  const prompt = firstNonEmpty(args.prompt, args.message, args.task, request.text, request.artifact?.text);
-  const runAt = buildRunAt(args);
-  const intervalSeconds = Number(firstNonEmpty(args.intervalSeconds, args.interval, args.everySeconds));
-
-  if (!prompt.trim()) {
-    console.log(JSON.stringify(toolError("prompt/message/task, text, or artifact.text is required")));
-    return;
-  }
-
-  if (!runAt) {
-    console.log(JSON.stringify(toolError("args.runAt/at/when or args.delaySeconds/delay/seconds is required")));
-    return;
-  }
-
-  const asyncTask = {
-    kind: "agent_task",
-    runAt,
-    payload: { prompt },
-    recurrence: Number.isFinite(intervalSeconds) && intervalSeconds > 0
-      ? { type: "interval", everySeconds: intervalSeconds }
-      : null
-  };
-
-  console.log(JSON.stringify(toolOk({ runAt }, {
-    status: "scheduled",
-    asyncTask
-  })));
-}
-
-const args = process.argv.slice(2);
-if (!args.length || args.includes("--help") || args[0] === "help") {
-  printHelp();
-} else if (args[0] === "run") {
-  const fileIndex = args.indexOf("--request-file");
-  await run(args[fileIndex + 1]);
-} else {
-  printHelp();
-}

package/tools/schedule-agent-task/package.json

@@ -1,6 +0,0 @@
-{
-  "name": "schedule-agent-task-cli",
-  "private": true,
-  "type": "module",
-  "version": "1.0.0"
-}

package/tools/schedule-agent-task/tool.manifest.json

@@ -1,8 +0,0 @@
-{
-  "name": "schedule-agent-task",
-  "description": "Schedule a future Pi Agent task for the current chat.",
-  "entry": "index.js",
-  "input": ["text/plain"],
-  "output": ["application/json"],
-  "configSchema": {}
-}

package/tools/web-browser/config.js

@@ -1 +0,0 @@
-export default {};

package/tools/web-browser/index.js

@@ -1,147 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { toolError, toolOk } from "../../src/core/tools/tool-result.js";
-
-function printHelp() {
-  console.log(`web-browser\n\nUsage:\n  node index.js --help\n  node index.js run --request-file <json>\n\nExpected input:\n  {\n    "text": "weather toronto" | "https://example.com",\n    "artifact": { "text": "weather toronto" },\n    "args": {\n      "mode": "search" | "open",\n      "url": "https://example.com",\n      "maxResults": "5"\n    }\n  }\n\nBehavior:\n  - If the input looks like a URL, open the page.\n  - Otherwise, perform a web search.\n  - When possible, opening pages uses r.jina.ai with a direct fetch fallback.\n`);
-}
-
-function decodeHtml(text = "") {
-  return text
-    .replace(/&amp;/g, "&")
-    .replace(/&quot;/g, '"')
-    .replace(/&#39;/g, "'")
-    .replace(/&lt;/g, "<")
-    .replace(/&gt;/g, ">")
-    .replace(/&nbsp;/g, " ");
-}
-
-function stripHtml(html = "") {
-  return decodeHtml(
-    html
-      .replace(/<script[\s\S]*?<\/script>/gi, " ")
-      .replace(/<style[\s\S]*?<\/style>/gi, " ")
-      .replace(/<[^>]+>/g, " ")
-      .replace(/\s+/g, " ")
-  ).trim();
-}
-
-function normalizeUrl(value = "") {
-  const text = value.trim();
-  if (!text) return "";
-  if (/^https?:\/\//i.test(text)) return text;
-  if (/^[\w.-]+\.[a-z]{2,}(\/|$)/i.test(text)) return `https://${text}`;
-  return "";
-}
-
-function extractActualUrl(duckUrl) {
-  try {
-    const parsed = new URL(duckUrl.startsWith("//") ? `https:${duckUrl}` : duckUrl);
-    const uddg = parsed.searchParams.get("uddg");
-    return uddg ? decodeURIComponent(uddg) : parsed.toString();
-  } catch {
-    return duckUrl;
-  }
-}
-
-async function fetchText(url) {
-  const response = await fetch(url, {
-    headers: {
-      "user-agent": "Mozilla/5.0",
-      "accept-language": "en-US,en;q=0.9"
-    },
-    redirect: "follow"
-  });
-  return { response, text: await response.text() };
-}
-
-async function searchWeb(query, maxResults = 5) {
-  const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
-  const { response, text: html } = await fetchText(url);
-  if (!response.ok) throw new Error(`Search failed with status ${response.status}`);
-
-  const results = [];
-  const blocks = html.split(/<div class="result results_links[\s\S]*?web-result ">/i).slice(1);
-  for (const block of blocks) {
-    if (results.length >= maxResults) break;
-    const titleMatch = block.match(/<a[^>]*class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/i);
-    if (!titleMatch) continue;
-    const snippetMatch = block.match(/<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/i);
-    const displayUrlMatch = block.match(/<a[^>]*class="result__url"[^>]*>([\s\S]*?)<\/a>/i);
-    results.push({
-      title: stripHtml(titleMatch[2]),
-      url: extractActualUrl(titleMatch[1]),
-      snippet: stripHtml(snippetMatch?.[1] || ""),
-      displayUrl: stripHtml(displayUrlMatch?.[1] || "")
-    });
-  }
-
-  if (!results.length) {
-    return `Search: ${query}\n\nNo parseable results were found.`;
-  }
-
-  return [
-    `Search: ${query}`,
-    "",
-    ...results.flatMap((item, index) => [
-      `${index + 1}. ${item.title}`,
-      `URL: ${item.url}`,
-      `Snippet: ${item.snippet}`,
-      item.displayUrl ? `Displayed: ${item.displayUrl}` : null,
-      ""
-    ].filter(Boolean))
-  ].join("\n").trim();
-}
-
-async function openWebPage(inputUrl) {
-  const targetUrl = normalizeUrl(inputUrl);
-  if (!targetUrl) throw new Error("A valid URL is required");
-
-  const jinaUrl = `https://r.jina.ai/http://${targetUrl.replace(/^https?:\/\//i, "")}`;
-  let body = "";
-  let source = "jina-ai";
-
-  try {
-    const { response, text } = await fetchText(jinaUrl);
-    if (!response.ok) throw new Error(`r.jina.ai status ${response.status}`);
-    body = text.trim();
-  } catch {
-    const { response, text } = await fetchText(targetUrl);
-    if (!response.ok) throw new Error(`Open failed with status ${response.status}`);
-    body = stripHtml(text);
-    source = "direct-fetch";
-  }
-
-  const shortened = body.length > 12000 ? `${body.slice(0, 12000)}\n\n[content truncated]` : body;
-  return [`Page: ${targetUrl}`, `Source: ${source}`, "", shortened].join("\n").trim();
-}
-
-async function run(requestFile) {
-  const request = JSON.parse(await readFile(requestFile, "utf8"));
-  const rawInput = request.args?.url || request.text || request.artifact?.text || "";
-  const mode = request.args?.mode || (normalizeUrl(rawInput) ? "open" : "search");
-  const maxResults = Number.parseInt(request.args?.maxResults || "5", 10);
-
-  if (!rawInput.trim()) {
-    console.log(JSON.stringify(toolError("text, artifact.text, or args.url is required")));
-    return;
-  }
-
-  try {
-    const outputText = mode === "open"
-      ? await openWebPage(rawInput)
-      : await searchWeb(rawInput, Number.isFinite(maxResults) ? maxResults : 5);
-    console.log(JSON.stringify(toolOk({ text: outputText })));
-  } catch (error) {
-    console.log(JSON.stringify(toolError(error.message || String(error))));
-  }
-}
-
-const args = process.argv.slice(2);
-if (!args.length || args.includes("--help") || args[0] === "help") {
-  printHelp();
-} else if (args[0] === "run") {
-  const fileIndex = args.indexOf("--request-file");
-  await run(args[fileIndex + 1]);
-} else {
-  printHelp();
-}

package/tools/web-browser/package.json

@@ -1,6 +0,0 @@
-{
-  "name": "web-browser-cli",
-  "private": true,
-  "type": "module",
-  "version": "1.0.0"
-}

package/tools/web-browser/tool.manifest.json

@@ -1,8 +0,0 @@
-{
-  "name": "web-browser",
-  "description": "Search the web and open web pages as readable text.",
-  "entry": "index.js",
-  "input": ["text/plain"],
-  "output": ["text/plain"],
-  "configSchema": {}
-}