@mono-agent/agent-app 0.12.0 → 0.14.0

package/dist/adapter-send-tools.js

@@ -29,13 +29,8 @@ const ASK_BRIDGE_CLEANUP_TIMEOUT_MS = 1_000;
 export const ADAPTER_SEND_TOOLS_MCP_SERVER_NAME = "mono-agent-adapter-send";
 export async function resolveAdapterSendToolsSettings(input, options = {}) {
     const telegramSendAllowed = isAdapterToolAllowed("TelegramSendMessage", options);
-    const telegramAskAllowed = options.suppressInteractionTools !== true
-        && isAdapterToolAllowed("TelegramAskButtons", options);
     const telegramFileAllowed = isAdapterToolAllowed("TelegramSendFile", options);
-    const telegramAnyAllowed = telegramSendAllowed || telegramAskAllowed || telegramFileAllowed;
-    const telegramAskBridge = telegramAskAllowed
-        ? resolveAskUserToolSettings(input.env, options.interaction)
-        : undefined;
+    const telegramAnyAllowed = telegramSendAllowed || telegramFileAllowed;
     const [slack, telegram] = await Promise.all([
         isAdapterToolAllowed("SlackSendMessage", options)
             ? resolveSlackSendToolSettings(input, options)
@@ -43,9 +38,8 @@ export async function resolveAdapterSendToolsSettings(input, options = {}) {
         telegramAnyAllowed
             ? resolveTelegramSendToolSettings(input, options, {
                 send: telegramSendAllowed,
-                ask: telegramAskAllowed,
                 file: telegramFileAllowed,
-            }, telegramAskBridge)
+            })
             : undefined,
     ]);
     const askUser = options.suppressInteractionTools !== true && isAdapterToolAllowed("AskUser", options)
@@ -74,13 +68,15 @@ function resolveAskUserToolSettings(env, interaction) {
     const timeoutRaw = Number(optionalString(env.MONO_AGENT_ASK_USER_TIMEOUT_MS));
     const timeoutMs = interaction?.timeoutMs
         ?? (Number.isFinite(timeoutRaw) && timeoutRaw >= 1000 ? timeoutRaw : 600_000);
-    const conversationId = optionalString(env.MONO_AGENT_ADAPTER_TOOLS_PRODUCING_CONVERSATION_ID);
+    const producerConversationId = optionalString(env.MONO_AGENT_ADAPTER_TOOLS_PRODUCING_CONVERSATION_ID);
+    const interactionConversationId = optionalString(env.MONO_AGENT_ADAPTER_TOOLS_INTERACTION_CONVERSATION_ID);
     const runId = optionalString(env.MONO_AGENT_ADAPTER_TOOLS_PRODUCING_RUN_ID);
     return {
         bridgeUrl,
         bridgeToken,
         timeoutMs,
-        ...(conversationId === undefined ? {} : { conversationId }),
+        ...(producerConversationId === undefined ? {} : { producerConversationId }),
+        ...(interactionConversationId === undefined ? {} : { interactionConversationId }),
         ...(runId === undefined ? {} : { runId }),
     };
 }
