@poolzin/pool-bot 2026.3.25 → 2026.3.27

package/dist/telegram/lane-delivery-text-deliverer.js

@@ -0,0 +1,357 @@
+import { isRecoverableTelegramNetworkError, isSafeToRetrySendError, isTelegramClientRejection, } from "./network-errors.js";
+const MESSAGE_NOT_MODIFIED_RE = /400:\s*Bad Request:\s*message is not modified|MESSAGE_NOT_MODIFIED/i;
+const MESSAGE_NOT_FOUND_RE = /400:\s*Bad Request:\s*message to edit not found|MESSAGE_ID_INVALID|message can't be edited/i;
+function extractErrorText(err) {
+    return typeof err === "string"
+        ? err
+        : err instanceof Error
+            ? err.message
+            : typeof err === "object" && err && "description" in err
+                ? typeof err.description === "string"
+                    ? err.description
+                    : ""
+                : "";
+}
+function isMessageNotModifiedError(err) {
+    return MESSAGE_NOT_MODIFIED_RE.test(extractErrorText(err));
+}
+/**
+ * Returns true when Telegram rejects an edit because the target message can no
+ * longer be resolved or edited. The caller still needs preview context to
+ * decide whether to retain a different visible preview or fall back to send.
+ */
+function isMissingPreviewMessageError(err) {
+    return MESSAGE_NOT_FOUND_RE.test(extractErrorText(err));
+}
+function shouldSkipRegressivePreviewUpdate(args) {
+    const currentPreviewText = args.currentPreviewText;
+    if (currentPreviewText === undefined) {
+        return false;
+    }
+    return (currentPreviewText.startsWith(args.text) &&
+        args.text.length < currentPreviewText.length &&
+        (args.skipRegressive === "always" || args.hadPreviewMessage));
+}
+function resolvePreviewTarget(params) {
+    const lanePreviewMessageId = params.lane.stream?.messageId();
+    const previewMessageId = typeof params.previewMessageIdOverride === "number"
+        ? params.previewMessageIdOverride
+        : lanePreviewMessageId;
+    const hadPreviewMessage = typeof params.previewMessageIdOverride === "number" || typeof lanePreviewMessageId === "number";
+    return {
+        hadPreviewMessage,
+        previewMessageId: typeof previewMessageId === "number" ? previewMessageId : undefined,
+        stopCreatesFirstPreview: params.stopBeforeEdit && !hadPreviewMessage && params.context === "final",
+    };
+}
+export function createLaneTextDeliverer(params) {
+    const getLanePreviewText = (lane) => lane.lastPartialText;
+    const markActivePreviewComplete = (laneName) => {
+        params.activePreviewLifecycleByLane[laneName] = "complete";
+        params.retainPreviewOnCleanupByLane[laneName] = true;
+    };
+    const isDraftPreviewLane = (lane) => lane.stream?.previewMode?.() === "draft";
+    const canMaterializeDraftFinal = (lane, previewButtons) => {
+        const hasPreviewButtons = Boolean(previewButtons && previewButtons.length > 0);
+        return (isDraftPreviewLane(lane) &&
+            !hasPreviewButtons &&
+            typeof lane.stream?.materialize === "function");
+    };
+    const tryMaterializeDraftPreviewForFinal = async (args) => {
+        const stream = args.lane.stream;
+        if (!stream || !isDraftPreviewLane(args.lane)) {
+            return false;
+        }
+        // Draft previews have no message_id to edit; materialize the final text
+        // into a real message and treat that as the finalized delivery.
+        stream.update(args.text);
+        const materializedMessageId = await stream.materialize?.();
+        if (typeof materializedMessageId !== "number") {
+            params.log(`telegram: ${args.laneName} draft preview materialize produced no message id; falling back to standard send`);
+            return false;
+        }
+        args.lane.lastPartialText = args.text;
+        params.markDelivered();
+        return true;
+    };
+    const tryEditPreviewMessage = async (args) => {
+        try {
+            await params.editPreview({
+                laneName: args.laneName,
+                messageId: args.messageId,
+                text: args.text,
+                previewButtons: args.previewButtons,
+                context: args.context,
+            });
+            if (args.updateLaneSnapshot) {
+                args.lane.lastPartialText = args.text;
+            }
+            params.markDelivered();
+            return "edited";
+        }
+        catch (err) {
+            if (isMessageNotModifiedError(err)) {
+                params.log(`telegram: ${args.laneName} preview ${args.context} edit returned "message is not modified"; treating as delivered`);
+                params.markDelivered();
+                return "edited";
+            }
+            if (args.context === "final") {
+                if (args.finalTextAlreadyLanded) {
+                    params.log(`telegram: ${args.laneName} preview final edit failed after stop flush; keeping existing preview (${String(err)})`);
+                    params.markDelivered();
+                    return "retained";
+                }
+                if (isSafeToRetrySendError(err)) {
+                    params.log(`telegram: ${args.laneName} preview final edit failed before reaching Telegram; falling back to standard send (${String(err)})`);
+                    return "fallback";
+                }
+                if (isMissingPreviewMessageError(err)) {
+                    if (args.retainAlternatePreviewOnMissingTarget) {
+                        params.log(`telegram: ${args.laneName} preview final edit target missing; keeping alternate preview without fallback (${String(err)})`);
+                        params.markDelivered();
+                        return "retained";
+                    }
+                    params.log(`telegram: ${args.laneName} preview final edit target missing with no alternate preview; falling back to standard send (${String(err)})`);
+                    return "fallback";
+                }
+                if (isRecoverableTelegramNetworkError(err, { allowMessageMatch: true })) {
+                    params.log(`telegram: ${args.laneName} preview final edit may have landed despite network error; keeping existing preview (${String(err)})`);
+                    params.markDelivered();
+                    return "retained";
+                }
+                if (isTelegramClientRejection(err)) {
+                    params.log(`telegram: ${args.laneName} preview final edit rejected by Telegram (client error); falling back to standard send (${String(err)})`);
+                    return "fallback";
+                }
+                // Default: ambiguous error — prefer incomplete over duplicate
+                params.log(`telegram: ${args.laneName} preview final edit failed with ambiguous error; keeping existing preview to avoid duplicate (${String(err)})`);
+                params.markDelivered();
+                return "retained";
+            }
+            params.log(`telegram: ${args.laneName} preview ${args.context} edit failed; falling back to standard send (${String(err)})`);
+            return "fallback";
+        }
+    };
+    const tryUpdatePreviewForLane = async ({ lane, laneName, text, previewButtons, stopBeforeEdit = false, updateLaneSnapshot = false, skipRegressive, context, previewMessageId: previewMessageIdOverride, previewTextSnapshot, }) => {
+        const editPreview = (messageId, finalTextAlreadyLanded, retainAlternatePreviewOnMissingTarget) => tryEditPreviewMessage({
+            laneName,
+            messageId,
+            text,
+            context,
+            previewButtons,
+            updateLaneSnapshot,
+            lane,
+            finalTextAlreadyLanded,
+            retainAlternatePreviewOnMissingTarget,
+        });
+        const finalizePreview = (previewMessageId, finalTextAlreadyLanded, hadPreviewMessage, retainAlternatePreviewOnMissingTarget = false) => {
+            const currentPreviewText = previewTextSnapshot ?? getLanePreviewText(lane);
+            const shouldSkipRegressive = shouldSkipRegressivePreviewUpdate({
+                currentPreviewText,
+                text,
+                skipRegressive,
+                hadPreviewMessage,
+            });
+            if (shouldSkipRegressive) {
+                params.markDelivered();
+                return "edited";
+            }
+            return editPreview(previewMessageId, finalTextAlreadyLanded, retainAlternatePreviewOnMissingTarget);
+        };
+        if (!lane.stream) {
+            return "fallback";
+        }
+        const previewTargetBeforeStop = resolvePreviewTarget({
+            lane,
+            previewMessageIdOverride,
+            stopBeforeEdit,
+            context,
+        });
+        if (previewTargetBeforeStop.stopCreatesFirstPreview) {
+            // Final stop() can create the first visible preview message.
+            // Prime pending text so the stop flush sends the final text snapshot.
+            lane.stream.update(text);
+            await params.stopDraftLane(lane);
+            const previewTargetAfterStop = resolvePreviewTarget({
+                lane,
+                stopBeforeEdit: false,
+                context,
+            });
+            if (typeof previewTargetAfterStop.previewMessageId !== "number") {
+                return "fallback";
+            }
+            return finalizePreview(previewTargetAfterStop.previewMessageId, true, false);
+        }
+        if (stopBeforeEdit) {
+            await params.stopDraftLane(lane);
+        }
+        const previewTargetAfterStop = resolvePreviewTarget({
+            lane,
+            previewMessageIdOverride,
+            stopBeforeEdit: false,
+            context,
+        });
+        if (typeof previewTargetAfterStop.previewMessageId !== "number") {
+            // Only retain for final delivery when a prior preview is already visible
+            // to the user — otherwise falling back is safer than silence. For updates,
+            // always fall back so the caller can attempt sendPayload without stale
+            // markDelivered() state.
+            if (context === "final" && lane.hasStreamedMessage && lane.stream?.sendMayHaveLanded?.()) {
+                params.log(`telegram: ${laneName} preview send may have landed despite missing message id; keeping to avoid duplicate`);
+                params.markDelivered();
+                return "retained";
+            }
+            return "fallback";
+        }
+        const activePreviewMessageId = lane.stream?.messageId();
+        return finalizePreview(previewTargetAfterStop.previewMessageId, false, previewTargetAfterStop.hadPreviewMessage, typeof activePreviewMessageId === "number" &&
+            activePreviewMessageId !== previewTargetAfterStop.previewMessageId);
+    };
+    const consumeArchivedAnswerPreviewForFinal = async ({ lane, text, payload, previewButtons, canEditViaPreview, }) => {
+        const archivedPreview = params.archivedAnswerPreviews.shift();
+        if (!archivedPreview) {
+            return undefined;
+        }
+        if (canEditViaPreview) {
+            const finalized = await tryUpdatePreviewForLane({
+                lane,
+                laneName: "answer",
+                text,
+                previewButtons,
+                stopBeforeEdit: false,
+                skipRegressive: "existingOnly",
+                context: "final",
+                previewMessageId: archivedPreview.messageId,
+                previewTextSnapshot: archivedPreview.textSnapshot,
+            });
+            if (finalized === "edited") {
+                return "preview-finalized";
+            }
+            if (finalized === "retained") {
+                params.retainPreviewOnCleanupByLane.answer = true;
+                return "preview-retained";
+            }
+        }
+        // Send the replacement message first, then clean up the old preview.
+        // This avoids the visual "disappear then reappear" flash.
+        const delivered = await params.sendPayload(params.applyTextToPayload(payload, text));
+        // Once this archived preview is consumed by a fallback final send, delete it
+        // regardless of deleteIfUnused. That flag only applies to unconsumed boundaries.
+        if (delivered || archivedPreview.deleteIfUnused !== false) {
+            try {
+                await params.deletePreviewMessage(archivedPreview.messageId);
+            }
+            catch (err) {
+                params.log(`telegram: archived answer preview cleanup failed (${archivedPreview.messageId}): ${String(err)}`);
+            }
+        }
+        return delivered ? "sent" : "skipped";
+    };
+    return async ({ laneName, text, payload, infoKind, previewButtons, allowPreviewUpdateForNonFinal = false, }) => {
+        const lane = params.lanes[laneName];
+        const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
+        const canEditViaPreview = !hasMedia && text.length > 0 && text.length <= params.draftMaxChars && !payload.isError;
+        if (infoKind === "final") {
+            // Transient previews must decide cleanup retention per final attempt.
+            // Completed previews intentionally stay retained so later extra payloads
+            // do not clear the already-finalized message.
+            if (params.activePreviewLifecycleByLane[laneName] === "transient") {
+                params.retainPreviewOnCleanupByLane[laneName] = false;
+            }
+            if (laneName === "answer") {
+                const archivedResult = await consumeArchivedAnswerPreviewForFinal({
+                    lane,
+                    text,
+                    payload,
+                    previewButtons,
+                    canEditViaPreview,
+                });
+                if (archivedResult) {
+                    return archivedResult;
+                }
+            }
+            if (canEditViaPreview && params.activePreviewLifecycleByLane[laneName] === "transient") {
+                await params.flushDraftLane(lane);
+                if (laneName === "answer") {
+                    const archivedResultAfterFlush = await consumeArchivedAnswerPreviewForFinal({
+                        lane,
+                        text,
+                        payload,
+                        previewButtons,
+                        canEditViaPreview,
+                    });
+                    if (archivedResultAfterFlush) {
+                        return archivedResultAfterFlush;
+                    }
+                }
+                if (canMaterializeDraftFinal(lane, previewButtons)) {
+                    const materialized = await tryMaterializeDraftPreviewForFinal({
+                        lane,
+                        laneName,
+                        text,
+                    });
+                    if (materialized) {
+                        markActivePreviewComplete(laneName);
+                        return "preview-finalized";
+                    }
+                }
+                const finalized = await tryUpdatePreviewForLane({
+                    lane,
+                    laneName,
+                    text,
+                    previewButtons,
+                    stopBeforeEdit: true,
+                    skipRegressive: "existingOnly",
+                    context: "final",
+                });
+                if (finalized === "edited") {
+                    markActivePreviewComplete(laneName);
+                    return "preview-finalized";
+                }
+                if (finalized === "retained") {
+                    markActivePreviewComplete(laneName);
+                    return "preview-retained";
+                }
+            }
+            else if (!hasMedia && !payload.isError && text.length > params.draftMaxChars) {
+                params.log(`telegram: preview final too long for edit (${text.length} > ${params.draftMaxChars}); falling back to standard send`);
+            }
+            await params.stopDraftLane(lane);
+            const delivered = await params.sendPayload(params.applyTextToPayload(payload, text));
+            return delivered ? "sent" : "skipped";
+        }
+        if (allowPreviewUpdateForNonFinal && canEditViaPreview) {
+            if (isDraftPreviewLane(lane)) {
+                // DM draft flow has no message_id to edit; updates are sent via sendMessageDraft.
+                // Only mark as updated when the draft flush actually emits an update.
+                const previewRevisionBeforeFlush = lane.stream?.previewRevision?.() ?? 0;
+                lane.stream?.update(text);
+                await params.flushDraftLane(lane);
+                const previewUpdated = (lane.stream?.previewRevision?.() ?? 0) > previewRevisionBeforeFlush;
+                if (!previewUpdated) {
+                    params.log(`telegram: ${laneName} draft preview update not emitted; falling back to standard send`);
+                    const delivered = await params.sendPayload(params.applyTextToPayload(payload, text));
+                    return delivered ? "sent" : "skipped";
+                }
+                lane.lastPartialText = text;
+                params.markDelivered();
+                return "preview-updated";
+            }
+            const updated = await tryUpdatePreviewForLane({
+                lane,
+                laneName,
+                text,
+                previewButtons,
+                stopBeforeEdit: false,
+                updateLaneSnapshot: true,
+                skipRegressive: "always",
+                context: "update",
+            });
+            if (updated === "edited") {
+                return "preview-updated";
+            }
+        }
+        const delivered = await params.sendPayload(params.applyTextToPayload(payload, text));
+        return delivered ? "sent" : "skipped";
+    };
+}

