pi-harness-runtime 1.1.427 → 1.1.429

package/packages/telegram/src/bindings.js

@@ -1,1086 +0,0 @@
-/**
- * Telegram bridge binding composition
- * Zones: telegram, pi agent, orchestration
- * Owns pi-facing tool, command, and lifecycle hook registration for the entrypoint
- */
-import * as ActivityVerbosity from "./activity-verbosity.js";
-import * as Activity from "./activity.js";
-import * as BusApi from "./bus-api.js";
-import * as ChannelPosts from "./channel-posts.js";
-import * as CommandTemplates from "./command-templates.js";
-import * as Commands from "./commands.js";
-import * as Config from "./config.js";
-import * as Delivery from "./delivery.js";
-import * as GenerativeApps from "./generative-apps.js";
-import * as Lifecycle from "./lifecycle.js";
-import * as Menu from "./menu.js";
-import * as OutboundAttachments from "./outbound-attachments.js";
-import * as OutboundHandlers from "./outbound.js";
-import * as Pi from "./pi.js";
-import * as Prompts from "./prompts.js";
-import * as Queue from "./queue.js";
-import * as Replies from "./replies.js";
-import * as Routing from "./routing.js";
-import * as Runtime from "./runtime.js";
-import * as Setup from "./setup.js";
-import * as TelegramApi from "./telegram-api.js";
-/** Compose any registered held command over captured recipient effects; no ordinary follower API fallback. */
-export function createTelegramFollowerSelectedCommandBinding(deps) {
-    const { ctx, operationId, registrationGeneration, name, recipient, command, deliver, recordOwnership, } = deps, target = { ...deps.target };
-    const prepare = command.prepareHeldCommand, canPrepare = command.canPrepareHeldCommand;
-    const isCurrent = recipient.isCurrent, assertRecipientCurrent = recipient.assertRecipientCurrent, menu = deps.menu, menuPorts = menu && { ...menu };
-    if ([
-        prepare,
-        canPrepare,
-        isCurrent,
-        assertRecipientCurrent,
-        deliver,
-        recordOwnership,
-    ].some((port) => typeof port !== "function") ||
-        (menuPorts &&
-            [
-                menuPorts.getModelMenuState,
-                menuPorts.storeModelMenuState,
-                menuPorts.getActiveModel,
-                menuPorts.getThinkingLevel,
-                menuPorts.buildStatusHtml,
-                menuPorts.isIdle,
-                menuPorts.canOfferInFlightModelSwitch,
-            ].some((port) => typeof port !== "function")))
-        return undefined;
-    const portsCurrent = () => deps.ctx === ctx &&
-        deps.operationId === operationId &&
-        deps.registrationGeneration === registrationGeneration &&
-        deps.name === name &&
-        deps.recipient === recipient &&
-        recipient.isCurrent === isCurrent &&
-        recipient.assertRecipientCurrent === assertRecipientCurrent &&
-        deps.command === command &&
-        command.prepareHeldCommand === prepare &&
-        command.canPrepareHeldCommand === canPrepare &&
-        deps.deliver === deliver &&
-        deps.recordOwnership === recordOwnership &&
-        deps.menu === menu &&
-        (!menuPorts ||
-            Object.entries(menuPorts).every(([key, value]) => Reflect.get(menu, key) === value));
-    const current = () => portsCurrent() && isCurrent.call(recipient) && portsCurrent();
-    if (!current())
-        return undefined;
-    const api = BusApi.createTelegramSelectedMenuTextApi({
-        operationId,
-        registrationGeneration,
-        target,
-        assertAuthority: assertRecipientCurrent,
-        deliver,
-    });
-    const rendered = Replies.createTelegramRenderedMessageDeliveryRuntime({
-        sendMessage: api.sendMessage,
-        editMessage: api.editMessageText,
-        recordOwnership,
-        async sendRichMessage() {
-            throw new Error("Selected command has no rich or ordinary API fallback.");
-        },
-    });
-    const menus = menuPorts &&
-        Menu.createTelegramMenuActionRuntime({
-            ...menuPorts,
-            sendTextReply: rendered.sendTextReply,
-            sendInteractiveMessage: rendered.sendInteractiveMessage,
-            editInteractiveMessage: rendered.editInteractiveMessage,
-        });
-    const effects = {
-        sendTextReply: rendered.sendTextReply,
-        ...(menus ? { showStatus: menus.sendStatusMessage } : {}),
-    };
-    if (!canPrepare.call(command, name, effects) || !current())
-        return undefined;
-    return {
-        isCurrent: current,
-        assertRecipientCurrent,
-        prepare(readiness, context, input) {
-            if (!current() ||
-                context !== ctx ||
-                input.target.chatId !== target.chatId ||
-                input.target.threadId !== target.threadId ||
-                input.assertRecipientCurrent !== assertRecipientCurrent)
-                return undefined;
-            const plan = prepare.call(command, name, readiness, context, input, effects);
-            return current() ? plan : undefined;
-        },
-    };
-}
-export function createTelegramQueueBindingRuntime(deps) {
-    const settleDiscardedItems = (items, ctx) => {
-        const durableItems = items.filter((item) => (item.admissionReceipts?.length ?? 0) > 0);
-        if (durableItems.length === 0)
-            return true;
-        const settlement = deps.admission.getSettlement();
-        if (!settlement)
-            return false;
-        return settlement.onItemsDiscarded(durableItems, ctx) === true;
-    };
-    const mutation = Queue.createTelegramQueueMutationController({
-        ...deps.store,
-        hasPendingDispatch: deps.lifecycle.hasDispatchPending,
-        allocateLaneOrder: deps.queue.allocateItemOrder,
-        onItemsDiscarded(items, ctx) {
-            if (!settleDiscardedItems(items, ctx)) {
-                throw new Error("Telegram queue items could not be discarded durably.");
-            }
-        },
-        updateStatus: deps.updateStatus,
-        recordRuntimeEvent: deps.recordRuntimeEvent,
-    });
-    const dispatch = Queue.createTelegramQueueDispatchRuntime({
-        ...deps.store,
-        isCompactionInProgress: deps.lifecycle.isCompactionInProgress,
-        hasActiveTurn: deps.activeTurn.has,
-        hasDispatchPending: deps.lifecycle.hasDispatchPending,
-        isIdle: deps.isIdle,
-        hasPendingMessages: deps.hasPendingMessages,
-        hasDispatchContext: deps.deferredDispatch.isBound,
-        getDispatchGeneration: deps.deferredDispatch.getGeneration,
-        isDispatchGenerationActive: deps.deferredDispatch.isGenerationActive,
-        isQueueItemTransportActive(item) {
-            return deps.transportStamp.isActive(item.transportStamp);
-        },
-        hasPendingInboundQueueMutationForItem(item) {
-            return deps.admission.hasPendingQueueMutationForItem(item);
-        },
-        isQueueItemAdmissionReady(item) {
-            return (deps.admission.getSettlement()?.isItemReady(item) ??
-                (item.admissionReceipts?.length ?? 0) === 0);
-        },
-        commitPromptDispatch(item, ctx) {
-            if ((item.admissionReceipts?.length ?? 0) === 0)
-                return true;
-            const settlement = deps.admission.getSettlement();
-            if (!settlement?.onPromptHandedOff)
-                return false;
-            return settlement.onPromptHandedOff(item, ctx) === true;
-        },
-        onControlSettled(item, ctx) {
-            deps.admission.getSettlement()?.onControlSettled(item, ctx);
-        },
-        onPromptSkipped(item, ctx) {
-            return settleDiscardedItems([item], ctx);
-        },
-        updateStatus: deps.updateStatus,
-        sendTextReply: deps.sendTextReply,
-        reconcileNextDispatchAnnouncementReplyOwnership: deps.reconcileNextDispatchAnnouncementReplyOwnership,
-        recordRuntimeEvent: deps.recordRuntimeEvent,
-        ...deps.promptDispatch,
-        sendUserMessage: deps.sendUserMessage,
-    });
-    return {
-        mutation,
-        dispatchNext: dispatch.dispatchNext,
-        requestNextDispatchAnnouncement: dispatch.requestNextDispatchAnnouncement,
-        cancelNextDispatchAnnouncement: dispatch.cancelNextDispatchAnnouncement,
-        watchdog: Queue.createTelegramQueueDispatchWatchdogRuntime({
-            hasQueuedItems: deps.store.hasQueuedItems,
-            dispatchNextQueuedTelegramTurn: dispatch.dispatchNext,
-            recordRuntimeEvent: deps.recordRuntimeEvent,
-        }),
-    };
-}
-export function createTelegramGenerativeAppLiveSurfaceBinding() {
-    let current;
-    return {
-        get() {
-            return current;
-        },
-        set(runtime) {
-            current?.shutdown();
-            current = runtime;
-        },
-        shutdown() {
-            current?.shutdown();
-            current = undefined;
-        },
-    };
-}
-export function createTelegramGenerativeAppBoundButtonActionInvoker(deps) {
-    return async (action, query) => {
-        let boundAction;
-        let handedOff;
-        try {
-            boundAction = GenerativeApps.parseGenerativeAppBoundAction(action.prompt);
-            if (!boundAction)
-                return false;
-            deps.assertExecutionCurrent(query);
-            const chatId = query.message?.chat?.id;
-            const messageId = query.message?.message_id;
-            if (typeof chatId !== "number" || typeof messageId !== "number") {
-                throw new Error("Generative App callback target is unavailable.");
-            }
-            const liveSurfaces = deps.getLiveSurfaceRuntime?.();
-            handedOff = liveSurfaces?.take(GenerativeApps.getTelegramBindLiveSurfaceKey(boundAction.app, deps.getActiveProfileName?.() ?? "default", {
-                chatId,
-                ...(query.message?.message_thread_id !== undefined
-                    ? { threadId: query.message.message_thread_id }
-                    : {}),
-            }));
-            const result = await GenerativeApps.invokeGenerativeApp({
-                agentDir: deps.agentDir,
-                ...(deps.getExecutionFence(query)
-                    ? { execution: deps.getExecutionFence(query) }
-                    : {}),
-                ...(boundAction.argument !== undefined
-                    ? { argument: boundAction.argument }
-                    : {}),
-                ...(action.binding?.app === boundAction.app
-                    ? {
-                        expectedGeneration: action.binding.generation,
-                        expectedRevision: action.binding.revision,
-                    }
-                    : {}),
-                method: boundAction.method,
-                app: boundAction.app,
-            });
-            deps.assertExecutionCurrent(query);
-            const reply = deps.planOutput(result.output, {
-                binding: {
-                    generation: result.generation,
-                    app: result.app,
-                    revision: result.revision,
-                },
-            });
-            if (handedOff && liveSurfaces) {
-                try {
-                    await liveSurfaces.resume(handedOff, result);
-                    deps.assertExecutionCurrent(query);
-                    return "edit";
-                }
-                catch (error) {
-                    deps.recordRuntimeEvent("generative-app", error, {
-                        phase: "bound-action-live-edit-fallback",
-                        app: boundAction.app,
-                        method: boundAction.method,
-                    });
-                }
-            }
-            if (result.viewMode === "edit" && deps.editInteractiveMessage) {
-                let editFailed = false;
-                try {
-                    await deps.editInteractiveMessage(chatId, messageId, reply.markdown, "markdown", reply.replyMarkup ?? { inline_keyboard: [] });
-                }
-                catch (error) {
-                    editFailed = true;
-                    deps.recordRuntimeEvent("generative-app", error, {
-                        phase: "bound-action-edit-fallback",
-                        app: boundAction.app,
-                        method: boundAction.method,
-                    });
-                }
-                deps.assertExecutionCurrent(query);
-                if (!editFailed)
-                    return "edit";
-            }
-            deps.assertExecutionCurrent(query);
-            await deps.sendMarkdownReply(chatId, messageId, reply.markdown, {
-                replyMarkup: reply.replyMarkup,
-            });
-            deps.assertExecutionCurrent(query);
-            return "new";
-        }
-        catch (error) {
-            if (handedOff)
-                deps.getLiveSurfaceRuntime?.()?.open(handedOff);
-            deps.recordRuntimeEvent("generative-app", error, {
-                phase: "bound-action",
-                ...(boundAction
-                    ? { app: boundAction.app, method: boundAction.method }
-                    : {}),
-            });
-            throw error;
-        }
-    };
-}
-export function createTelegramAgentMessageToolRoutingRuntime(deps) {
-    return {
-        async resolveAgentTarget(selector) {
-            if (!deps.ownsLeader())
-                return deps.follower.resolveTarget(selector);
-            const target = deps.local.resolveTarget(selector, deps.getSourceTarget());
-            if (!target) {
-                throw new Error("Telegram agent target is unavailable, ambiguous, or not live.");
-            }
-            return target;
-        },
-        async routeAgentMessage(message) {
-            if (!deps.ownsLeader())
-                return deps.follower.routeMessage(message);
-            await deps.local.route({
-                sourceTarget: deps.getSourceTarget(),
-                sourceThreadName: deps.getSourceThreadName(),
-                message,
-            });
-        },
-        canSendDirect() {
-            return deps.ownsDirectDelivery() || deps.isFollowerRegistered();
-        },
-    };
-}
-export function createTelegramAssistantOutputBindingRuntime(deps) {
-    const authority = Routing.createTelegramAssistantOutputAuthorityRuntime(deps.authority);
-    const sendOutput = OutboundHandlers.createTelegramAssistantOutputSender(deps.sender);
-    const runtime = Activity.createTelegramAssistantOutputRuntime({
-        ...authority,
-        enqueue: deps.enqueue,
-        prepareSend: (event) => event.source === "telegram" ? deps.prepareTelegramPreview?.() : undefined,
-        async send(event, authority, isAuthorityActive) {
-            await deps.waitForActivityIdle?.();
-            if (!isAuthorityActive())
-                return;
-            await sendOutput(event, authority, isAuthorityActive);
-        },
-        recordFailure(event, error) {
-            deps.recordRuntimeEvent("proactive-push", error, {
-                activityId: event.activityId,
-                sequence: event.sequence,
-                placement: event.placement,
-            });
-        },
-    });
-    return {
-        runtime,
-        authority,
-        observeEvent(event) {
-            if (event.type === "assistant-segment")
-                runtime.accept(event);
-        },
-    };
-}
-/** Compose public activity fanout, verbosity, and assistant output ordering. */
-export function createTelegramActivityBindingRuntime(deps) {
-    const publication = Activity.createTelegramActivityPublicationRuntime();
-    const assistantOutputBinding = createTelegramAssistantOutputBindingRuntime({
-        ...deps.assistantOutput,
-        enqueue: publication.enqueue,
-    });
-    const activityVerbosityRuntime = ActivityVerbosity.createTelegramActivityVerbosityRuntime({
-        ...deps.activityVerbosity,
-        enqueue: publication.enqueue,
-        captureAuthority: assistantOutputBinding.authority.captureAuthority,
-        isAuthorityActive: assistantOutputBinding.authority.isAuthorityActive,
-        recordFailure(operation, event, error) {
-            deps.assistantOutput.recordRuntimeEvent("activity", error, {
-                operation,
-                eventType: event.type,
-                activityId: event.activityId,
-            });
-        },
-    });
-    const activityRuntime = Activity.createTelegramActivityBridgeRuntime({
-        generation: deps.generation,
-        observeEvent(event) {
-            assistantOutputBinding.observeEvent(event);
-            activityVerbosityRuntime.accept(event);
-        },
-        recordFailure(handlerId, event, error) {
-            deps.assistantOutput.recordRuntimeEvent("activity", error, {
-                handlerId,
-                eventType: event.type,
-                activityId: event.activityId,
-            });
-        },
-    });
-    return {
-        activityRuntime: {
-            ...activityRuntime,
-            onSessionStart() {
-                publication.reset();
-                activityRuntime.onSessionStart?.();
-            },
-            onSessionShutdown() {
-                publication.reset();
-                activityRuntime.onSessionShutdown();
-            },
-        },
-        activityVerbosityRuntime,
-        assistantOutputRuntime: assistantOutputBinding.runtime,
-        publicationRuntime: {
-            enqueue: publication.enqueue,
-            reserve: publication.reserve,
-            hasPending: publication.hasPending,
-            beginWork: publication.beginWork,
-            hasUnconfirmed: publication.hasUnconfirmed,
-            capture() {
-                const authority = assistantOutputBinding.authority.captureAuthority();
-                return {
-                    target: authority.target ? { ...authority.target } : undefined,
-                    isCurrent: () => assistantOutputBinding.authority.isAuthorityActive(authority),
-                };
-            },
-        },
-    };
-}
-/** Fresh current work projection; a snapshot is not a cleanup grant or target-application ACK. */
-export function createTelegramLiveTargetWorkObserver(deps) {
-    return (target, ctx) => {
-        const work = Queue.observeTelegramTargetQueueWork(target, deps.activeTurn.get(), deps.queue.getQueuedItems());
-        const flags = [
-            deps.isIdle(ctx),
-            deps.hasPendingMessages(ctx),
-            deps.lifecycle.hasDispatchPending(),
-            deps.lifecycle.isCompactionInProgress(),
-            deps.hasPendingControl(),
-        ];
-        const tools = deps.lifecycle.getActiveToolExecutions();
-        const publication = deps.publication.hasPending(), unconfirmed = deps.publication.hasUnconfirmed?.(), activity = deps.activity.hasPending?.(), delivery = deps.delivery.hasPendingTarget(target), api = deps.api.hasPendingTarget(target);
-        const unknown = work.unknown ||
-            flags.some((flag) => typeof flag !== "boolean") ||
-            !Number.isSafeInteger(tools) ||
-            tools < 0 ||
-            unconfirmed !== false ||
-            [publication, activity, delivery, api].some((flag) => typeof flag !== "boolean");
-        return {
-            sessionBusy: flags[0] !== true || flags.slice(1).some(Boolean) || tools > 0,
-            targetWork: work.protected,
-            deliveryPending: publication === true ||
-                activity === true ||
-                delivery === true ||
-                api === true,
-            unknown,
-        };
-    };
-}
-export function registerTelegramCommandsAndTools({ pi, agentDir, configStore, persistConfig, setup, activeTurnRuntime, lockedPollingRuntime, stopPolling, getDisconnectThreadName, onTransportChanged, getStatusLines, buttonActionStore, sendMarkdownReply, sendChannelMarkdownMessage, sendChannelMediaMessage, listChannelPosts, mutateChannelPost, callMultipart, getDefaultChatId, getDefaultTarget, resolveAgentTarget, routeAgentMessage, canSendDirect, setGenerativeAppLiveSurfaceRuntime, recordRuntimeEvent, updateStatus, isContextCurrent, getSessionGeneration, connectionIntent, }) {
-    GenerativeApps.registerTelegramBindTool(pi, {
-        agentDir,
-        getActiveProfileName: configStore.getActiveProfileName,
-        getActiveTurn: activeTurnRuntime.get,
-        ...(setGenerativeAppLiveSurfaceRuntime
-            ? { setLiveSurfaceRuntime: setGenerativeAppLiveSurfaceRuntime }
-            : {}),
-        isDeliveryHandleCurrent: Delivery.isTelegramDeliveryHandleCurrent,
-        editView: (handle, view) => Delivery.editTelegramView(handle, view),
-        planOutput: OutboundHandlers.createTelegramOutboundReplyPlanner(buttonActionStore, Config.createTelegramConfigControls(configStore)
-            .getAssistantRenderingMode),
-        sendMarkdownReply,
-        sendView: (view, options) => Delivery.sendTelegramView(view, options),
-        recordRuntimeEvent,
-    });
-    ChannelPosts.registerTelegramChannelPostMutationTool(pi, {
-        mutate: mutateChannelPost,
-    });
-    ChannelPosts.registerTelegramChannelPostListTool(pi, {
-        list: listChannelPosts,
-    });
-    OutboundAttachments.registerTelegramOutboundAttachmentTool(pi, {
-        getActiveTurn: activeTurnRuntime.get,
-        getDefaultChatId,
-        getDefaultTarget,
-        canSendDirect,
-        sendMultipart: callMultipart,
-        recordRuntimeEvent,
-    });
-    OutboundAttachments.registerTelegramOutboundMessageTool(pi, {
-        getDefaultChatId,
-        getDefaultTarget,
-        getActiveTurn: activeTurnRuntime.get,
-        resolveAgentTarget,
-        routeAgentMessage,
-        canSendDirect,
-        planMessage: OutboundHandlers.createTelegramOutboundReplyPlanner(buttonActionStore, Config.createTelegramConfigControls(configStore)
-            .getAssistantRenderingMode),
-        sendMarkdownMessage: (chatId, markdown, options) => sendMarkdownReply(chatId, undefined, markdown, options),
-        sendChannelMarkdownMessage,
-        sendChannelMediaMessage,
-        recordRuntimeEvent,
-    });
-    const queueAgentConnectionContext = (connected) => {
-        pi.sendMessage({
-            customType: "telegram-connection-state",
-            content: connected
-                ? Prompts.TELEGRAM_CONNECTED_CONTEXT_MESSAGE
-                : Prompts.TELEGRAM_DISCONNECTED_CONTEXT_MESSAGE,
-            display: false,
-        }, { deliverAs: "nextTurn" });
-    };
-    Commands.registerTelegramBridgeCommands(pi, {
-        promptForConfig: async (ctx, profileName) => {
-            const nextProfileName = profileName ?? undefined;
-            if (profileName && !Config.isValidTelegramProfileName(profileName)) {
-                ctx.ui.notify(`Invalid Telegram profile name: ${profileName}`, "error");
-                return;
-            }
-            const previousProfileName = configStore.getActiveProfileName();
-            let setupConfigStore = configStore;
-            let persistSetupConfig = persistConfig;
-            if (!profileName) {
-                if (previousProfileName !== nextProfileName) {
-                    await (stopPolling ?? lockedPollingRuntime.stop)();
-                }
-                configStore.activateProfile(undefined);
-                await onTransportChanged?.();
-            }
-            else {
-                const storedConfig = configStore.getStoredConfig();
-                setupConfigStore = Config.createTelegramConfigStore({
-                    initialConfig: {
-                        ...storedConfig,
-                        profiles: {
-                            ...(storedConfig.profiles ?? {}),
-                            [profileName]: storedConfig.profiles?.[profileName] ?? {
-                                botToken: "",
-                            },
-                        },
-                    },
-                });
-                setupConfigStore.activateProfile(profileName);
-                persistSetupConfig = async () => {
-                    try {
-                        if (previousProfileName !== profileName) {
-                            await (stopPolling ?? lockedPollingRuntime.stop)();
-                        }
-                        const profile = Config.getTelegramProfileFields(setupConfigStore.get());
-                        if (!profile) {
-                            throw new Error(`Telegram profile "${profileName}" has no token.`);
-                        }
-                        await configStore.load();
-                        const latestProfile = configStore.getStoredConfig().profiles?.[profileName];
-                        configStore.setProfile(profileName, {
-                            ...profile,
-                            threadDisplayMode: latestProfile?.threadDisplayMode,
-                        });
-                        configStore.activateProfile(profileName);
-                        await onTransportChanged?.();
-                        await persistConfig(configStore.get());
-                    }
-                    catch (error) {
-                        await configStore.load().catch(() => undefined);
-                        configStore.activateProfile(previousProfileName);
-                        await onTransportChanged?.();
-                        throw error;
-                    }
-                };
-            }
-            const runSetup = Setup.createTelegramSetupPromptRuntime({
-                getConfig: setupConfigStore.get,
-                setConfig: setupConfigStore.set,
-                setupGuard: setup,
-                getMe: TelegramApi.fetchTelegramBotIdentity,
-                resolveBotToken: (value) => Config.resolveTelegramBotToken(value, process.env),
-                describeBotToken: (value) => Config.getTelegramBotTokenDiagnostic(value, process.env),
-                persistConfig: persistSetupConfig,
-                startPolling: lockedPollingRuntime.start,
-                updateStatus,
-                recordRuntimeEvent,
-            });
-            const completion = await runSetup(ctx);
-            if (completion.status === "success") {
-                queueAgentConnectionContext(true);
-                if (profileName) {
-                    ctx.ui.notify(`Profile "${profileName}" saved and connected.`, "info");
-                }
-            }
-        },
-        getStatusLines,
-        reloadConfig: configStore.load,
-        hasBotToken: configStore.hasBotToken,
-        getBotTokenDiagnostic: configStore.getBotTokenDiagnostic,
-        startPolling: lockedPollingRuntime.start,
-        recordConnectionEvent: (error, phase) => recordRuntimeEvent("connection", error, { phase }),
-        stopPolling: stopPolling ?? lockedPollingRuntime.stop,
-        getDisconnectThreadName,
-        queueAgentConnectionContext,
-        updateStatus,
-        isContextCurrent,
-        getSessionGeneration,
-        connectionIntent,
-        getProfileNames: () => Config.getTelegramProfileNames(configStore.getStoredConfig()),
-        activateDefaultProfileConfig: async (_ctx, isCurrent) => {
-            const previousProfileName = configStore.getActiveProfileName();
-            await configStore.load();
-            if (!isCurrent())
-                return;
-            if (previousProfileName) {
-                await (stopPolling ?? lockedPollingRuntime.stop)();
-                if (!isCurrent())
-                    return;
-            }
-            configStore.activateProfile(undefined);
-            await onTransportChanged?.();
-        },
-        activateProfileConfig: async (_ctx, profileName, isCurrent) => {
-            const previousProfileName = configStore.getActiveProfileName();
-            await configStore.load();
-            if (!isCurrent())
-                return false;
-            if (!Config.isValidTelegramProfileName(profileName))
-                return false;
-            const storedConfig = configStore.getStoredConfig();
-            if (!storedConfig.profiles?.[profileName])
-                return false;
-            if (previousProfileName !== profileName) {
-                await (stopPolling ?? lockedPollingRuntime.stop)();
-                if (!isCurrent())
-                    return false;
-            }
-            if (!configStore.activateProfile(profileName))
-                return false;
-            await onTransportChanged?.();
-            return true;
-        },
-    });
-}
-export function registerTelegramLifecycleRuntimeHooks({ pi, publicationRuntime, activityRuntime, activityVerbosityRuntime, diagnostics, assistantOutputRuntime, sessionLifecycleRuntime, configStore, abort, typing, lifecycle, activeTurnRuntime, telegramQueueStore, modelSwitchController, previewRuntime, promptDispatchRuntime, deferredQueueDispatchRuntime, modelContextAvailabilityRuntime, disconnectOnQuit, onSessionStarted, shutdownGenerativeAppLiveSurfaces, resolveAutomaticThreadCleanupEnabled, buttonActionStore, callMultipart, sendChatAction, sendRecordVoiceAction, sendMarkdownReply, sendTextReply, dispatchNextQueuedTelegramTurn, onPromptHandedOff, answerGuestQuery, deleteMessage, sendGuestReply, editGuestReply, stopGuestPlaceholder, preparePreviewDelivery, finalizeMarkdownPreview, proactivePushTargetGetter, getAssistantRenderingMode, recordMessageOwnership, canSendAgentActivity, isSessionContextActive = () => true, isTurnTransportActive, updateStatus, recordRuntimeEvent, }) {
-    const agentEndResetter = Runtime.createTelegramAgentEndResetter({
-        abort,
-        typing,
-        clearActiveTurn: activeTurnRuntime.clear,
-        resetToolExecutions: lifecycle.resetActiveToolExecutions,
-        clearPendingModelSwitch: modelSwitchController.clearPendingSwitch,
-        clearDispatchPending: lifecycle.clearDispatchPending,
-    });
-    const queuedAttachmentSender = OutboundAttachments.createTelegramQueuedOutboundAttachmentSender({
-        sendMultipart: callMultipart,
-        sendTextReply,
-        recordRuntimeEvent,
-    });
-    const richAttachmentSender = OutboundAttachments.createTelegramRichOutboundAttachmentSender({
-        sendMultipart: callMultipart,
-        getRenderingMode: getAssistantRenderingMode,
-        recordOwnership: recordMessageOwnership,
-        recordRuntimeEvent,
-    });
-    const sendGuestAttachment = async (turn, attachment, caption) => {
-        const stagingTarget = proactivePushTargetGetter();
-        const stagingChatId = stagingTarget?.chatId;
-        if (stagingChatId === undefined) {
-            throw new Error("Guest attachment staging requires a paired Telegram chat");
-        }
-        await OutboundAttachments.deliverTelegramGuestCachedAttachment({
-            guestQueryId: turn.guestQueryId,
-            stagingChatId,
-            stagingTarget,
-            attachment,
-            caption,
-            sendMultipart: callMultipart,
-            answerGuestQuery: (guestQueryId, result) => answerGuestQuery(guestQueryId, undefined, { result }),
-            answerGuestText: (guestQueryId, text) => answerGuestQuery(guestQueryId, text),
-            fallbackText: caption ||
-                "Telegram bridge could not deliver the requested attachment.",
-            deleteMessage,
-            recordRuntimeEvent,
-        });
-    };
-    const outboundReplyPlanner = OutboundHandlers.createTelegramOutboundReplyPlanner(buttonActionStore, getAssistantRenderingMode);
-    const voiceReplySenderDeps = {
-        execCommand: CommandTemplates.execCommandTemplate,
-        sendMultipart: callMultipart,
-        sendTextReply,
-        sendChatAction,
-        sendRecordVoiceAction,
-        getHandlers: configStore.getOutboundHandlers,
-        recordRuntimeEvent,
-    };
-    const outboundReplyArtifactSender = OutboundHandlers.createTelegramOutboundReplyArtifactSender(voiceReplySenderDeps);
-    const sendGuestVoiceReply = async (turn, plan, caption) => {
-        const stagingTarget = proactivePushTargetGetter();
-        const stagingChatId = stagingTarget?.chatId;
-        if (stagingChatId === undefined) {
-            throw new Error("Guest voice staging requires a paired Telegram chat");
-        }
-        const guestVoiceSender = OutboundHandlers.createTelegramOutboundReplyArtifactSender({
-            ...voiceReplySenderDeps,
-            sendChatAction: undefined,
-            sendRecordVoiceAction: undefined,
-            sendMultipart: async (_method, _fields, _fileField, filePath, fileName) => {
-                try {
-                    await OutboundAttachments.deliverTelegramGuestCachedAttachment({
-                        guestQueryId: turn.guestQueryId,
-                        stagingChatId,
-                        stagingTarget,
-                        attachment: { path: filePath, fileName },
-                        caption,
-                        sendMultipart: callMultipart,
-                        answerGuestQuery: (guestQueryId, result) => answerGuestQuery(guestQueryId, undefined, { result }),
-                        answerGuestText: (guestQueryId, text) => answerGuestQuery(guestQueryId, text),
-                        fallbackText: caption || "Telegram bridge could not deliver the voice reply.",
-                        deleteMessage,
-                        recordRuntimeEvent,
-                    });
-                }
-                catch (error) {
-                    recordRuntimeEvent("delivery", error, {
-                        phase: "guest-voice-answer",
-                        guestQueryId: turn.guestQueryId,
-                    });
-                }
-                return {};
-            },
-        });
-        await guestVoiceSender(turn, {
-            ...plan,
-            ...(plan.voiceReplies?.length
-                ? { voiceReplies: [plan.voiceReplies[0]] }
-                : {}),
-        }, { replyToPrompt: false });
-    };
-    let pendingFinalPublication;
-    const cancelPendingFinalPublication = () => {
-        pendingFinalPublication?.reservation.cancel();
-        pendingFinalPublication = undefined;
-    };
-    const recordPublicationFailure = (error) => {
-        recordRuntimeEvent("delivery", error, {
-            phase: "agent-end-background-delivery",
-        });
-    };
-    const scheduleActiveTurnDelivery = (task) => {
-        void publicationRuntime.enqueue(task).catch(recordPublicationFailure);
-    };
-    const agentLifecycleHooks = Queue.createTelegramAgentLifecycleHooks({
-        setAbortHandler: Runtime.createTelegramContextAbortHandlerSetter(abort),
-        getQueuedItems: telegramQueueStore.getQueuedItems,
-        hasPendingDispatch: lifecycle.hasDispatchPending,
-        hasActiveTurn: activeTurnRuntime.has,
-        resetToolExecutions: lifecycle.resetActiveToolExecutions,
-        resetPendingModelSwitch: modelSwitchController.clearPendingSwitch,
-        setQueuedItems: telegramQueueStore.setQueuedItems,
-        clearDispatchPending: lifecycle.clearDispatchPending,
-        setFoldQueuedPromptsIntoHistory: lifecycle.setFoldQueuedPromptsIntoHistory,
-        setActiveTurn: activeTurnRuntime.set,
-        onPromptHandedOff: (turn, ctx) => {
-            assistantOutputRuntime.beginTurn();
-            onPromptHandedOff?.(turn, ctx);
-        },
-        createPreviewState: previewRuntime.resetState,
-        startTypingLoop: (ctx) => {
-            const turn = activeTurnRuntime.get();
-            promptDispatchRuntime.startTypingLoop(ctx, turn?.chatId, {
-                target: turn?.target,
-            });
-        },
-        updateStatus,
-        getActiveTurn: activeTurnRuntime.get,
-        loadConfig: configStore.load,
-        extractAssistant: Replies.extractRunAssistantMessage,
-        isAssistantAlreadyPublished: (assistant) => !!assistant.text &&
-            assistantOutputRuntime.hasAdmittedTelegramIntermediate(assistant.text),
-        getFoldQueuedPromptsIntoHistory: lifecycle.shouldFoldQueuedPromptsIntoHistory,
-        resetRuntimeState: agentEndResetter,
-        isSessionActive: isSessionContextActive,
-        isTurnTransportActive,
-        waitForTypingIdle: typing.waitForIdle,
-        dispatchNextQueuedTelegramTurn,
-        requestDeferredDispatchNextQueuedTelegramTurn: deferredQueueDispatchRuntime.request,
-        scheduleActiveTurnDelivery,
-        reserveActiveTurnDelivery() {
-            const pending = pendingFinalPublication;
-            pendingFinalPublication = undefined;
-            const matches = pending?.turn === activeTurnRuntime.get();
-            if (!matches)
-                pending?.reservation.cancel();
-            const reservation = matches && pending ? pending.reservation : publicationRuntime.reserve();
-            return {
-                schedule: (task) => {
-                    void reservation.publish(task).catch(recordPublicationFailure);
-                },
-                cancel: reservation.cancel,
-            };
-        },
-        preparePreviewDelivery,
-        preparePreviewClear: previewRuntime.prepareClear,
-        clearPreview: previewRuntime.clear,
-        setPreviewPendingText: previewRuntime.setPendingText,
-        finalizeMarkdownPreview,
-        sendMarkdownReply,
-        sendTextReply,
-        sendQueuedAttachments: queuedAttachmentSender,
-        sendRichAttachmentReply: richAttachmentSender,
-        answerGuestQuery,
-        sendGuestReply,
-        editGuestReply,
-        stopGuestPlaceholder,
-        sendGuestAttachment,
-        sendGuestVoiceReply,
-        planOutboundReply: outboundReplyPlanner,
-        sendOutboundReplyArtifacts: outboundReplyArtifactSender,
-        recordRuntimeEvent,
-        getActiveToolExecutions: lifecycle.getActiveToolExecutions,
-        setActiveToolExecutions: lifecycle.setActiveToolExecutions,
-        triggerPendingModelSwitchAbort: modelSwitchController.triggerPendingAbort,
-    });
-    const agentStartWithDedupReset = Lifecycle.createAgentStartDedupHook(agentLifecycleHooks.onAgentStart, Replies.resetTransportReplyDedup, scheduleActiveTurnDelivery);
-    let uiPromptActive = false;
-    const startAgentActivityTypingLoop = (ctx) => {
-        if (uiPromptActive || !canSendAgentActivity(ctx))
-            return false;
-        const turn = activeTurnRuntime.get();
-        const target = turn?.target ?? proactivePushTargetGetter();
-        return (promptDispatchRuntime.startTypingLoop(ctx, turn?.chatId ?? target?.chatId, { target }) !== false);
-    };
-    const startActiveTurnTypingLoop = (ctx) => {
-        if (uiPromptActive)
-            return;
-        const turn = activeTurnRuntime.get();
-        promptDispatchRuntime.startTypingLoop(ctx, turn?.chatId, {
-            target: turn?.target,
-        });
-    };
-    let observedAutomaticCompaction = false;
-    let agentWorkActive = false;
-    const prepareCompactionNotice = (text, ctx) => {
-        const authority = publicationRuntime.capture();
-        const turn = activeTurnRuntime.get();
-        const selectedTarget = turn?.target ?? authority.target;
-        const target = selectedTarget ? { ...selectedTarget } : undefined;
-        const replyToMessageId = turn?.replyToMessageId;
-        return async () => {
-            if (!target || !isSessionContextActive(ctx) || !authority.isCurrent())
-                return;
-            if (turn && isTurnTransportActive?.(turn) === false)
-                return;
-            try {
-                await sendMarkdownReply(target.chatId, replyToMessageId, text, {
-                    target,
-                });
-            }
-            catch (error) {
-                recordRuntimeEvent("delivery", error, { phase: "compaction-notice" });
-            }
-        };
-    };
-    const sendCompactionNotice = (text, ctx) => {
-        scheduleActiveTurnDelivery(prepareCompactionNotice(text, ctx));
-    };
-    const compactionObserver = Lifecycle.createTelegramCompactionObserverRuntime({
-        isContextActive: isSessionContextActive,
-        setCompactionInProgress: lifecycle.setCompactionInProgress,
-        updateStatus,
-        startTypingLoop: startAgentActivityTypingLoop,
-        stopTypingLoop: typing.stop,
-        requestDeferredDispatchNextQueuedTelegramTurn: deferredQueueDispatchRuntime.request,
-        dispatchNextQueuedTelegramTurn,
-        recordRuntimeEvent,
-        onCompactionAbandoned: () => {
-            observedAutomaticCompaction = false;
-            activityRuntime.onCompactionAbandoned();
-        },
-    });
-    const messageActivityTypingHooks = Lifecycle.createTelegramMessageActivityTypingHooks({
-        hasActiveTurn: activeTurnRuntime.has,
-        startTypingLoop: startActiveTurnTypingLoop,
-        onMessageStart: previewRuntime.onMessageStart,
-        onMessageUpdate: previewRuntime.onMessageUpdate,
-        recordRuntimeEvent,
-    });
-    const messageActivityHooks = messageActivityTypingHooks;
-    Lifecycle.registerTelegramLifecycleHooks(pi, {
-        isSessionActive: isSessionContextActive,
-        ...sessionLifecycleRuntime,
-        ...agentLifecycleHooks,
-        onInput(event) {
-            activityRuntime.recordInputSource(event.source ?? "unknown");
-        },
-        async onSessionStart(event, ctx) {
-            diagnostics?.onSessionStart();
-            cancelPendingFinalPublication();
-            previewRuntime.invalidate();
-            assistantOutputRuntime.start();
-            activityRuntime.onSessionStart?.();
-            activityVerbosityRuntime?.reset();
-            modelContextAvailabilityRuntime.reconcile();
-            await sessionLifecycleRuntime.onSessionStart(event, ctx);
-            onSessionStarted?.(event, ctx);
-        },
-        async onSessionShutdown(event, ctx) {
-            if (!isSessionContextActive(ctx))
-                return;
-            const diagnosticsStopped = diagnostics?.onSessionShutdown();
-            shutdownGenerativeAppLiveSurfaces?.();
-            agentLifecycleHooks.clearRetainedAgentEnd();
-            activityRuntime.onSessionShutdown();
-            activityVerbosityRuntime?.reset();
-            assistantOutputRuntime.stop();
-            observedAutomaticCompaction = false;
-            agentWorkActive = false;
-            cancelPendingFinalPublication();
-            uiPromptActive = false;
-            compactionObserver.onSessionShutdown();
-            await diagnosticsStopped;
-            if (!isSessionContextActive(ctx))
-                return;
-            if (event.reason === "quit" && disconnectOnQuit) {
-                try {
-                    const automaticCleanupEnabled = (await resolveAutomaticThreadCleanupEnabled?.()) ?? true;
-                    if (automaticCleanupEnabled)
-                        await disconnectOnQuit();
-                }
-                catch (error) {
-                    recordRuntimeEvent("session", error, {
-                        phase: "automatic-disconnect-on-quit",
-                    });
-                }
-            }
-            await sessionLifecycleRuntime.onSessionShutdown(event, ctx);
-        },
-        async onSessionBeforeCompact(event, ctx) {
-            if (!isSessionContextActive(ctx))
-                return;
-            const shouldNotify = !(lifecycle.isCompactionInProgress?.() ?? false);
-            if (shouldNotify)
-                observedAutomaticCompaction = true;
-            activityRuntime.onCompactionStart(Pi.getSessionCompactionReason(event));
-            compactionObserver.onSessionBeforeCompact(event, ctx);
-            if (shouldNotify)
-                sendCompactionNotice(Commands.TELEGRAM_COMPACTION_STARTED_MARKDOWN, ctx);
-        },
-        async onSessionCompact(event, ctx) {
-            if (!isSessionContextActive(ctx))
-                return;
-            activityRuntime.onCompactionEnd(Pi.getSessionCompactionReason(event));
-            compactionObserver.onSessionCompact(event, ctx);
-            if (observedAutomaticCompaction) {
-                observedAutomaticCompaction = false;
-                sendCompactionNotice(Commands.TELEGRAM_COMPACTION_COMPLETED_MARKDOWN, ctx);
-            }
-        },
-        async onSessionCompactFailed(event, ctx) {
-            if (!isSessionContextActive(ctx))
-                return;
-            const shouldNotify = observedAutomaticCompaction;
-            compactionObserver.onSessionCompactFailed(event, ctx);
-            if (!shouldNotify)
-                return;
-            const notice = event.aborted
-                ? "**⚠️ Compaction cancelled.**"
-                : "**⚠️ Compaction failed.**";
-            sendCompactionNotice(notice, ctx);
-        },
-        async onAgentStart(event, ctx) {
-            if (!isSessionContextActive(ctx))
-                return;
-            agentWorkActive = true;
-            cancelPendingFinalPublication();
-            await agentStartWithDedupReset(event, ctx);
-            const turn = activeTurnRuntime.get();
-            activityRuntime.onAgentStart(turn?.target, turn?.replyToMessageId);
-            startAgentActivityTypingLoop(ctx);
-        },
-        async onToolExecutionStart(event, ctx) {
-            if (!isSessionContextActive(ctx))
-                return;
-            agentLifecycleHooks.onToolExecutionStart();
-            activityRuntime.onToolStart({
-                toolCallId: event.toolCallId,
-                toolName: event.toolName,
-                args: event.args,
-            });
-        },
-        onToolExecutionUpdate(event, ctx) {
-            if (!isSessionContextActive(ctx))
-                return;
-            activityRuntime.onToolUpdate({
-                toolCallId: event.toolCallId,
-                toolName: event.toolName,
-                update: event.partialResult,
-            });
-        },
-        async onToolExecutionEnd(event, ctx) {
-            if (!isSessionContextActive(ctx))
-                return;
-            activityRuntime.onToolEnd({
-                toolCallId: event.toolCallId,
-                toolName: event.toolName,
-                result: event.result,
-                isError: event.isError,
-            });
-            agentLifecycleHooks.onToolExecutionEnd(event, ctx);
-        },
-        async onMessageStart(event, ctx) {
-            if (!isSessionContextActive(ctx))
-                return;
-            await messageActivityHooks.onMessageStart(event, ctx);
-        },
-        async onMessageUpdate(event, ctx) {
-            if (!isSessionContextActive(ctx))
-                return;
-            if (event.assistantMessageEvent) {
-                activityRuntime.onAssistantEvent(event.assistantMessageEvent);
-            }
-            await messageActivityHooks.onMessageUpdate(event, ctx);
-        },
-        onMessageEnd(event, ctx) {
-            if (!isSessionContextActive(ctx))
-                return;
-            if (event.message.role === "assistant") {
-                previewRuntime.seal();
-                activityRuntime.onAssistantMessageEnd(event.message.stopReason);
-            }
-            if (event.message.role !== "assistant" ||
-                event.message.stopReason === "toolUse" ||
-                event.message.stopReason === "aborted")
-                return;
-            const turn = activeTurnRuntime.get();
-            if (!turn || turn.guestQueryId || pendingFinalPublication?.turn === turn)
-                return;
-            cancelPendingFinalPublication();
-            const assistant = Replies.extractLatestAssistantMessageText([
-                event.message,
-            ]);
-            if (!assistant.text &&
-                assistant.stopReason !== "error" &&
-                turn.queuedAttachments.length === 0)
-                return;
-            pendingFinalPublication = {
-                turn,
-                reservation: publicationRuntime.reserve(),
-            };
-        },
-        onUiPromptStart(event, ctx) {
-            if (!isSessionContextActive(ctx))
-                return;
-            uiPromptActive = true;
-            typing.stop();
-            activityRuntime.onUiPromptStart(event.kind, event.title);
-            updateStatus(ctx);
-        },
-        onUiPromptEnd(_event, ctx) {
-            if (!isSessionContextActive(ctx))
-                return;
-            uiPromptActive = false;
-            activityRuntime.onUiPromptEnd();
-            if (agentWorkActive || lifecycle.isCompactionInProgress()) {
-                startAgentActivityTypingLoop(ctx);
-            }
-            updateStatus(ctx);
-        },
-        async onAgentEnd(event, ctx) {
-            if (!isSessionContextActive(ctx))
-                return;
-            if (pendingFinalPublication &&
-                pendingFinalPublication.turn !== activeTurnRuntime.get()) {
-                cancelPendingFinalPublication();
-                return;
-            }
-            activityRuntime.onAgentEnd();
-            await agentLifecycleHooks.onAgentEnd(event, ctx);
-        },
-        async onAgentSettled(event, ctx) {
-            if (!isSessionContextActive(ctx))
-                return;
-            const pending = pendingFinalPublication;
-            try {
-                await agentLifecycleHooks.onAgentSettled(event, ctx);
-            }
-            finally {
-                if (pendingFinalPublication === pending)
-                    cancelPendingFinalPublication();
-            }
-            if (!isSessionContextActive(ctx))
-                return;
-            agentWorkActive = false;
-            activityRuntime.onAgentSettled();
-            modelContextAvailabilityRuntime.reconcile();
-        },
-        onBeforeAgentStart: Prompts.createTelegramProactiveBeforeAgentStartHook({
-            reconcileAvailability: modelContextAvailabilityRuntime.reconcile,
-            isAvailable: canSendAgentActivity,
-        }),
-    });
-}