key: string;

threadId?: number;

messages: Array<{ msg: Message; ctx: TelegramContext; receivedAtMs: number }>;

promptContextMinTimestampMs?: number;

timer: ReturnType<typeof setTimeout>;

};

const textFragmentBuffer = new Map<string, TextFragmentEntry>();

debounceLane: TelegramDebounceLane;

botUsername?: string;

threadId?: number;

promptContextMinTimestampMs?: number;

};

const normalizePromptContextMinTimestampMs = (timestampMs?: number) =>

typeof timestampMs === "number" && Number.isFinite(timestampMs) ? timestampMs : undefined;

const latestPromptContextMinTimestampMs = (

...timestamps: Array<number | undefined>

): number | undefined => {

let latest: number | undefined;

for (const timestampMs of timestamps) {

const normalized = normalizePromptContextMinTimestampMs(timestampMs);

if (normalized === undefined) {

continue;

}

latest = latest === undefined ? normalized : Math.max(latest, normalized);

}

return latest;

};

const resolveTelegramDebounceLane = (msg: Message): TelegramDebounceLane => {

const forwardMeta = msg as {

return;

}

if (entries.length === 1) {

const promptContextMinTimestampMs = normalizePromptContextMinTimestampMs(

last.promptContextMinTimestampMs,

);

await processMessageWithReplyChain(last.ctx, last.msg, last.allMedia, last.storeAllowFrom, {

receivedAtMs: last.receivedAtMs,

ingressBuffer: "inbound-debounce",

...(promptContextMinTimestampMs !== undefined ? { promptContextMinTimestampMs } : {}),

});

return;

}

return;

}

const first = entries[0];

const promptContextMinTimestampMs = latestPromptContextMinTimestampMs(

...entries.map((entry) => entry.promptContextMinTimestampMs),

);

const baseCtx = first.ctx;

const syntheticMessage = buildSyntheticTextMessage({

base: first.msg,

...(messageIdOverride ? { messageIdOverride } : {}),

receivedAtMs: first.receivedAtMs,

ingressBuffer: "inbound-debounce",

...(promptContextMinTimestampMs !== undefined ? { promptContextMinTimestampMs } : {}),

},

);

},

messageThreadId?: number;

resolvedThreadId?: number;

senderId?: string | number;