package/dist/telegram/lane-delivery.js

@@ -0,0 +1,2 @@
+export { createLaneTextDeliverer, } from "./lane-delivery-text-deliverer.js";
+export { createLaneDeliveryStateTracker, } from "./lane-delivery-state.js";

package/dist/telegram/normalize.js

@@ -0,0 +1,37 @@
+import { normalizeTelegramLookupTarget, parseTelegramTarget } from "./targets.js";
+const TELEGRAM_PREFIX_RE = /^(telegram|tg):/i;
+function normalizeTelegramTargetBody(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const prefixStripped = trimmed.replace(TELEGRAM_PREFIX_RE, "").trim();
+    if (!prefixStripped) {
+        return undefined;
+    }
+    const parsed = parseTelegramTarget(trimmed);
+    const normalizedChatId = normalizeTelegramLookupTarget(parsed.chatId);
+    if (!normalizedChatId) {
+        return undefined;
+    }
+    const keepLegacyGroupPrefix = /^group:/i.test(prefixStripped);
+    const hasTopicSuffix = /:topic:\d+$/i.test(prefixStripped);
+    const chatSegment = keepLegacyGroupPrefix ? `group:${normalizedChatId}` : normalizedChatId;
+    if (parsed.messageThreadId == null) {
+        return chatSegment;
+    }
+    const threadSuffix = hasTopicSuffix
+        ? `:topic:${parsed.messageThreadId}`
+        : `:${parsed.messageThreadId}`;
+    return `${chatSegment}${threadSuffix}`;
+}
+export function normalizeTelegramMessagingTarget(raw) {
+    const normalizedBody = normalizeTelegramTargetBody(raw);
+    if (!normalizedBody) {
+        return undefined;
+    }
+    return `telegram:${normalizedBody}`.toLowerCase();
+}
+export function looksLikeTelegramTargetId(raw) {
+    return normalizeTelegramTargetBody(raw) !== undefined;
+}