@@ -92,9 +88,6 @@ export function adapterSendToolNames(settings) {
     if (settings.telegram?.tools.send === true) {
         names.push("TelegramSendMessage");
     }
-    if (settings.telegram?.tools.ask === true) {
-        names.push("TelegramAskButtons");
-    }
     if (settings.telegram?.tools.file === true) {
         names.push("TelegramSendFile");
     }
@@ -118,6 +111,9 @@ export function adapterSendToolsMcpEnv(configPath, allowedTools, context, intera
         ...(context?.conversationId === undefined
             ? {}
             : { MONO_AGENT_ADAPTER_TOOLS_PRODUCING_CONVERSATION_ID: context.conversationId }),
+        ...(context?.interactionConversationId === undefined
+            ? {}
+            : { MONO_AGENT_ADAPTER_TOOLS_INTERACTION_CONVERSATION_ID: context.interactionConversationId }),
         ...(context?.runId === undefined
             ? {}
             : { MONO_AGENT_ADAPTER_TOOLS_PRODUCING_RUN_ID: context.runId }),
@@ -199,6 +195,7 @@ export function adapterSendToolsMcpServerSpec(configPath, cwd, allowedTools, con
 export function createAdapterSendToolsRuntimeExtension(configPath, cwd, allowedTools, indexPath, interaction, runOutputRoot, deliveryHistoryCapabilityIssuer) {
     return async (input) => {
         const conversationId = input?.request?.conversationId;
+        const interactionConversationId = input?.request?.replyTo?.conversationId ?? conversationId;
         const runId = input?.runId;
         const hasConversation = typeof conversationId === "string" && conversationId.trim().length > 0;
         const hasRunId = typeof runId === "string" && runId.trim().length > 0;
@@ -224,6 +221,9 @@ export function createAdapterSendToolsRuntimeExtension(configPath, cwd, allowedT
         const context = hasConversation || hasRunId
             ? {
                 ...(hasConversation ? { conversationId } : {}),
+                ...(typeof interactionConversationId === "string" && interactionConversationId.trim().length > 0
+                    ? { interactionConversationId }
+                    : {}),
                 ...(hasRunId ? { runId } : {}),
                 ...(indexPath === undefined ? {} : { indexPath }),
                 ...(runOutput === undefined
@@ -281,24 +281,24 @@ export async function createAdapterSendToolsServer(settings, clients, indexing,
         registerSlackSendTool(server, settings.slack, clients.slack, adapter.formatMarkdownForSlack, indexing, options.deliveryHistory, options.fetchImpl ?? globalThis.fetch);
     }
     if (settings.telegram !== undefined && clients.telegram !== undefined) {
-        // Loaded once here (not per-register-call) because registerTelegramAskTool
-        // needs TELEGRAM_ASK_MAX_OPTIONS synchronously while building its zod
-        // schema, at registration time — not deferred into the request handler.
         const adapter = await loadTelegramModule();
-        if (settings.telegram.tools.send) {
-            registerTelegramSendTool(server, settings.telegram, clients.telegram, options.deliveryHistory, options.fetchImpl ?? globalThis.fetch);
-        }
-        if (settings.telegram.tools.ask) {
-            registerTelegramAskTool(server, settings.telegram, clients.telegram, adapter, options.fetchImpl ?? globalThis.fetch);
+        if (settings.telegram.tools.send && clients.telegram.sendMessage !== undefined) {
+            registerTelegramSendTool(server, settings.telegram, { sendMessage: clients.telegram.sendMessage }, adapter, options.deliveryHistory, options.fetchImpl ?? globalThis.fetch);
         }
-        if (settings.telegram.tools.file) {
+        if (settings.telegram.tools.file
+            && (clients.telegram.sendDocument !== undefined || clients.telegram.sendPhoto !== undefined)) {
             registerTelegramSendFileTool(server, settings.telegram, clients.telegram, adapter);
         }
     }
     // AskUser needs a target conversation; the parent app process resolves the
     // settings without one (for tool-name gating) and must not register the tool.
-    if (settings.askUser?.conversationId !== undefined) {
-        registerAskUserTool(server, { ...settings.askUser, conversationId: settings.askUser.conversationId }, options.fetchImpl ?? globalThis.fetch);
+    if (settings.askUser?.producerConversationId !== undefined
+        && settings.askUser.interactionConversationId !== undefined) {
+        registerAskUserTool(server, {
+            ...settings.askUser,
+            producerConversationId: settings.askUser.producerConversationId,
+            interactionConversationId: settings.askUser.interactionConversationId,
+        }, options.fetchImpl ?? globalThis.fetch);
     }
     return server;
 }
@@ -307,17 +307,26 @@ const ASK_USER_POLL_WAIT_MS = 20_000;
 function registerAskUserTool(server, settings, fetchImpl) {
     server.registerTool("AskUser", {
         title: "Ask the user and wait",
-        description: "Ask the user ONE consolidated free-text question on the current conversation and WAIT for their reply (blocking, up to the configured timeout — default 10 minutes). Returns the user's answer text. Consolidate everything you need into a single question — a second concurrent ask fails. If the wait times out, the tool returns without an answer and the user's late reply will arrive as their next message: finish the turn gracefully (proceed with sensible defaults and say what you assumed).",
+        description: "Ask 1–5 related questions and WAIT for the user to answer them in the current conversation. Each question must offer 2–3 concise options with descriptions; the UI also permits a custom reply. Use multiSelect only when several choices may be combined. Put long decision context or a draft in message. A second concurrent AskUser call fails. If the wait expires, finish gracefully using the returned partial answers and state any assumptions.",
         inputSchema: {
-            question: z.string().min(1).describe("The full question to show the user (plain text, no markdown)."),
+            message: z.string().min(1).max(4_096).optional().describe("Optional context or draft shown above the questions."),
+            questions: z.array(z.object({
+                header: z.string().min(1).max(12).describe("Short section label, at most 12 characters."),
+                question: z.string().min(1).max(1_000).describe("The decision or information needed."),
+                options: z.array(z.object({
+                    label: z.string().min(1).max(75).describe("Concise selectable answer."),
+                    description: z.string().min(1).max(300).describe("What choosing this option means."),
+                })).min(2).max(3),
+                multiSelect: z.boolean().optional().describe("Allow selecting more than one proposed answer before Done."),
+            })).min(1).max(5),
         },
     }, async (args, extra) => {
         const created = await askBridgeRequest(settings, fetchImpl, "POST", "/v1/asks", {
-            conversationId: settings.conversationId,
-            producerConversationId: settings.conversationId,
+            conversationId: settings.interactionConversationId,
+            producerConversationId: settings.producerConversationId,
             runId: settings.runId,
-            toolName: "AskUser",
-            question: args.question,
+            message: args.message,
+            questions: args.questions,
             timeoutMs: settings.timeoutMs,
         }, extra.signal);
         if (created.status === 409) {
@@ -326,44 +335,48 @@ function registerAskUserTool(server, settings, fetchImpl) {
         if (created.status === 501) {
             return askToolResult("This conversation's channel does not support interactive asks. Ask your question in your final reply instead.", { answered: false, reason: "unsupported_channel" });
         }
-        if (created.status !== 201 || typeof created.body.askId !== "string") {
+        if (created.status !== 201 || typeof created.body.interactionId !== "string") {
             throw new Error(`AskUser: the interaction bridge rejected the ask (HTTP ${String(created.status)}).`);
         }
-        return await awaitBridgeAsk(settings, created.body.askId, "AskUser", extra, fetchImpl, extra.signal);
+        return await awaitBridgeAsk(settings, created.body.interactionId, extra, fetchImpl, extra.signal);
     });
 }
-function askToolResult(text, structured, extraStructured = {}) {
+function askToolResult(text, structured) {
     return {
         content: [{ type: "text", text }],
-        structuredContent: { ok: true, ...extraStructured, ...structured },
+        structuredContent: { ok: true, ...structured },
     };
 }
-async function awaitBridgeAsk(settings, askId, toolName, extra, fetchImpl, signal, extraStructured = {}) {
+async function awaitBridgeAsk(settings, interactionId, extra, fetchImpl, signal) {
     const startedMs = Date.now();
     try {
         for (;;) {
-            const poll = await askBridgeRequest(settings, fetchImpl, "GET", `/v1/asks/${encodeURIComponent(askId)}?waitMs=${String(ASK_USER_POLL_WAIT_MS)}`, undefined, signal);
+            const poll = await askBridgeRequest(settings, fetchImpl, "GET", `/v1/asks/${encodeURIComponent(interactionId)}?waitMs=${String(ASK_USER_POLL_WAIT_MS)}`, undefined, signal);
             if (poll.status !== 200) {
-                throw new Error(`${toolName}: lost the pending ask (HTTP ${String(poll.status)}).`);
+                throw new Error(`AskUser: lost the pending ask (HTTP ${String(poll.status)}).`);
             }
             // Keep-alive: progress notifications reset the runtime's MCP inactivity
             // timeout so a long human wait cannot kill the tool call.
             await sendAskProgress(extra, Math.round((Date.now() - startedMs) / 1000));
             const status = poll.body.status;
-            if (status === "answered" && typeof poll.body.answer === "string") {
-                const answeredText = toolName === "TelegramAskButtons"
-                    ? `The user tapped:\n${poll.body.answer}`
-                    : `The user answered:\n${poll.body.answer}`;
-                return askToolResult(answeredText, { answered: true, answer: poll.body.answer }, extraStructured);
+            if (status === "answered") {
+                const answer = formatBridgeAskAnswers(poll.body);
+                return askToolResult(`The user answered:\n${answer.text}`, {
+                    answered: true,
+                    interactionId,
+                    answers: answer.answers,
+                });
             }
             if (status === "expired") {
-                return askToolResult("The user did not answer within the wait window. Their reply will arrive as their next message — wrap up this turn gracefully (proceed with sensible defaults and say what you assumed).", { answered: false, reason: "timeout" }, extraStructured);
+                const partial = formatBridgeAskAnswers(poll.body);
+                return askToolResult(`${partial.answers.length === 0 ? "The user did not answer" : `The user answered only:\n${partial.text}\n\nThe remaining questions were not answered`} within the wait window. Their next message will be a new turn; finish gracefully and state any assumptions.`, { answered: false, reason: "timeout", interactionId, answers: partial.answers });
             }
             if (status === "cancelled") {
                 return askToolResult("The user cancelled the current run. Stop this task.", {
                     answered: false,
                     reason: "cancelled",
-                }, extraStructured);
+                    interactionId,
+                });
             }
         }
     }
@@ -371,11 +384,56 @@ async function awaitBridgeAsk(settings, askId, toolName, extra, fetchImpl, signa
         // A cancelled MCP call must not leave a bridge ask pending until its full
         // human timeout. Cleanup gets its own bounded signal (not the aborted call
         // signal), and its failure must never replace the primary tool failure.
-        await cleanupBridgeAskBestEffort(settings, fetchImpl, askId);
+        await cleanupBridgeAskBestEffort(settings, fetchImpl, interactionId);
         throw error;
     }
 }
-async function cleanupBridgeAskBestEffort(settings, fetchImpl, askId) {
+function formatBridgeAskAnswers(body) {
+    const questions = Array.isArray(body.questions) ? body.questions : [];
+    const answers = Array.isArray(body.answers) ? body.answers : [];
+    const normalized = [];
+    const lines = [];
+    for (const rawAnswer of answers) {
+        if (typeof rawAnswer !== "object" || rawAnswer === null || Array.isArray(rawAnswer))
+            continue;
+        const answer = rawAnswer;
+        const questionId = typeof answer.questionId === "string" ? answer.questionId : undefined;
+        if (questionId === undefined)
+            continue;
+        const question = questions.find((candidate) => typeof candidate === "object"
+            && candidate !== null
+            && !Array.isArray(candidate)
+            && candidate.id === questionId);
+        const options = Array.isArray(question?.options) ? question.options : [];
+        const selectedOptionIds = Array.isArray(answer.selectedOptionIds)
+            ? answer.selectedOptionIds.filter((value) => typeof value === "string")
+            : [];
+        const selectedOptions = selectedOptionIds.flatMap((optionId) => {
+            const option = options.find((candidate) => typeof candidate === "object"
+                && candidate !== null
+                && !Array.isArray(candidate)
+                && candidate.id === optionId);
+            return typeof option?.label === "string"
+                ? [{ id: optionId, label: option.label, ...(typeof option.description === "string" ? { description: option.description } : {}) }]
+                : [];
+        });
+        const customReply = typeof answer.customReply === "string" ? answer.customReply : undefined;
+        const header = typeof question?.header === "string" ? question.header : questionId;
+        const rendered = [
+            ...selectedOptions.map((option) => option.label),
+            ...(customReply === undefined ? [] : [customReply]),
+        ].join(", ");
+        lines.push(`- ${header}: ${rendered}`);
+        normalized.push({
+            questionId,
+            header,
+            selectedOptions,
+            ...(customReply === undefined ? {} : { customReply }),
+        });
+    }
+    return { text: lines.join("\n") || "(no answers)", answers: normalized };
+}
+async function cleanupBridgeAskBestEffort(settings, fetchImpl, interactionId) {
     const controller = new AbortController();
     let deadlineTimer;
     const deadline = new Promise((resolve) => {
@@ -387,7 +445,7 @@ async function cleanupBridgeAskBestEffort(settings, fetchImpl, askId) {
     });
     // Attach the rejection handler before racing. If a test seam or nonstandard
     // fetch ignores abort and rejects later, it cannot become an unhandled error.
-    const cleanup = askBridgeRequest(settings, fetchImpl, "DELETE", `/v1/asks/${encodeURIComponent(askId)}`, undefined, controller.signal).then(() => undefined, () => undefined);
+    const cleanup = askBridgeRequest(settings, fetchImpl, "DELETE", `/v1/asks/${encodeURIComponent(interactionId)}`, undefined, controller.signal).then(() => undefined, () => undefined);
     try {
         await Promise.race([cleanup, deadline]);
     }
@@ -566,25 +624,41 @@ function registerSlackSendTool(server, settings, client, formatMarkdownForSlack,
         };
     });
 }
-function registerTelegramSendTool(server, settings, client, deliveryHistory, fetchImpl = globalThis.fetch) {
+function registerTelegramSendTool(server, settings, client, adapter, deliveryHistory, fetchImpl = globalThis.fetch) {
     server.registerTool("TelegramSendMessage", {
         title: "Send Telegram message",
-        description: "Send a message to an allowed Telegram chat using the configured Telegram adapter bot token.",
+        description: "Send a message to an allowed Telegram chat. Optionally add 2–8 non-blocking reply buttons; a tap arrives later as a new user turn.",
         inputSchema: {
             chat_id: z.union([z.string().min(1), z.number().int()]).describe("Telegram chat id from the adapter allowlist."),
             text: z.string().min(1).describe("Message text to send."),
             parse_mode: z.string().min(1).optional().describe("Optional Telegram parse mode, e.g. MarkdownV2 or HTML."),
             reply_to_message_id: z.number().int().optional().describe("Optional message id to reply to."),
             disable_web_page_preview: z.boolean().optional().describe("Disable Telegram link previews."),
+            reply_options: z
+                .array(z.string().min(1).max(75))
+                .min(2)
+                .max(8)
+                .optional()
+                .describe("Optional non-blocking reply button labels. Use AskUser when this run must wait for the selection."),
         },
     }, async (args, extra) => {
-        assertTelegramChatAllowed(settings, args.chat_id);
+        assertTelegramChatAllowed(settings, args.chat_id, "TelegramSendMessage");
         const result = await client.sendMessage({
             chat_id: args.chat_id,
             text: args.text,
             ...(args.parse_mode === undefined ? {} : { parse_mode: args.parse_mode }),
             ...(args.reply_to_message_id === undefined ? {} : { reply_to_message_id: args.reply_to_message_id }),
             ...(args.disable_web_page_preview === undefined ? {} : { disable_web_page_preview: args.disable_web_page_preview }),
+            ...(args.reply_options === undefined
+                ? {}
+                : {
+                    reply_markup: {
+                        inline_keyboard: args.reply_options.map((label, index) => [{
+                                text: label,
+                                callback_data: adapter.telegramReplyCallbackData(index),
+                            }]),
+                    },
+                }),
         }, { signal: extra.signal });
         const history = await recordAdapterDeliveryHistory({
             settings: deliveryHistory,
@@ -600,211 +674,53 @@ function registerTelegramSendTool(server, settings, client, deliveryHistory, fet
                 ok: true,
                 chat_id: result.chat.id,
                 message_id: result.message_id,
+                ...(args.reply_options === undefined ? {} : { reply_options: args.reply_options }),
                 ...(history === undefined ? {} : { history }),
             },
         };
     });
 }
-/** Marker appended (buttons kept) when a Telegram ask times out. */
-const TELEGRAM_ASK_EXPIRED_MARKER = "⌛ Expired — tapping a button still reaches me and starts a new turn.";
-/** Marker appended (buttons kept) when a Telegram ask is cancelled. */
-const TELEGRAM_ASK_CANCELLED_MARKER = "🚫 Cancelled — tapping a button still reaches me and starts a new turn.";
-/** Bounded own-signal budget for the best-effort expiry edit — never the aborted call signal. */
-const TELEGRAM_ASK_EXPIRY_EDIT_TIMEOUT_MS = 2_000;
-/** A Telegram 400 is the parse-entity rejection we fall back from (raw text, no parse_mode). */
-function isTelegramParseError(error, adapter) {
-    return error instanceof adapter.TelegramApiError && error.errorCode === 400;
-}
-/**
- * Send the ask keyboard rendered as MarkdownV2, retrying ONCE with the raw source and
- * no parse_mode when Telegram rejects the entities with a 400 parse error. Any other
- * failure propagates so the caller can clean up a pending bridge ask.
- */
-async function sendTelegramAskKeyboard(client, adapter, params) {
-    try {
-        return await client.sendMessage({
-            chat_id: params.chat_id,
-            text: params.rendered,
-            parse_mode: "MarkdownV2",
-            reply_markup: params.replyMarkup,
-        }, { signal: params.signal });
-    }
-    catch (error) {
-        if (!isTelegramParseError(error, adapter)) {
-            throw error;
-        }
-        return await client.sendMessage({
-            chat_id: params.chat_id,
-            text: params.rawSource,
-            reply_markup: params.replyMarkup,
-        }, { signal: params.signal });
-    }
-}
-/**
- * Best-effort: append an expiry/cancel note to the buttons message while KEEPING the
- * inline keyboard (Telegram strips the keyboard on `editMessageText` unless reply_markup
- * is re-sent). Renders through the same MarkdownV2-with-plain-fallback path. Uses its own
- * bounded signal — never the aborted call signal — and swallows every failure so a failed
- * edit can never replace the primary ask result.
- */
-async function editExpiredTelegramAskMessage(client, adapter, params) {
-    try {
-        const source = `${params.rawSource}\n\n${params.marker}`;
-        const rendered = adapter.renderTelegramMarkdown(source);
-        const signal = AbortSignal.timeout(TELEGRAM_ASK_EXPIRY_EDIT_TIMEOUT_MS);
-        try {
-            await client.editMessageText({
-                chat_id: params.chat_id,
-                message_id: params.message_id,
-                text: rendered,
-                parse_mode: "MarkdownV2",
-                reply_markup: params.replyMarkup,
-            }, { signal });
-        }
-        catch (error) {
-            if (!isTelegramParseError(error, adapter)) {
-                throw error;
-            }
-            await client.editMessageText({
-                chat_id: params.chat_id,
-                message_id: params.message_id,
-                text: source,
-                reply_markup: params.replyMarkup,
-            }, { signal });
-        }
-    }
-    catch {
-        // Best-effort: a failed expiry edit must never replace the ask result.
-    }
-}
-function registerTelegramAskTool(server, settings, client, adapter, fetchImpl) {
-    server.registerTool("TelegramAskButtons", {
-        title: "Ask via Telegram buttons",
-        description: "Ask the owner a question in an allowed Telegram chat with tappable inline-keyboard buttons (e.g. a confirmation or a multiple-choice). By default WAITS for their tap (up to the ask timeout) and returns the tapped label; a second concurrent ask in the same chat fails. On a proactive or scheduled turn (cron/heartbeat) set `wait:false`: the buttons are sent and the tool returns immediately, and the tap arrives later as a new message quoting the question.",
-        inputSchema: {
-            chat_id: z.union([z.string().min(1), z.number().int()]).describe("Telegram chat id from the adapter allowlist."),
-            question: z.string().min(1).describe("The question to show above the buttons."),
-            options: z
-                .array(z.string().min(1).max(100))
-                .min(2)
-                .max(adapter.TELEGRAM_ASK_MAX_OPTIONS)
-                .describe("Button labels (2–8). The label the user taps is echoed back as a new message."),
-            note: z.string().min(1).optional().describe("Optional extra context shown beneath the question."),
-            wait: z
-                .boolean()
-                .optional()
-                .describe("Default true: block until the user taps (up to the ask timeout). Set false on proactive/scheduled (cron/heartbeat) turns — send the buttons and return immediately; the tapped answer arrives later as a new message quoting the question."),
-        },
-    }, async (args, extra) => {
-        assertTelegramChatAllowed(settings, args.chat_id);
-        const inlineKeyboard = args.options.map((label, index) => [
-            { text: label, callback_data: adapter.telegramAskCallbackData(index) },
-        ]);
-        const replyMarkup = { inline_keyboard: inlineKeyboard };
-        // Raw source is what the bridge records and what the plain-text fallback (and the
-        // expiry edit) re-send; the rendered form is only for the MarkdownV2 send.
-        const source = args.note === undefined ? args.question : `${args.question}\n\n${args.note}`;
-        const rendered = adapter.renderTelegramMarkdown(source);
-        // Non-blocking mode (proactive/scheduled turns): send the buttons and return.
-        // No bridge is consulted — this must work even with no bridge configured.
-        if (args.wait === false) {
-            const sent = await sendTelegramAskKeyboard(client, adapter, {
-                chat_id: args.chat_id,
-                rendered,
-                rawSource: source,
-                replyMarkup,
-                signal: extra.signal,
-            });
-            return askToolResult(`Sent the question with ${String(args.options.length)} buttons to ${String(sent.chat.id)} (message ${String(sent.message_id)}). Not waiting — the tapped answer will arrive as a new message.`, { answered: false, reason: "not_waiting" }, { chat_id: sent.chat.id, message_id: sent.message_id, options: args.options });
-        }
-        // Blocking mode requires the interaction bridge to correlate the tap.
-        const bridge = settings.askBridge;
-        if (bridge === undefined) {
-            return askToolResult("TelegramAskButtons requires a live interaction bridge, but none is configured.", {
-                answered: false,
-                reason: "unsupported_channel",
-            });
-        }
-        const conversationId = `telegram:${String(args.chat_id)}`;
-        const created = await askBridgeRequest(bridge, fetchImpl, "POST", "/v1/asks", {
-            conversationId,
-            producerConversationId: bridge.conversationId,
-            runId: bridge.runId,
-            toolName: "TelegramAskButtons",
-            question: source,
-            options: args.options,
-            timeoutMs: bridge.timeoutMs,
-            postQuestion: false,
-            answerKind: "callback",
-        }, extra.signal);
-        if (created.status === 409) {
-            return askToolResult("A question is already pending for this Telegram chat. Wait for its answer instead of asking again.", { answered: false, reason: "already_pending" }, { chat_id: args.chat_id });
-        }
-        if (created.status === 501) {
-            return askToolResult("This Telegram chat is not registered with the interaction bridge. Ask your question in your final reply instead.", { answered: false, reason: "unsupported_channel" }, { chat_id: args.chat_id });
-        }
-        if (created.status !== 201 || typeof created.body.askId !== "string") {
-            throw new Error(`TelegramAskButtons: the interaction bridge rejected the ask (HTTP ${String(created.status)}).`);
-        }
-        const askId = created.body.askId;
-        let result;
-        try {
-            result = await sendTelegramAskKeyboard(client, adapter, {
-                chat_id: args.chat_id,
-                rendered,
-                rawSource: source,
-                replyMarkup,
-                signal: extra.signal,
-            });
-        }
-        catch (error) {
-            await cleanupBridgeAskBestEffort(bridge, fetchImpl, askId);
-            throw error;
-        }
-        const askResult = await awaitBridgeAsk(bridge, askId, "TelegramAskButtons", extra, fetchImpl, extra.signal, {
-            chat_id: result.chat.id,
-            message_id: result.message_id,
-            options: args.options,
-        });
-        // An expired/cancelled ask leaves a live-looking keyboard forever; append a note
-        // while keeping the buttons (a tap still starts a fresh turn). Best-effort only.
-        const reason = askResult.structuredContent.reason;
-        if (reason === "timeout" || reason === "cancelled") {
-            await editExpiredTelegramAskMessage(client, adapter, {
-                chat_id: result.chat.id,
-                message_id: result.message_id,
-                rawSource: source,
-                marker: reason === "timeout" ? TELEGRAM_ASK_EXPIRED_MARKER : TELEGRAM_ASK_CANCELLED_MARKER,
-                replyMarkup,
-            });
-        }
-        return askResult;
-    });
-}
 /**
  * Register the single `TelegramSendFile` tool. A required `kind` param selects
  * `"document"` (any file, shown as a downloadable document) or `"photo"` (an image
  * shown inline). Both accept the file as base64 `data` (with a `filename`) OR a
  * workspace `path` (filename derived from the basename), enforce the adapter
  * allowlist, and bound the size to the adapter's inbound cap before uploading via
- * the adapter-owned sender.
+ * the adapter-owned sender. Producing-conversation scope omits `chat_id` from the
+ * schema and derives it from trusted request context instead.
  */
 function registerTelegramSendFileTool(server, settings, client, adapter) {
+    const producingConversationScope = settings.sendTools?.scope === "producing-conversation";
+    const inputSchema = {
+        kind: z.enum(["document", "photo"]).describe("`document` for any file (downloadable), `photo` for an image shown inline."),
+        ...(producingConversationScope
+            ? {}
+            : {
+                chat_id: z
+                    .union([z.string().min(1), z.number().int()])
+                    .describe("Telegram chat id from the adapter allowlist."),
+            }),
+        data: z.string().min(1).optional().describe("Base64-encoded file bytes. Provide this or `path`."),
+        path: z.string().min(1).optional().describe("Path to a file to upload (resolved against the agent working dir). Provide this or `data`."),
+        filename: z.string().min(1).optional().describe("Filename to present. Required with `data` for a document; derived from `path` otherwise."),
+        caption: z.string().min(1).optional().describe("Optional caption shown with the file."),
+    };
     server.registerTool("TelegramSendFile", {
         title: "Send Telegram file",
-        description: "Upload and send a file to an allowed Telegram chat. Set `kind:\"document\"` to send any file (shown as a downloadable document) or `kind:\"photo\"` to send an image inline. Provide the bytes as base64 `data` (with a `filename` — required for a document), or a workspace `path`. A self-hosted Bot API can stream legacy path uploads; strict run-output paths are always read through a pinned descriptor.",
-        inputSchema: {
-            kind: z.enum(["document", "photo"]).describe("`document` for any file (downloadable), `photo` for an image shown inline."),
-            chat_id: z.union([z.string().min(1), z.number().int()]).describe("Telegram chat id from the adapter allowlist."),
-            data: z.string().min(1).optional().describe("Base64-encoded file bytes. Provide this or `path`."),
-            path: z.string().min(1).optional().describe("Path to a file to upload (resolved against the agent working dir). Provide this or `data`."),
-            filename: z.string().min(1).optional().describe("Filename to present. Required with `data` for a document; derived from `path` otherwise."),
-            caption: z.string().min(1).optional().describe("Optional caption shown with the file."),
-        },
+        description: producingConversationScope
+            ? "Upload and send a file to the Telegram conversation that produced this run. The host binds the destination; provide only the file content or path. Set `kind:\"document\"` to send any file (shown as a downloadable document) or `kind:\"photo\"` to send an image inline. Strict run-output paths are always read through a pinned descriptor."
+            : "Upload and send a file to an allowed Telegram chat. Set `kind:\"document\"` to send any file (shown as a downloadable document) or `kind:\"photo\"` to send an image inline. Provide the bytes as base64 `data` (with a `filename` — required for a document), or a workspace `path`. A self-hosted Bot API can stream legacy path uploads.",
+        inputSchema,
     }, async (args, extra) => {
         extra.signal.throwIfAborted();
         const kind = args.kind;
-        assertTelegramChatAllowed(settings, args.chat_id);
+        const sendDocument = client.sendDocument;
+        const sendPhoto = client.sendPhoto;
+        if ((kind === "document" && sendDocument === undefined) || (kind === "photo" && sendPhoto === undefined)) {
+            throw new Error(`TelegramSendFile: the ${kind} sender is unavailable.`);
+        }
+        const requestedChatId = "chat_id" in args ? args.chat_id : undefined;
+        const chatId = resolveTelegramSendFileChatId(settings, requestedChatId);
         if ((args.data !== undefined) === (args.path !== undefined)) {
             throw new Error("provide exactly one of `data` (base64) or `path`.");
         }
@@ -829,16 +745,13 @@ function registerTelegramSendFileTool(server, settings, client, adapter) {
                 throw new Error(`file exceeds the ${String(maxUploadBytes)}-byte upload cap.`);
             }
             try {
-                const sent = await client.sendDocument({
-                    chat_id: args.chat_id,
+                const sent = await sendDocument({
+                    chat_id: chatId,
                     document: pathToFileURL(uploadPath).href,
                     ...(args.caption === undefined ? {} : { caption: args.caption }),
                 }, { signal: extra.signal });
                 const name = basename(uploadPath);
-                return {
-                    content: [{ type: "text", text: `Sent ${kind} ${sent.message_id} (${name}) to ${String(sent.chat.id)}.` }],
-                    structuredContent: { ok: true, chat_id: sent.chat.id, message_id: sent.message_id, filename: name },
-                };
+                return telegramSendFileResult(producingConversationScope, kind, sent, name);
             }
             catch (error) {
                 // Retry buffered exactly once; rethrow anything that isn't a server-side rejection.
@@ -857,24 +770,50 @@ function registerTelegramSendFileTool(server, settings, client, adapter) {
             signal: extra.signal,
         });
         const result = kind === "document"
-            ? await client.sendDocument({
-                chat_id: args.chat_id,
+            ? await sendDocument({
+                chat_id: chatId,
                 document: bytes,
                 filename,
                 ...(args.caption === undefined ? {} : { caption: args.caption }),
             }, { signal: extra.signal })
-            : await client.sendPhoto({
-                chat_id: args.chat_id,
+            : await sendPhoto({
+                chat_id: chatId,
                 photo: bytes,
                 filename,
                 ...(args.caption === undefined ? {} : { caption: args.caption }),
             }, { signal: extra.signal });
-        return {
-            content: [{ type: "text", text: `Sent ${kind} ${result.message_id} (${filename}) to ${String(result.chat.id)}.` }],
-            structuredContent: { ok: true, chat_id: result.chat.id, message_id: result.message_id, filename },
-        };
+        return telegramSendFileResult(producingConversationScope, kind, result, filename);
     });
 }
+function resolveTelegramSendFileChatId(settings, requestedChatId) {
+    if (settings.sendTools?.scope === "producing-conversation") {
+        const producingChatId = telegramChatIdFromConversation(settings.producingConversationId);
+        if (producingChatId === undefined) {
+            throw new Error("TelegramSendFile: producing Telegram conversation context is unavailable.");
+        }
+        assertTelegramChatAllowed(settings, producingChatId, "TelegramSendFile");
+        return producingChatId;
+    }
+    if (requestedChatId === undefined) {
+        throw new Error("TelegramSendFile: chat_id is required outside producing-conversation scope.");
+    }
+    assertTelegramChatAllowed(settings, requestedChatId, "TelegramSendFile");
+    return requestedChatId;
+}
+function telegramSendFileResult(producingConversationScope, kind, sent, filename) {
+    const destination = producingConversationScope
+        ? "the producing Telegram conversation"
+        : String(sent.chat.id);
+    return {
+        content: [{ type: "text", text: `Sent ${kind} ${sent.message_id} (${filename}) to ${destination}.` }],
+        structuredContent: {
+            ok: true,
+            ...(producingConversationScope ? {} : { chat_id: sent.chat.id }),
+            message_id: sent.message_id,
+            filename,
+        },
+    };
+}
 /** Resolve the upload bytes + filename from exactly one of base64 `data` or a `path`. */
 async function resolveTelegramFileBytes(input) {
     const hasData = input.data !== undefined;
@@ -1033,7 +972,7 @@ async function resolveSlackSendToolSettings(input, options) {
         return undefined;
     }
 }
-async function resolveTelegramSendToolSettings(input, options, tools, askBridge) {
+async function resolveTelegramSendToolSettings(input, options, tools) {
     try {
         const adapter = await loadTelegramModule();
         const config = await adapter.loadTelegramAdapterConfig({ env: input.env, jsonPath: input.configPath });
@@ -1050,7 +989,6 @@ async function resolveTelegramSendToolSettings(input, options, tools, askBridge)
             ...(config.apiRoot === undefined ? {} : { apiRoot: config.apiRoot }),
             maxUploadBytes: config.attachments?.maxUploadBytes ?? adapter.DEFAULT_ATTACHMENT_MAX_BYTES,
             tools,
-            ...(askBridge === undefined ? {} : { askBridge }),
             ...(config.sendTools === undefined ? {} : { sendTools: config.sendTools }),
             ...(producingConversationId === undefined ? {} : { producingConversationId }),
             ...(runOutputDir === undefined ? {} : { runOutputDir }),
@@ -1070,21 +1008,21 @@ function assertSlackChannelAllowed(settings, channel) {
     }
     throw new Error("SlackSendMessage: channel is not allowed by Slack adapter config.");
 }
-function assertTelegramChatAllowed(settings, chatId) {
+function assertTelegramChatAllowed(settings, chatId, toolName) {
     const normalized = String(chatId);
     if (settings.sendTools?.scope === "producing-conversation") {
         const producingChatId = telegramChatIdFromConversation(settings.producingConversationId);
         if (producingChatId === undefined) {
-            throw new Error("TelegramSendMessage: producing Telegram conversation context is unavailable.");
+            throw new Error(`${toolName}: producing Telegram conversation context is unavailable.`);
         }
         if (normalized !== producingChatId) {
-            throw new Error("TelegramSendMessage: chat_id must match the producing Telegram conversation.");
+            throw new Error(`${toolName}: chat_id must match the producing Telegram conversation.`);
         }
     }
     if (settings.allowAllChats || settings.allowedChatIds.includes(normalized)) {
         return;
     }
-    throw new Error("TelegramSendMessage: chat_id is not allowed by Telegram adapter config.");
+    throw new Error(`${toolName}: chat_id is not allowed by Telegram adapter config.`);
 }
 function telegramChatIdFromConversation(conversationId) {
     if (conversationId === undefined)