runtimeCfg?: OpenClawConfig;

}): {

agentId: string;

sessionEntry: ReturnType<typeof resolveSessionStoreEntry>["existing"];

sessionKey: string;

model?: string;

} => {

const runtimeCfg = telegramDeps.getRuntimeConfig();

const runtimeCfg = params.runtimeCfg ?? telegramDeps.getRuntimeConfig();

const resolvedThreadId =

params.resolvedThreadId ??

resolveTelegramForumThreadId({

const storePath = telegramDeps.resolveStorePath(runtimeCfg.session?.store, {

agentId: route.agentId,

});

const store = loadSessionStore(storePath);

const store = (telegramDeps.loadSessionStore ?? loadSessionStore)(storePath);

const entry = resolveSessionStoreEntry({ store, sessionKey }).existing;

const storedOverride = resolveStoredModelOverride({

sessionEntry: entry,

primaryEntry.msg,

allMedia,

storeAllowFrom,

entry.promptContextMinTimestampMs !== undefined

? { promptContextMinTimestampMs: entry.promptContextMinTimestampMs }

: undefined,

);

} catch (err) {

runtime.error?.(danger(`media group handler failed: ${String(err)}`));

messageIdOverride: String(last.msg.message_id),

receivedAtMs: first.receivedAtMs,

ingressBuffer: "text-fragment",

...(entry.promptContextMinTimestampMs !== undefined

? { promptContextMinTimestampMs: entry.promptContextMinTimestampMs }

: {}),

});

} catch (err) {

runtime.error?.(danger(`text fragment handler failed: ${String(err)}`));

const buildPromptContextForMessage = (

msg: Message,

replyChainNodes: TelegramCachedMessageNode[],

options?: TelegramMessageContextOptions,

): TelegramPromptContextEntry[] => {

const messageId = typeof msg.message_id === "number" ? String(msg.message_id) : undefined;

const currentNode = messageCache.get({

replyChainNodes,

recentLimit: 10,

replyTargetWindowSize: 2,

...(options?.promptContextMinTimestampMs !== undefined

? { minTimestampMs: options.promptContextMinTimestampMs }

: {}),

});

return conversationContext.length > 0

? [

) => {

const replyChainNodes = buildReplyChainForMessage(msg);

const { replyMedia, replyChain } = await resolveReplyMediaForChain(ctx, replyChainNodes);

const promptContext = buildPromptContextForMessage(msg, replyChainNodes);

const promptContext = buildPromptContextForMessage(msg, replyChainNodes, options);

await processMessage(

ctx,

allMedia,

storeAllowFrom: string[];

sendOversizeWarning: boolean;

oversizeLogMessage: string;

promptContextMinTimestampMs?: number;

}) => {

const {

ctx,

storeAllowFrom,

sendOversizeWarning,

oversizeLogMessage,

promptContextMinTimestampMs,

} = params;

// Text fragment handling - Telegram splits long pastes into multiple inbound messages (~4096 chars).

nextTotalChars <= TELEGRAM_TEXT_FRAGMENT_MAX_TOTAL_CHARS

) {

existing.messages.push({ msg, ctx, receivedAtMs: nowMs });

existing.promptContextMinTimestampMs = latestPromptContextMinTimestampMs(

existing.promptContextMinTimestampMs,

promptContextMinTimestampMs,

);

scheduleTextFragmentFlush(existing);

return;

}

const entry: TextFragmentEntry = {

key,

messages: [{ msg, ctx, receivedAtMs: nowMs }],

...(promptContextMinTimestampMs !== undefined ? { promptContextMinTimestampMs } : {}),

timer: setTimeout(() => {}, TELEGRAM_TEXT_FRAGMENT_MAX_GAP_MS),

};

textFragmentBuffer.set(key, entry);

if (existing) {

clearTimeout(existing.timer);

existing.messages.push({ msg, ctx });

existing.promptContextMinTimestampMs = latestPromptContextMinTimestampMs(

existing.promptContextMinTimestampMs,

promptContextMinTimestampMs,

);

existing.timer = setTimeout(async () => {

mediaGroupBuffer.delete(mediaGroupId);

mediaGroupProcessing = mediaGroupProcessing

} else {

const entry: MediaGroupEntry = {

messages: [{ msg, ctx }],

...(promptContextMinTimestampMs !== undefined ? { promptContextMinTimestampMs } : {}),

timer: setTimeout(async () => {

mediaGroupBuffer.delete(mediaGroupId);

mediaGroupProcessing = mediaGroupProcessing

debounceKey,

debounceLane,

botUsername: ctx.me?.username,

...(promptContextMinTimestampMs !== undefined ? { promptContextMinTimestampMs } : {}),

});

};

bot.on("callback_query", async (ctx) => {

}

}

const promptContextMinTimestampMs = normalizePromptContextMinTimestampMs(

resolveTelegramSessionState({

chatId: event.chatId,

isGroup: event.isGroup,

isForum: event.isForum,

messageThreadId: event.messageThreadId,

resolvedThreadId,

senderId: event.senderId,

runtimeCfg: cfg,

}).sessionEntry?.sessionStartedAt,

);

recordMessageForReplyChain(event.msg, resolvedThreadId ?? dmThreadId);

await processInboundMessage({

ctx: event.ctx,

storeAllowFrom,

sendOversizeWarning: event.sendOversizeWarning,

oversizeLogMessage: event.oversizeLogMessage,

...(promptContextMinTimestampMs !== undefined ? { promptContextMinTimestampMs } : {}),

});

} catch (err) {

runtime.error?.(danger(`${event.errorMessage}: ${String(err)}`));