package/dist/telegram/onboarding.js

@@ -0,0 +1,192 @@
+import { applySingleTokenPromptResult, patchChannelConfigForAccount, promptSingleChannelSecretInput, promptResolvedAllowFrom, resolveAccountIdForConfigure, resolveOnboardingAccountId, setChannelDmPolicyWithAllowFrom, setOnboardingChannelEnabled, splitOnboardingEntries, } from "../../../src/channels/plugins/onboarding/helpers.js";
+import { formatCliCommand } from "../../../src/cli/command-format.js";
+import { hasConfiguredSecretInput } from "../../../src/config/types.secrets.js";
+import { DEFAULT_ACCOUNT_ID } from "../../../src/routing/session-key.js";
+import { formatDocsLink } from "../../../src/terminal/links.js";
+import { inspectTelegramAccount } from "./account-inspect.js";
+import { listTelegramAccountIds, resolveDefaultTelegramAccountId, resolveTelegramAccount, } from "./accounts.js";
+import { fetchTelegramChatId } from "./api-fetch.js";
+const channel = "telegram";
+async function noteTelegramTokenHelp(prompter) {
+    await prompter.note([
+        "1) Open Telegram and chat with @BotFather",
+        "2) Run /newbot (or /mybots)",
+        "3) Copy the token (looks like 123456:ABC...)",
+        "Tip: you can also set TELEGRAM_BOT_TOKEN in your env.",
+        `Docs: ${formatDocsLink("/telegram")}`,
+        "Website: https://openclaw.ai",
+    ].join("\n"), "Telegram bot token");
+}
+async function noteTelegramUserIdHelp(prompter) {
+    await prompter.note([
+        `1) DM your bot, then read from.id in \`${formatCliCommand("openclaw logs --follow")}\` (safest)`,
+        "2) Or call https://api.telegram.org/bot<bot_token>/getUpdates and read message.from.id",
+        "3) Third-party: DM @userinfobot or @getidsbot",
+        `Docs: ${formatDocsLink("/telegram")}`,
+        "Website: https://openclaw.ai",
+    ].join("\n"), "Telegram user id");
+}
+export function normalizeTelegramAllowFromInput(raw) {
+    return raw
+        .trim()
+        .replace(/^(telegram|tg):/i, "")
+        .trim();
+}
+export function parseTelegramAllowFromId(raw) {
+    const stripped = normalizeTelegramAllowFromInput(raw);
+    return /^\d+$/.test(stripped) ? stripped : null;
+}
+async function promptTelegramAllowFrom(params) {
+    const { cfg, prompter, accountId } = params;
+    const resolved = resolveTelegramAccount({ cfg, accountId });
+    const existingAllowFrom = resolved.config.allowFrom ?? [];
+    await noteTelegramUserIdHelp(prompter);
+    const token = params.tokenOverride?.trim() || resolved.token;
+    if (!token) {
+        await prompter.note("Telegram token missing; username lookup is unavailable.", "Telegram");
+    }
+    const unique = await promptResolvedAllowFrom({
+        prompter,
+        existing: existingAllowFrom,
+        token,
+        message: "Telegram allowFrom (numeric sender id; @username resolves to id)",
+        placeholder: "@username",
+        label: "Telegram allowlist",
+        parseInputs: splitOnboardingEntries,
+        parseId: parseTelegramAllowFromId,
+        invalidWithoutTokenNote: "Telegram token missing; use numeric sender ids (usernames require a bot token).",
+        resolveEntries: async ({ token: tokenValue, entries }) => {
+            const results = await Promise.all(entries.map(async (entry) => {
+                const numericId = parseTelegramAllowFromId(entry);
+                if (numericId) {
+                    return { input: entry, resolved: true, id: numericId };
+                }
+                const stripped = normalizeTelegramAllowFromInput(entry);
+                if (!stripped) {
+                    return { input: entry, resolved: false, id: null };
+                }
+                const username = stripped.startsWith("@") ? stripped : `@${stripped}`;
+                const id = await fetchTelegramChatId({ token: tokenValue, chatId: username });
+                return { input: entry, resolved: Boolean(id), id };
+            }));
+            return results;
+        },
+    });
+    return patchChannelConfigForAccount({
+        cfg,
+        channel: "telegram",
+        accountId,
+        patch: { dmPolicy: "allowlist", allowFrom: unique },
+    });
+}
+async function promptTelegramAllowFromForAccount(params) {
+    const accountId = resolveOnboardingAccountId({
+        accountId: params.accountId,
+        defaultAccountId: resolveDefaultTelegramAccountId(params.cfg),
+    });
+    return promptTelegramAllowFrom({
+        cfg: params.cfg,
+        prompter: params.prompter,
+        accountId,
+    });
+}
+const dmPolicy = {
+    label: "Telegram",
+    channel,
+    policyKey: "channels.telegram.dmPolicy",
+    allowFromKey: "channels.telegram.allowFrom",
+    getCurrent: (cfg) => cfg.channels?.telegram?.dmPolicy ?? "pairing",
+    setPolicy: (cfg, policy) => setChannelDmPolicyWithAllowFrom({
+        cfg,
+        channel: "telegram",
+        dmPolicy: policy,
+    }),
+    promptAllowFrom: promptTelegramAllowFromForAccount,
+};
+export const telegramOnboardingAdapter = {
+    channel,
+    getStatus: async ({ cfg }) => {
+        const configured = listTelegramAccountIds(cfg).some((accountId) => {
+            const account = inspectTelegramAccount({ cfg, accountId });
+            return account.configured;
+        });
+        return {
+            channel,
+            configured,
+            statusLines: [`Telegram: ${configured ? "configured" : "needs token"}`],
+            selectionHint: configured ? "recommended · configured" : "recommended · newcomer-friendly",
+            quickstartScore: configured ? 1 : 10,
+        };
+    },
+    configure: async ({ cfg, prompter, options, accountOverrides, shouldPromptAccountIds, forceAllowFrom, }) => {
+        const defaultTelegramAccountId = resolveDefaultTelegramAccountId(cfg);
+        const telegramAccountId = await resolveAccountIdForConfigure({
+            cfg,
+            prompter,
+            label: "Telegram",
+            accountOverride: accountOverrides.telegram,
+            shouldPromptAccountIds,
+            listAccountIds: listTelegramAccountIds,
+            defaultAccountId: defaultTelegramAccountId,
+        });
+        let next = cfg;
+        const resolvedAccount = resolveTelegramAccount({
+            cfg: next,
+            accountId: telegramAccountId,
+        });
+        const hasConfiguredBotToken = hasConfiguredSecretInput(resolvedAccount.config.botToken);
+        const hasConfigToken = hasConfiguredBotToken || Boolean(resolvedAccount.config.tokenFile?.trim());
+        const accountConfigured = Boolean(resolvedAccount.token) || hasConfigToken;
+        const allowEnv = telegramAccountId === DEFAULT_ACCOUNT_ID;
+        const canUseEnv = allowEnv && !hasConfigToken && Boolean(process.env.TELEGRAM_BOT_TOKEN?.trim());
+        if (!accountConfigured) {
+            await noteTelegramTokenHelp(prompter);
+        }
+        const tokenResult = await promptSingleChannelSecretInput({
+            cfg: next,
+            prompter,
+            providerHint: "telegram",
+            credentialLabel: "Telegram bot token",
+            secretInputMode: options?.secretInputMode,
+            accountConfigured,
+            canUseEnv,
+            hasConfigToken,
+            envPrompt: "TELEGRAM_BOT_TOKEN detected. Use env var?",
+            keepPrompt: "Telegram token already configured. Keep it?",
+            inputPrompt: "Enter Telegram bot token",
+            preferredEnvVar: allowEnv ? "TELEGRAM_BOT_TOKEN" : undefined,
+        });
+        let resolvedTokenForAllowFrom;
+        if (tokenResult.action === "use-env") {
+            next = applySingleTokenPromptResult({
+                cfg: next,
+                channel: "telegram",
+                accountId: telegramAccountId,
+                tokenPatchKey: "botToken",
+                tokenResult: { useEnv: true, token: null },
+            });
+            resolvedTokenForAllowFrom = process.env.TELEGRAM_BOT_TOKEN?.trim() || undefined;
+        }
+        else if (tokenResult.action === "set") {
+            next = applySingleTokenPromptResult({
+                cfg: next,
+                channel: "telegram",
+                accountId: telegramAccountId,
+                tokenPatchKey: "botToken",
+                tokenResult: { useEnv: false, token: tokenResult.value },
+            });
+            resolvedTokenForAllowFrom = tokenResult.resolvedValue;
+        }
+        if (forceAllowFrom) {
+            next = await promptTelegramAllowFrom({
+                cfg: next,
+                prompter,
+                accountId: telegramAccountId,
+                tokenOverride: resolvedTokenForAllowFrom,
+            });
+        }
+        return { cfg: next, accountId: telegramAccountId };
+    },
+    dmPolicy,
+    disable: (cfg) => setOnboardingChannelEnabled(cfg, channel, false),
+};