@llblab/pi-telegram 0.4.0 → 0.5.0

package/lib/commands.ts

@@ -1,9 +1,10 @@
 /**
  * Telegram command routing helpers
- * Owns slash-command normalization and command side-effect branching behind runtime ports
+ * Owns Telegram slash-command normalization, bot command metadata, and pi-side command registration behind runtime ports
  */
 
 import { pairTelegramUserIfNeeded } from "./config.ts";
+import type { ExtensionAPI, ExtensionCommandContext } from "./pi.ts";
 import {
   createTelegramControlItemBuilder,
   createTelegramControlQueueController,
@@ -52,22 +53,115 @@ export function createTelegramBotCommandRegistrar(
   return () => registerTelegramBotCommands(deps);
 }
 
+export interface TelegramBridgeCommandStartPollingOptions {
+  force?: boolean;
+}
+
+export interface TelegramBridgeCommandStartPollingResult {
+  ok: boolean;
+  message?: string;
+  canTakeover?: boolean;
+  owner?: string;
+}
+
+export interface TelegramBridgeCommandRegistrationDeps {
+  promptForConfig: (ctx: ExtensionCommandContext) => Promise<void>;
+  getStatusLines: () => string[];
+  reloadConfig: () => Promise<void>;
+  hasBotToken: () => boolean;
+  startPolling: (
+    ctx: ExtensionCommandContext,
+    options?: TelegramBridgeCommandStartPollingOptions,
+  ) =>
+    | void
+    | Promise<void | TelegramBridgeCommandStartPollingResult>
+    | TelegramBridgeCommandStartPollingResult;
+  stopPolling: () => Promise<void | string>;
+  updateStatus: (ctx: ExtensionCommandContext) => void;
+}
+
+function formatTelegramTakeoverTitle(ctx: ExtensionCommandContext): string {
+  return ctx.ui.theme.fg("accent", "pi-telegram");
+}
+
+function formatTelegramTakeoverPrompt(
+  ctx: ExtensionCommandContext,
+  owner?: string,
+): string {
+  const theme = ctx.ui.theme;
+  const action = theme.fg("warning", "move singleton lock here?");
+  const from = theme.fg("muted", "from:");
+  const to = theme.fg("muted", "to:");
+  const source = owner ?? "another pi instance";
+  return `${action}\n\n${from} ${source}\n${to} ${ctx.cwd}`;
+}
+
+export function registerTelegramBridgeCommands(
+  pi: ExtensionAPI,
+  deps: TelegramBridgeCommandRegistrationDeps,
+): void {
+  pi.registerCommand("telegram-setup", {
+    description: "Configure Telegram bot token",
+    handler: async (_args, ctx) => {
+      await deps.promptForConfig(ctx);
+    },
+  });
+  pi.registerCommand("telegram-status", {
+    description: "Show Telegram bridge status",
+    handler: async (_args, ctx) => {
+      ctx.ui.notify(deps.getStatusLines().join("\n"), "info");
+    },
+  });
+  pi.registerCommand("telegram-connect", {
+    description: "Start the Telegram bridge in this pi session",
+    handler: async (_args, ctx) => {
+      await deps.reloadConfig();
+      if (!deps.hasBotToken()) {
+        await deps.promptForConfig(ctx);
+        return;
+      }
+      let result = await deps.startPolling(ctx);
+      if (result && !result.ok && result.canTakeover) {
+        const confirmed = await ctx.ui.confirm(
+          formatTelegramTakeoverTitle(ctx),
+          formatTelegramTakeoverPrompt(ctx, result.owner),
+        );
+        if (!confirmed) {
+          ctx.ui.notify("Telegram bridge takeover cancelled.", "info");
+          deps.updateStatus(ctx);
+          return;
+        }
+        result = await deps.startPolling(ctx, { force: true });
+      }
+      if (result?.message) {
+        ctx.ui.notify(result.message, result.ok ? "info" : "warning");
+      }
+      deps.updateStatus(ctx);
+    },
+  });
+  pi.registerCommand("telegram-disconnect", {
+    description: "Stop the Telegram bridge in this pi session",
+    handler: async (_args, ctx) => {
+      const message = await deps.stopPolling();
+      if (message) ctx.ui.notify(message, "info");
+      deps.updateStatus(ctx);
+    },
+  });
+}
+
 export type TelegramCommandAction =
   | { kind: "ignore"; executionMode: "ignored" }
   | { kind: "stop"; executionMode: "immediate" }
   | { kind: "compact"; executionMode: "immediate" }
-  | { kind: "status"; executionMode: "control-queue" }
-  | { kind: "model"; executionMode: "control-queue" }
+  | { kind: "status"; executionMode: "immediate" }
+  | { kind: "model"; executionMode: "immediate" }
   | {
       kind: "help";
       commandName: "help" | "start";
       executionMode: "immediate";
     };
 
-export type TelegramCommandExecutionMode =
-  | "ignored"
-  | "immediate"
-  | "control-queue";
+export type TelegramCommandExecutionMode = "ignored" | "immediate";
 
 export interface TelegramCommandActionDeps<TMessage, TContext> {
   handleStop: (message: TMessage, ctx: TContext) => Promise<void>;
@@ -99,8 +193,7 @@ export interface TelegramRuntimeEventRecorderPort {
   ) => void;
 }
 
-export interface TelegramCompactCommandDeps
-  extends TelegramRuntimeEventRecorderPort {
+export interface TelegramCompactCommandDeps extends TelegramRuntimeEventRecorderPort {
   isIdle: () => boolean;
   hasPendingMessages: () => boolean;
   hasActiveTelegramTurn: () => boolean;
@@ -130,14 +223,6 @@ export interface TelegramHelpCommandDeps {
 export type TelegramControlCommandType =
   PendingTelegramControlItem<unknown>["controlType"];
 
-export interface TelegramQueuedControlCommandDeps<TContext> {
-  enqueueControlItem: (
-    controlType: TelegramControlCommandType,
-    statusSummary: string,
-    execute: (ctx: TContext) => Promise<void>,
-  ) => void;
-}
-
 export interface TelegramCommandRuntimeMessage {
   chat: { id: number };
   message_id: number;
@@ -380,9 +465,9 @@ export function buildTelegramCommandAction(
     case "compact":
       return { kind: "compact", executionMode: "immediate" };
     case "status":
-      return { kind: "status", executionMode: "control-queue" };
+      return { kind: "status", executionMode: "immediate" };
     case "model":
-      return { kind: "model", executionMode: "control-queue" };
+      return { kind: "model", executionMode: "immediate" };
     case "help":
     case "start":
       return { kind: "help", commandName, executionMode: "immediate" };
@@ -483,20 +568,18 @@ export async function handleTelegramHelpCommand(
   });
 }
 
-export async function handleTelegramStatusCommand<TContext>(
-  deps: TelegramQueuedControlCommandDeps<TContext> & {
-    showStatus: (ctx: TContext) => Promise<void>;
-  },
-): Promise<void> {
-  deps.enqueueControlItem("status", "⚡ status", deps.showStatus);
+export async function handleTelegramStatusCommand<TContext>(deps: {
+  ctx: TContext;
+  showStatus: (ctx: TContext) => Promise<void>;
+}): Promise<void> {
+  await deps.showStatus(deps.ctx);
 }
 
-export async function handleTelegramModelCommand<TContext>(
-  deps: TelegramQueuedControlCommandDeps<TContext> & {
-    openModelMenu: (ctx: TContext) => Promise<void>;
-  },
-): Promise<void> {
-  deps.enqueueControlItem("model", "⚡ model", deps.openModelMenu);
+export async function handleTelegramModelCommand<TContext>(deps: {
+  ctx: TContext;
+  openModelMenu: (ctx: TContext) => Promise<void>;
+}): Promise<void> {
+  await deps.openModelMenu(deps.ctx);
 }
 
 export async function executeTelegramCommandAction<TMessage, TContext>(
@@ -644,21 +727,6 @@ async function handleTelegramCommandRuntime<
     deps.sendTextReply(nextMessage, text);
   const updateStatusFor = (commandCtx: TContext) => () =>
     deps.updateStatus(commandCtx);
-  const enqueueControlFor =
-    (nextMessage: TMessage, commandCtx: TContext) =>
-    (
-      controlType: TelegramControlCommandType,
-      statusSummary: string,
-      execute: (ctx: TContext) => Promise<void>,
-    ) => {
-      deps.enqueueControlItem(
-        nextMessage,
-        commandCtx,
-        controlType,
-        statusSummary,
-        execute,
-      );
-    };
   return executeTelegramCommandAction(
     buildTelegramCommandAction(commandName),
     message,
@@ -694,13 +762,13 @@ async function handleTelegramCommandRuntime<
       },
       handleStatus: async (nextMessage, commandCtx) => {
         await handleTelegramStatusCommand<TContext>({
-          enqueueControlItem: enqueueControlFor(nextMessage, commandCtx),
+          ctx: commandCtx,
           showStatus: (controlCtx) => deps.showStatus(nextMessage, controlCtx),
         });
       },
       handleModel: async (nextMessage, commandCtx) => {
         await handleTelegramModelCommand<TContext>({
-          enqueueControlItem: enqueueControlFor(nextMessage, commandCtx),
+          ctx: commandCtx,
           openModelMenu: (controlCtx) =>
             deps.openModelMenu(nextMessage, controlCtx),
         });

package/lib/handlers.ts

@@ -1,31 +1,20 @@
 /**
  * Telegram inbound attachment handler pipeline
- * Owns MIME/type matching plus command and auto-tool execution for downloaded inbound files before prompt enqueueing
+ * Owns MIME/type matching, command-template execution, fallback handling, and prompt injection before prompt enqueueing
  */
 
-import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { basename, isAbsolute, join, resolve } from "node:path";
+import { basename, isAbsolute, resolve } from "node:path";
 
 const DEFAULT_ATTACHMENT_HANDLER_TIMEOUT_MS = 120_000;
 
-function getDefaultAgentDir(): string {
-  return process.env.PI_CODING_AGENT_DIR
-    ? resolve(process.env.PI_CODING_AGENT_DIR)
-    : join(homedir(), ".pi", "agent");
-}
-
-function getDefaultAutoToolsPath(): string {
-  return join(getDefaultAgentDir(), "auto-tools.json");
-}
-
 export interface TelegramAttachmentHandlerConfig {
   match?: string | string[];
   mime?: string | string[];
   type?: string | string[];
-  command?: string;
-  tool?: string;
-  args?: Record<string, unknown>;
+  template?: string;
+  args?: string | string[];
+  defaults?: Record<string, unknown>;
   timeoutMs?: number;
 }
 
@@ -77,8 +66,6 @@ export interface TelegramAttachmentHandlerRuntimeDeps<TContext> {
     options?: TelegramAttachmentHandlerExecOptions,
   ) => Promise<TelegramAttachmentHandlerExecResult>;
   getCwd: (ctx: TContext) => string;
-  readTextFile?: (path: string) => Promise<string>;
-  autoToolsPath?: string;
   recordRuntimeEvent?: (
     category: string,
     error: unknown,
@@ -99,15 +86,12 @@ interface AttachmentHandlerInvocation {
   args: string[];
 }
 
-interface AutoToolConfig {
-  name: string;
-  script: string;
-  args: string[];
-}
-
 function normalizeStringList(value: string | string[] | undefined): string[] {
   if (Array.isArray(value)) {
-    return value.map(String).map((item) => item.trim()).filter(Boolean);
+    return value
+      .map(String)
+      .map((item) => item.trim())
+      .filter(Boolean);
   }
   if (typeof value === "string" && value.trim()) return [value.trim()];
   return [];
@@ -124,7 +108,9 @@ function matchesWildcard(pattern: string, value: string | undefined): boolean {
   return new RegExp(`^${escaped}$`).test(normalizedValue);
 }
 
-function handlerHasSelectors(handler: TelegramAttachmentHandlerConfig): boolean {
+function handlerHasSelectors(
+  handler: TelegramAttachmentHandlerConfig,
+): boolean {
   return (
     normalizeStringList(handler.match).length > 0 ||
     normalizeStringList(handler.mime).length > 0 ||
@@ -132,7 +118,10 @@ function handlerHasSelectors(handler: TelegramAttachmentHandlerConfig): boolean
   );
 }
 
-function matchesAnyPattern(patterns: string[], value: string | undefined): boolean {
+function matchesAnyPattern(
+  patterns: string[],
+  value: string | undefined,
+): boolean {
   return patterns.some((pattern) => matchesWildcard(pattern, value));
 }
 
@@ -150,12 +139,12 @@ export function telegramAttachmentHandlerMatchesFile(
   return matchesAnyPattern(matchPatterns, file.kind);
 }
 
-export function findTelegramAttachmentHandler(
+export function findTelegramAttachmentHandlers(
   handlers: TelegramAttachmentHandlerConfig[] | undefined,
   file: TelegramAttachmentHandlerFile,
-): TelegramAttachmentHandlerConfig | undefined {
-  if (!Array.isArray(handlers)) return undefined;
-  return handlers.find(
+): TelegramAttachmentHandlerConfig[] {
+  if (!Array.isArray(handlers)) return [];
+  return handlers.filter(
     (handler) =>
       !!handler &&
       typeof handler === "object" &&
@@ -163,29 +152,64 @@ export function findTelegramAttachmentHandler(
   );
 }
 
-function hasAttachmentPlaceholder(value: string): boolean {
-  return /\{(?:filename|path|basename|mime|type)\}/.test(value);
+export function findTelegramAttachmentHandler(
+  handlers: TelegramAttachmentHandlerConfig[] | undefined,
+  file: TelegramAttachmentHandlerFile,
+): TelegramAttachmentHandlerConfig | undefined {
+  return findTelegramAttachmentHandlers(handlers, file)[0];
 }
 
-export function substituteTelegramAttachmentHandlerToken(
-  token: string,
+function hasAttachmentFilePlaceholder(value: string): boolean {
+  return /\{file\}/.test(value);
+}
+
+function normalizeTelegramAttachmentHandlerArgs(
+  value: string | string[] | undefined,
+): string[] {
+  if (Array.isArray(value)) return value.map(String).map((item) => item.trim());
+  if (typeof value !== "string") return [];
+  return value.split(",").map((item) => item.trim());
+}
+
+function getTelegramAttachmentHandlerArgDefaults(
+  handler: TelegramAttachmentHandlerConfig,
+): Record<string, string> {
+  const defaults: Record<string, string> = {};
+  for (const item of normalizeTelegramAttachmentHandlerArgs(handler.args)) {
+    if (!item) continue;
+    const [name, ...defaultParts] = item.split("=");
+    if (!name || defaultParts.length === 0) continue;
+    defaults[name.trim()] = defaultParts.join("=").trim();
+  }
+  for (const [key, value] of Object.entries(handler.defaults ?? {})) {
+    defaults[key] = value === undefined || value === null ? "" : String(value);
+  }
+  return defaults;
+}
+
+function getTelegramAttachmentHandlerTemplateValues(
+  handler: TelegramAttachmentHandlerConfig,
   file: TelegramAttachmentHandlerFile,
-): string {
-  const replacements: Record<string, string> = {
-    "{filename}": file.path,
-    "{path}": file.path,
-    "{basename}": file.fileName || basename(file.path),
-    "{mime}": file.mimeType ?? "",
-    "{type}": file.kind ?? "",
+): Record<string, string> {
+  return {
+    ...getTelegramAttachmentHandlerArgDefaults(handler),
+    file: file.path,
+    mime: file.mimeType ?? "",
+    type: file.kind ?? "",
   };
-  let result = token;
-  for (const [key, value] of Object.entries(replacements)) {
-    result = result.split(key).join(value);
-  }
-  return result;
 }
 
-export function splitTelegramAttachmentHandlerCommand(input: string): string[] {
+function substituteTelegramAttachmentHandlerTemplateToken(
+  token: string,
+  values: Record<string, string>,
+): string {
+  return token.replace(/\{([A-Za-z_][A-Za-z0-9_-]*)\}/g, (_match, name) => {
+    if (Object.hasOwn(values, name)) return values[name] ?? "";
+    throw new Error(`Missing attachment handler template value: ${name}`);
+  });
+}
+
+export function splitTelegramAttachmentHandlerTemplate(input: string): string[] {
   const words: string[] = [];
   let current = "";
   let quote: "'" | '"' | undefined;
@@ -237,135 +261,38 @@ function expandExecutablePath(command: string, cwd: string): string {
   return command;
 }
 
-export function buildTelegramAttachmentCommandInvocation(
-  commandTemplate: string,
+function buildTelegramAttachmentTemplateInvocation(
+  template: string,
+  handler: TelegramAttachmentHandlerConfig,
   file: TelegramAttachmentHandlerFile,
   cwd: string,
 ): AttachmentHandlerInvocation {
-  const parts = splitTelegramAttachmentHandlerCommand(commandTemplate);
+  const parts = splitTelegramAttachmentHandlerTemplate(template);
   const commandPart = parts[0];
-  if (!commandPart) throw new Error("Attachment handler command is empty");
-  const hadPlaceholder = parts.some(hasAttachmentPlaceholder);
+  if (!commandPart) throw new Error("Attachment handler template is empty");
+  const values = getTelegramAttachmentHandlerTemplateValues(handler, file);
+  const hadFilePlaceholder = parts.some(hasAttachmentFilePlaceholder);
   const command = expandExecutablePath(
-    substituteTelegramAttachmentHandlerToken(commandPart, file),
+    substituteTelegramAttachmentHandlerTemplateToken(commandPart, values),
     cwd,
   );
   const args = parts
     .slice(1)
-    .map((part) => substituteTelegramAttachmentHandlerToken(part, file));
-  if (!hadPlaceholder) args.push(file.path);
-  return { command, args };
-}
-
-function normalizeAutoToolName(name: string): string {
-  return name
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9_]/g, "_")
-    .replace(/_+/g, "_")
-    .replace(/^_+|_+$/g, "");
-}
-
-function normalizeAutoToolArgs(value: unknown): string[] {
-  const source = Array.isArray(value)
-    ? value
-    : typeof value === "string"
-      ? value.split(",")
-      : [];
-  const args: string[] = [];
-  const seen = new Set<string>();
-  for (const item of source) {
-    const arg = normalizeAutoToolName(String(item));
-    if (!arg || seen.has(arg)) continue;
-    seen.add(arg);
-    args.push(arg);
-  }
-  return args;
-}
-
-export function parseTelegramAutoToolsRegistry(
-  content: string,
-): Map<string, AutoToolConfig> {
-  const raw = JSON.parse(content) as unknown;
-  const entries = Array.isArray(raw)
-    ? raw.map((value) => [undefined, value] as const)
-    : raw && typeof raw === "object"
-      ? Object.entries(raw as Record<string, unknown>)
-      : [];
-  const tools = new Map<string, AutoToolConfig>();
-  for (const [key, value] of entries) {
-    if (!value || typeof value !== "object") continue;
-    const record = value as Record<string, unknown>;
-    const name = normalizeAutoToolName(
-      typeof record.name === "string" ? record.name : (key ?? ""),
+    .map((part) =>
+      substituteTelegramAttachmentHandlerTemplateToken(part, values),
     );
-    const script = typeof record.script === "string" ? record.script.trim() : "";
-    if (!name || !script) continue;
-    tools.set(name, { name, script, args: normalizeAutoToolArgs(record.args) });
-  }
-  return tools;
-}
-
-async function readTelegramAutoToolsRegistry(
-  path: string,
-  readTextFile: (path: string) => Promise<string>,
-): Promise<Map<string, AutoToolConfig>> {
-  try {
-    return parseTelegramAutoToolsRegistry(await readTextFile(path));
-  } catch {
-    return new Map();
-  }
-}
-
-function getConfiguredToolArgValue(
-  value: unknown,
-  file: TelegramAttachmentHandlerFile,
-): string | undefined {
-  if (value === undefined || value === null) return undefined;
-  return substituteTelegramAttachmentHandlerToken(String(value), file);
-}
-
-function getDefaultToolArgValue(
-  arg: string,
-  file: TelegramAttachmentHandlerFile,
-): string {
-  if (["file", "filename", "path"].includes(arg)) return file.path;
-  if (["basename", "name"].includes(arg)) {
-    return file.fileName || basename(file.path);
-  }
-  if (["mime", "mime_type", "mimetype"].includes(arg)) return file.mimeType ?? "";
-  if (["type", "kind"].includes(arg)) return file.kind ?? "";
-  return "";
+  if (!hadFilePlaceholder) args.push(file.path);
+  return { command, args };
 }
 
-async function buildTelegramAttachmentToolInvocation(
+export function buildTelegramAttachmentHandlerInvocation(
   handler: TelegramAttachmentHandlerConfig,
   file: TelegramAttachmentHandlerFile,
   cwd: string,
-  deps: Pick<
-    TelegramAttachmentHandlerRuntimeDeps<unknown>,
-    "readTextFile" | "autoToolsPath"
-  >,
-): Promise<AttachmentHandlerInvocation> {
-  const toolName = normalizeAutoToolName(handler.tool ?? "");
-  if (!toolName) throw new Error("Attachment handler tool is empty");
-  const readRegistryFile =
-    deps.readTextFile ?? ((path: string) => readFile(path, "utf8"));
-  const registry = await readTelegramAutoToolsRegistry(
-    deps.autoToolsPath ?? getDefaultAutoToolsPath(),
-    readRegistryFile,
-  );
-  const tool = registry.get(toolName);
-  if (!tool) {
-    throw new Error(`Attachment handler tool not found in auto-tools: ${toolName}`);
-  }
-  const script = expandExecutablePath(tool.script, cwd);
-  const args = tool.args.map(
-    (arg) =>
-      getConfiguredToolArgValue(handler.args?.[arg], file) ??
-      getDefaultToolArgValue(arg, file),
-  );
-  return { command: script, args };
+): AttachmentHandlerInvocation {
+  const { template } = handler;
+  if (!template) throw new Error("Attachment handler template is required");
+  return buildTelegramAttachmentTemplateInvocation(template, handler, file, cwd);
 }
 
 function getTelegramAttachmentHandlerTimeout(
@@ -378,9 +305,10 @@ function getTelegramAttachmentHandlerTimeout(
     : DEFAULT_ATTACHMENT_HANDLER_TIMEOUT_MS;
 }
 
-function getTelegramAttachmentHandlerKind(handler: TelegramAttachmentHandlerConfig): string {
-  if (handler.command) return "command";
-  if (handler.tool) return "tool";
+function getTelegramAttachmentHandlerKind(
+  handler: TelegramAttachmentHandlerConfig,
+): string {
+  if (handler.template) return "template";
   return "unknown";
 }
 
@@ -399,19 +327,19 @@ async function executeTelegramAttachmentHandler(
   handler: TelegramAttachmentHandlerConfig,
   file: TelegramAttachmentHandlerFile,
   cwd: string,
-  deps: Pick<
-    TelegramAttachmentHandlerRuntimeDeps<unknown>,
-    "execCommand" | "readTextFile" | "autoToolsPath"
-  >,
+  deps: Pick<TelegramAttachmentHandlerRuntimeDeps<unknown>, "execCommand">,
 ): Promise<string> {
-  const invocation = handler.command
-    ? buildTelegramAttachmentCommandInvocation(handler.command, file, cwd)
-    : await buildTelegramAttachmentToolInvocation(handler, file, cwd, deps);
+  const invocation = buildTelegramAttachmentHandlerInvocation(
+    handler,
+    file,
+    cwd,
+  );
   const result = await deps.execCommand(invocation.command, invocation.args, {
     cwd,
     timeout: getTelegramAttachmentHandlerTimeout(handler),
   });
-  if (result.code !== 0) throw new Error(formatTelegramAttachmentHandlerFailure(result));
+  if (result.code !== 0)
+    throw new Error(formatTelegramAttachmentHandlerFailure(result));
   return result.stdout.trim();
 }
 
@@ -423,28 +351,28 @@ export async function processTelegramAttachmentHandlers<
   handlers?: TelegramAttachmentHandlerConfig[];
   cwd: string;
   execCommand: TelegramAttachmentHandlerRuntimeDeps<unknown>["execCommand"];
-  readTextFile?: (path: string) => Promise<string>;
-  autoToolsPath?: string;
   recordRuntimeEvent?: TelegramAttachmentHandlerRuntimeDeps<unknown>["recordRuntimeEvent"];
 }): Promise<TelegramAttachmentHandlerProcessResult<TFile>> {
   const promptFiles: TFile[] = [...options.files];
   const outputs: TelegramAttachmentHandlerOutput[] = [];
   for (const file of options.files) {
-    const handler = findTelegramAttachmentHandler(options.handlers, file);
-    if (!handler) continue;
-    try {
-      const output = await executeTelegramAttachmentHandler(
-        handler,
-        file,
-        options.cwd,
-        options,
-      );
-      if (output) outputs.push({ file, output, handler });
-    } catch (error) {
-      options.recordRuntimeEvent?.("attachment-handler", error, {
-        fileName: file.fileName || basename(file.path),
-        handler: getTelegramAttachmentHandlerKind(handler),
-      });
+    const handlers = findTelegramAttachmentHandlers(options.handlers, file);
+    for (const handler of handlers) {
+      try {
+        const output = await executeTelegramAttachmentHandler(
+          handler,
+          file,
+          options.cwd,
+          options,
+        );
+        if (output) outputs.push({ file, output, handler });
+        break;
+      } catch (error) {
+        options.recordRuntimeEvent?.("attachment-handler", error, {
+          fileName: file.fileName || basename(file.path),
+          handler: getTelegramAttachmentHandlerKind(handler),
+        });
+      }
     }
   }
   return {
@@ -466,8 +394,6 @@ export function createTelegramAttachmentHandlerRuntime<TContext>(
         handlers: deps.getHandlers(),
         cwd: deps.getCwd(ctx),
         execCommand: deps.execCommand,
-        readTextFile: deps.readTextFile,
-        autoToolsPath: deps.autoToolsPath,
         recordRuntimeEvent: deps.recordRuntimeEvent,
       }),
   };