@llblab/pi-telegram 0.54.3 → 0.55.0

package/dist/lib/runtime.d.ts

@@ -3,6 +3,7 @@
  * Zones: pi agent runtime state, telegram session, shared coordination
  * Owns small session-local runtime primitives that are shared by orchestration but are not specific to queueing, rendering, polling, or Telegram transport
  */
+import * as Machine from "./machine.ts";
 export interface TelegramRuntimeQueueCounters {
     nextQueuedTelegramItemOrder: number;
     nextQueuedTelegramControlOrder: number;
@@ -16,10 +17,6 @@ export interface TelegramRuntimeLifecycleFlags {
 }
 export interface TelegramBridgeRuntimeState extends TelegramRuntimeQueueCounters, TelegramRuntimeLifecycleFlags {
     abortHandler?: () => void;
-    typingInterval?: ReturnType<typeof setInterval>;
-    typingInFlight?: Promise<void>;
-    typingLoopDeps?: TelegramTypingLoopDeps;
-    typingLoopKey?: string;
 }
 export interface TelegramRuntimeQueuePort {
     syncCounters: (counters: Partial<TelegramRuntimeQueueCounters>) => void;
@@ -54,7 +51,8 @@ export interface TelegramRuntimeAbortPort {
 export interface TelegramRuntimeTypingPort {
     start: (deps: TelegramTypingLoopDeps) => boolean;
     stop: () => boolean;
-    waitForIdle: () => Promise<void>;
+    /** Waits for the in-flight action, bounded so a never-settling request cannot hold shutdown. */
+    waitForIdle: (timeoutMs?: number) => Promise<void>;
 }
 export interface TelegramBridgeRuntime {
     state: TelegramBridgeRuntimeState;
@@ -65,7 +63,7 @@ export interface TelegramBridgeRuntime {
     typing: TelegramRuntimeTypingPort;
 }
 export declare function createTelegramBridgeRuntimeState(): TelegramBridgeRuntimeState;
-export declare function createTelegramBridgeRuntime(state?: TelegramBridgeRuntimeState): TelegramBridgeRuntime;
+export declare function createTelegramBridgeRuntime(state?: TelegramBridgeRuntimeState, typing?: TelegramRuntimeTypingPort): TelegramBridgeRuntime;
 export declare function syncTelegramQueueRuntimeCounters(state: TelegramBridgeRuntimeState, counters: Partial<TelegramRuntimeQueueCounters>): void;
 export declare function allocateTelegramQueueItemOrder(state: TelegramBridgeRuntimeState): number;
 export declare function allocateTelegramQueueControlOrder(state: TelegramBridgeRuntimeState): number;
@@ -109,19 +107,87 @@ export interface TelegramTypingLoopStarterDeps<TContext> extends TelegramRuntime
     getDefaultChatId: () => number | undefined;
     sendTypingAction: (chatId: number, options?: {
         message_thread_id?: number;
+        assertAuthority?: () => void;
     }) => Promise<unknown>;
     updateStatus: (ctx: TContext, error?: string) => void;
     isContextActive?: (ctx: TContext) => boolean;
+    getSessionGeneration?: () => number;
     isTransportAvailable?: () => boolean;
+    isThreadedMode?: () => boolean;
     getTransportAuthority?: () => string | number | undefined;
     intervalMs?: number;
 }
 export declare function createTelegramTypingLoopStarter<TContext>(deps: TelegramTypingLoopStarterDeps<TContext>): (ctx: TContext, chatId?: number, options?: {
     target?: TelegramTypingLoopTarget;
 }) => boolean;
-export declare function startTelegramTypingLoop(state: TelegramBridgeRuntimeState, deps: TelegramTypingLoopDeps): boolean;
-export declare function stopTelegramTypingLoop(state: TelegramBridgeRuntimeState): boolean;
-export declare function waitForTelegramTypingLoopIdle(state: TelegramBridgeRuntimeState, timeoutMs?: number): Promise<void>;
+/** The whole typing-loop state; only `transitionTelegramTypingLoop` produces a new one. */
+export interface TelegramTypingMachineState {
+    /** The loop the interval serves; its callbacks live in the shell under `id`. A loop exists exactly while ticking. */
+    readonly loop: {
+        readonly id: number;
+        readonly key: string;
+        readonly chatId: number;
+        readonly threadParams?: {
+            readonly message_thread_id: number;
+        };
+    } | null;
+    /** The action in flight; a tick waits for it, and replacing or stopping the loop forgets it. */
+    readonly inFlight: number | null;
+    readonly nextSendId: number;
+}
+export type TelegramTypingEvent = {
+    type: "started";
+    /** Shell-assigned, so the shell can hold the caller's callbacks before effects run. */
+    loopId: number;
+    chatId: number | undefined;
+    key: string;
+    threadParams?: {
+        message_thread_id: number;
+    };
+    intervalMs: number;
+    /** The caller's `shouldContinue`, sampled at dispatch. */
+    continues: boolean;
+} | {
+    type: "ticked";
+    continues: boolean;
+} | {
+    type: "sendSettled";
+    sendId: number;
+} | {
+    type: "stopRequested";
+};
+export type TelegramTypingEffect = {
+    type: "send";
+    loopId: number;
+    sendId: number;
+    chatId: number;
+    threadParams?: {
+        message_thread_id: number;
+    };
+} | {
+    type: "armInterval";
+    intervalMs: number;
+} | {
+    type: "cancelInterval";
+} | {
+    type: "loopEnded";
+    loopId: number;
+};
+export interface TelegramTypingStep extends Machine.TelegramMachineStep<TelegramTypingMachineState, TelegramTypingEffect> {
+    /** `start`: a loop began or moved to a new target. `stop`: a running loop ended. */
+    result: boolean;
+}
+export declare function createTelegramTypingMachineState(): TelegramTypingMachineState;
+/**
+ * Pure typing-loop transition. Every start replaces the caller's callbacks, even on the same target, and forgets the
+ * old in-flight action; only a new target sends at once on a running loop, whose interval keeps its phase.
+ */
+export declare function transitionTelegramTypingLoop(state: TelegramTypingMachineState, event: TelegramTypingEvent): TelegramTypingStep;
+/**
+ * The shell around `transitionTelegramTypingLoop`: it holds each loop's callbacks, samples `shouldContinue` into
+ * events, owns the interval and turns every action outcome into `sendSettled`.
+ */
+export declare function createTelegramTypingLoop(): TelegramRuntimeTypingPort;
 export declare function createTelegramContextAbortHandlerSetter<TContext extends {
     abort: () => void;
 }>(abort: Pick<TelegramRuntimeAbortPort, "setHandler">): (ctx: TContext) => void;
@@ -149,11 +215,11 @@ export interface TelegramPromptDispatchRuntime<TContext> {
     startTypingLoop: (ctx: TContext, chatId?: number, options?: {
         target?: TelegramTypingLoopTarget;
     }) => boolean | void;
-    onPromptDispatchStart: (ctx: TContext, chatId?: number) => void;
+    onPromptDispatchStart: (ctx: TContext, chatId?: number, target?: TelegramTypingLoopTarget) => void;
     onPromptDispatchFailure: (ctx: TContext, message: string) => void;
 }
 export declare function createTelegramPromptDispatchRuntime<TContext>(deps: TelegramPromptDispatchRuntimeDeps<TContext>): TelegramPromptDispatchRuntime<TContext>;
 export declare function createTelegramPromptDispatchLifecycle<TContext>(deps: TelegramPromptDispatchLifecycleDeps<TContext>): {
-    onPromptDispatchStart: (ctx: TContext, chatId?: number) => void;
+    onPromptDispatchStart: (ctx: TContext, chatId?: number, target?: TelegramTypingLoopTarget) => void;
     onPromptDispatchFailure: (ctx: TContext, message: string) => void;
 };

package/dist/lib/runtime.js

@@ -3,6 +3,7 @@
  * Zones: pi agent runtime state, telegram session, shared coordination
  * Owns small session-local runtime primitives that are shared by orchestration but are not specific to queueing, rendering, polling, or Telegram transport
  */
+import * as Machine from "./machine.js";
 const TELEGRAM_TYPING_ACTION_INTERVAL_MS = 3_000;
 const TELEGRAM_TYPING_IDLE_DRAIN_MAX_MS = 250;
 export function createTelegramBridgeRuntimeState() {
@@ -16,7 +17,7 @@ export function createTelegramBridgeRuntimeState() {
         setupInProgress: false,
     };
 }
-export function createTelegramBridgeRuntime(state = createTelegramBridgeRuntimeState()) {
+export function createTelegramBridgeRuntime(state = createTelegramBridgeRuntimeState(), typing = createTelegramTypingLoop()) {
     return {
         state,
         queue: {
@@ -49,11 +50,7 @@ export function createTelegramBridgeRuntime(state = createTelegramBridgeRuntimeS
             getHandler: () => getTelegramAbortHandler(state),
             abortTurn: () => abortTelegramTurn(state),
         },
-        typing: {
-            start: (deps) => startTelegramTypingLoop(state, deps),
-            stop: () => stopTelegramTypingLoop(state),
-            waitForIdle: () => waitForTelegramTypingLoopIdle(state),
-        },
+        typing,
     };
 }
 export function syncTelegramQueueRuntimeCounters(state, counters) {
@@ -148,12 +145,6 @@ export function abortTelegramTurn(state) {
     state.abortHandler();
     return true;
 }
-function getTelegramTypingLoopThreadParams(target) {
-    const threadId = target?.threadId;
-    return Number.isInteger(threadId)
-        ? { message_thread_id: threadId }
-        : undefined;
-}
 function updateTelegramRuntimeStatusSafely(updateStatus, ctx, options) {
     try {
         updateStatus(ctx, options.error);
@@ -171,34 +162,47 @@ function updateTelegramRuntimeStatusSafely(updateStatus, ctx, options) {
 }
 export function createTelegramTypingLoopStarter(deps) {
     return (ctx, chatId, options) => {
+        const sessionGeneration = deps.getSessionGeneration?.();
         const transportAuthority = deps.getTransportAuthority?.();
+        const isContextCurrent = () => deps.isContextActive?.(ctx) !== false &&
+            (!deps.getSessionGeneration || Object.is(deps.getSessionGeneration(), sessionGeneration));
         const hasTransport = () => deps.getTransportAuthority
             ? transportAuthority !== undefined &&
                 Object.is(deps.getTransportAuthority(), transportAuthority)
             : deps.isTransportAvailable?.() !== false;
-        if (!hasTransport())
+        const target = options?.target ? { ...options.target } : undefined;
+        const canContinue = () => isContextCurrent() && hasTransport() &&
+            (deps.isThreadedMode?.() !== true ||
+                (target?.threadId !== undefined && Number.isSafeInteger(target.threadId) && target.threadId > 0));
+        // Queue dispatch precedes agent_start: only an explicit destination permits Threaded presence, never chat fallback.
+        if (!canContinue())
             return false;
         let active = true;
         return deps.typing.start({
             chatId: chatId ?? deps.getDefaultChatId(),
-            target: options?.target,
+            target,
             intervalMs: deps.intervalMs ?? TELEGRAM_TYPING_ACTION_INTERVAL_MS,
             sendTypingAction: async (targetChatId, actionOptions) => {
                 if (!active)
                     return;
-                if (!hasTransport()) {
+                if (!canContinue()) {
                     deps.typing.stop();
                     return;
                 }
                 try {
-                    await deps.sendTypingAction(targetChatId, actionOptions);
+                    await deps.sendTypingAction(targetChatId, {
+                        ...actionOptions,
+                        // This stays process-local; adapters recheck it before HTTP/IPC issuance, not just loop ticks.
+                        assertAuthority() {
+                            if (!active || !canContinue())
+                                throw new Error("Typing context authority changed.");
+                        },
+                    });
                 }
                 catch (error) {
-                    if (deps.isContextActive?.(ctx) === false)
-                        return;
                     if (!active)
                         return;
-                    if (!hasTransport()) {
+                    if (!canContinue()) {
                         deps.typing.stop();
                         return;
                     }
@@ -212,7 +216,7 @@ export function createTelegramTypingLoopStarter(deps) {
                     }
                 }
             },
-            shouldContinue: hasTransport,
+            shouldContinue: canContinue,
             onStopped: () => {
                 active = false;
             },
@@ -223,79 +227,157 @@ function getTelegramTypingLoopKey(deps) {
     const threadId = deps.target?.threadId;
     return `${deps.chatId ?? 0}:${Number.isInteger(threadId) ? threadId : "all"}`;
 }
-export function startTelegramTypingLoop(state, deps) {
-    if (deps.chatId === undefined || deps.chatId === 0)
-        return false;
-    const previousKey = state.typingLoopKey;
-    const previousDeps = state.typingLoopDeps;
-    const nextKey = getTelegramTypingLoopKey(deps);
-    if (previousDeps && previousDeps !== deps) {
-        previousDeps.onStopped?.();
-        state.typingInFlight = undefined;
-    }
-    state.typingLoopDeps = deps;
-    state.typingLoopKey = nextKey;
-    const sendTyping = () => {
-        const activeDeps = state.typingLoopDeps;
-        if (!activeDeps ||
-            activeDeps.chatId === undefined ||
-            activeDeps.chatId === 0)
-            return;
-        if (activeDeps.shouldContinue?.() === false) {
-            stopTelegramTypingLoop(state);
-            return;
+export function createTelegramTypingMachineState() {
+    return { loop: null, inFlight: null, nextSendId: 0 };
+}
+const typingStep = (state, result, ...effects) => ({ state, effects, result });
+function stopTypingLoop(state) {
+    if (!state.loop)
+        return typingStep(state, false);
+    return typingStep({ ...state, loop: null, inFlight: null }, true, { type: "cancelInterval" }, { type: "loopEnded", loopId: state.loop.id });
+}
+/** One action per tick, never two at once; a caller that stops continuing ends the loop instead. */
+function sendTypingAction(state, continues) {
+    const loop = state.loop;
+    if (!loop)
+        return typingStep(state, false);
+    if (!continues)
+        return stopTypingLoop(state);
+    if (state.inFlight !== null)
+        return typingStep(state, false);
+    const sendId = state.nextSendId + 1;
+    return typingStep({ ...state, inFlight: sendId, nextSendId: sendId }, false, {
+        type: "send",
+        loopId: loop.id,
+        sendId,
+        chatId: loop.chatId,
+        ...(loop.threadParams ? { threadParams: loop.threadParams } : {}),
+    });
+}
+/**
+ * Pure typing-loop transition. Every start replaces the caller's callbacks, even on the same target, and forgets the
+ * old in-flight action; only a new target sends at once on a running loop, whose interval keeps its phase.
+ */
+export function transitionTelegramTypingLoop(state, event) {
+    switch (event.type) {
+        case "started": {
+            if (event.chatId === undefined || event.chatId === 0)
+                return typingStep(state, false);
+            const previous = state.loop;
+            const replaced = previous
+                ? [{ type: "loopEnded", loopId: previous.id }]
+                : [];
+            const next = {
+                ...state,
+                inFlight: previous ? null : state.inFlight,
+                loop: {
+                    id: event.loopId,
+                    key: event.key,
+                    chatId: event.chatId,
+                    ...(event.threadParams ? { threadParams: event.threadParams } : {}),
+                },
+            };
+            if (previous?.key === event.key)
+                return typingStep(next, false, ...replaced);
+            if (previous) {
+                const sent = sendTypingAction(next, event.continues);
+                return typingStep(sent.state, true, ...replaced, ...sent.effects);
+            }
+            // A fresh loop always arms its interval; a caller that already stopped continuing ends it on the first tick.
+            const sent = event.continues
+                ? sendTypingAction(next, true)
+                : typingStep(next, false);
+            return typingStep(sent.state, true, ...sent.effects, {
+                type: "armInterval",
+                intervalMs: event.intervalMs,
+            });
         }
-        if (state.typingInFlight)
-            return;
-        const targetChatId = activeDeps.chatId;
-        const threadParams = getTelegramTypingLoopThreadParams(activeDeps.target);
-        const typing = Promise.resolve()
-            .then(() => activeDeps.sendTypingAction(targetChatId, threadParams))
-            .then(() => undefined)
-            .catch(() => undefined);
-        state.typingInFlight = typing;
-        void typing.finally(() => {
-            if (state.typingInFlight === typing)
-                state.typingInFlight = undefined;
-        });
-    };
-    if (state.typingInterval) {
-        if (previousKey === nextKey)
-            return false;
-        sendTyping();
-        return true;
+        case "ticked":
+            return sendTypingAction(state, event.continues);
+        case "sendSettled":
+            return typingStep(state.inFlight === event.sendId ? { ...state, inFlight: null } : state, false);
+        case "stopRequested":
+            return stopTypingLoop(state);
     }
-    sendTyping();
-    state.typingInterval = setInterval(sendTyping, deps.intervalMs);
-    state.typingInterval.unref?.();
-    return true;
-}
-export function stopTelegramTypingLoop(state) {
-    if (!state.typingInterval)
-        return false;
-    clearInterval(state.typingInterval);
-    const activeDeps = state.typingLoopDeps;
-    state.typingInterval = undefined;
-    state.typingLoopDeps = undefined;
-    state.typingLoopKey = undefined;
-    state.typingInFlight = undefined;
-    activeDeps?.onStopped?.();
-    return true;
 }
-export async function waitForTelegramTypingLoopIdle(state, timeoutMs = TELEGRAM_TYPING_IDLE_DRAIN_MAX_MS) {
-    const inFlight = state.typingInFlight;
-    if (!inFlight)
-        return;
-    if (timeoutMs <= 0) {
-        await Promise.race([inFlight, Promise.resolve()]);
-        return;
-    }
-    await Promise.race([
-        inFlight,
-        new Promise((resolve) => {
-            setTimeout(resolve, timeoutMs);
-        }),
-    ]);
+/**
+ * The shell around `transitionTelegramTypingLoop`: it holds each loop's callbacks, samples `shouldContinue` into
+ * events, owns the interval and turns every action outcome into `sendSettled`.
+ */
+export function createTelegramTypingLoop() {
+    const callbacks = new Map();
+    let interval;
+    let loopIds = 0;
+    const continues = (loopId) => loopId === undefined
+        ? false
+        : callbacks.get(loopId)?.shouldContinue?.() !== false;
+    const machine = Machine.createTelegramMachineRunner({
+        initial: createTelegramTypingMachineState(),
+        transition: transitionTelegramTypingLoop,
+        run(effect) {
+            switch (effect.type) {
+                case "send": {
+                    const send = callbacks.get(effect.loopId)?.sendTypingAction;
+                    // Failures belong to the caller's action; the loop only needs to know the action is over.
+                    void Promise.resolve()
+                        .then(() => send?.(effect.chatId, effect.threadParams))
+                        .then(() => undefined, () => undefined)
+                        .then(() => machine.dispatch({ type: "sendSettled", sendId: effect.sendId }));
+                    return;
+                }
+                case "armInterval":
+                    interval = setInterval(() => machine.dispatch({
+                        type: "ticked",
+                        continues: continues(machine.state.loop?.id),
+                    }), effect.intervalMs);
+                    interval.unref?.();
+                    return;
+                case "cancelInterval":
+                    clearInterval(interval);
+                    interval = undefined;
+                    return;
+                case "loopEnded": {
+                    const ended = callbacks.get(effect.loopId);
+                    callbacks.delete(effect.loopId);
+                    ended?.onStopped?.();
+                    return;
+                }
+            }
+        },
+    });
+    return {
+        start(deps) {
+            const loopId = ++loopIds;
+            callbacks.set(loopId, deps);
+            const threadId = deps.target?.threadId;
+            const started = machine.dispatch({
+                type: "started",
+                loopId,
+                chatId: deps.chatId,
+                key: getTelegramTypingLoopKey(deps),
+                ...(Number.isInteger(threadId)
+                    ? { threadParams: { message_thread_id: threadId } }
+                    : {}),
+                intervalMs: deps.intervalMs,
+                continues: continues(loopId),
+            });
+            if (machine.state.loop?.id !== loopId)
+                callbacks.delete(loopId);
+            return started.result;
+        },
+        stop: () => machine.dispatch({ type: "stopRequested" }).result,
+        async waitForIdle(timeoutMs = TELEGRAM_TYPING_IDLE_DRAIN_MAX_MS) {
+            if (machine.state.inFlight === null)
+                return;
+            const idle = machine.waitFor((state) => state.inFlight === null);
+            await Promise.race([
+                idle,
+                timeoutMs <= 0
+                    ? Promise.resolve()
+                    : new Promise((resolve) => setTimeout(resolve, timeoutMs)),
+            ]);
+        },
+    };
 }
 export function createTelegramContextAbortHandlerSetter(abort) {
     return (ctx) => {
@@ -327,9 +409,9 @@ export function createTelegramPromptDispatchRuntime(deps) {
 }
 export function createTelegramPromptDispatchLifecycle(deps) {
     return {
-        onPromptDispatchStart: (ctx, chatId) => {
+        onPromptDispatchStart: (ctx, chatId, target) => {
             deps.lifecycle.setDispatchPending(true);
-            deps.startTypingLoop(ctx, chatId);
+            deps.startTypingLoop(ctx, chatId, { target });
             updateTelegramRuntimeStatusSafely(deps.updateStatus, ctx, {
                 category: "dispatch",
                 phase: "status-update",

package/dist/lib/sections.js

@@ -66,7 +66,6 @@ export function getTelegramSectionDiagnostics() {
     const registry = globalThis[SECTION_REGISTRY_KEY];
     return registry ? registry.getDiagnostics() : [];
 }
-// --- Registry ---
 const BACK_NAV_ROW = {
     text: "⬆️ Back",
 };

package/dist/lib/telegram-api.d.ts

@@ -369,7 +369,9 @@ export interface TelegramApiTargetActivityRuntime {
     }[];
     listPendingChats: () => number[];
 }
-export declare function createTelegramApiTargetActivityRuntime(): TelegramApiTargetActivityRuntime;
+export declare function createTelegramApiTargetActivityRuntime(deps?: {
+    captureDrain?: () => (() => void) | undefined;
+}): TelegramApiTargetActivityRuntime;
 export declare function createTelegramApiTargetTrackingClient(client: TelegramApiClient, activity: TelegramApiTargetActivityRuntime): TelegramApiClient;
 export type TelegramApiWorkspaceAdmissionScopeLike = {
     kind: "target";
@@ -431,6 +433,10 @@ export interface TelegramBridgeApiRuntimeDeps {
     chatActionMinIntervalMs?: number;
     chatActionMaxGates?: number;
 }
+/** Typing issuance guard is local authority, never Bot API body or IPC data. */
+export interface TelegramTypingActionOptions extends Pick<TelegramApiCallOptions, "assertAuthority"> {
+    message_thread_id?: number;
+}
 export interface TelegramBridgeApiRuntime extends Pick<TelegramApiClient, "call" | "callMultipart"> {
     downloadFile: (fileId: string, suggestedName: string, source?: TelegramAttachmentSource) => Promise<string>;
     deleteWebhook: (signal?: AbortSignal) => Promise<boolean>;
@@ -442,9 +448,7 @@ export interface TelegramBridgeApiRuntime extends Pick<TelegramApiClient, "call"
     sendChatAction: (chatId: number, action: string, options?: {
         message_thread_id?: number;
     }) => Promise<boolean>;
-    sendTypingAction: (chatId: number, options?: {
-        message_thread_id?: number;
-    }) => Promise<unknown>;
+    sendTypingAction: (chatId: number, options?: TelegramTypingActionOptions) => Promise<unknown>;
     sendRecordVoiceAction: (chatId: number, options?: {
         message_thread_id?: number;
     }) => Promise<unknown>;
@@ -522,11 +526,7 @@ export declare function fetchTelegramBotIdentity(botToken: string, fetchImpl?: t
 export declare function callTelegramMultipart<TResponse>(botToken: string | undefined, method: string, fields: Record<string, string>, fileField: string, filePath: string, fileName: string, options?: TelegramApiCallOptions): Promise<TResponse>;
 export declare function downloadTelegramFile(botToken: string | undefined, fileId: string, suggestedName: string, tempDir: string, options?: TelegramFileDownloadOptions): Promise<string>;
 export declare function answerTelegramCallbackQuery(botToken: string | undefined, callbackQueryId: string, text?: string, options?: TelegramAnswerCallbackQueryOptions): Promise<void>;
-export declare function createTelegramChatActionSender<TAction extends string>(sendChatAction: (chatId: number, action: TAction, options?: {
-    message_thread_id?: number;
-}) => Promise<unknown>, action: TAction): (chatId: number, options?: {
-    message_thread_id?: number;
-}) => Promise<unknown>;
+export declare function createTelegramChatActionSender<TAction extends string>(sendChatAction: (chatId: number, action: TAction, options?: TelegramTypingActionOptions) => Promise<unknown>, action: TAction): (chatId: number, options?: TelegramTypingActionOptions) => Promise<unknown>;
 export declare function createTelegramNativeMarkdownDraftSender(deps: {
     sendMessageDraft: TelegramBridgeApiRuntime["sendMessageDraft"];
     sendRichMessageDraft: TelegramBridgeApiRuntime["sendRichMessageDraft"];
@@ -545,6 +545,7 @@ export type TelegramWorkspaceThreadDeletionTransport = (authorize: () => {
 export declare function createDefaultTelegramBridgeApiRuntime(deps: {
     getBotToken: () => string | undefined;
     getBotScope?: () => string | undefined;
+    isThreadedMode?: () => boolean;
     recordRuntimeEvent: TelegramBridgeApiRuntimeDeps["recordRuntimeEvent"];
     captureRequestErrorHandler?: TelegramBridgeApiRuntimeDeps["captureRequestErrorHandler"];
     targetActivity?: TelegramApiTargetActivityRuntime;
@@ -560,5 +561,6 @@ export declare function createTelegramBridgeApiRuntime(deps: TelegramBridgeApiRu
  */
 export declare function createTelegramApiClient(getBotToken: () => string | undefined, options?: TelegramAnswerCallbackQueryOptions & {
     now?: () => number;
+    isThreadedMode?: () => boolean;
 }): TelegramApiClient;
 export {};