@cats-inc/cats-platform 0.1.0

package/build/server/platform/transports/telegram/bridge.js

@@ -0,0 +1,994 @@
+import { createCatActorId } from '../../../core/actors.js';
+import { describeTelegramRoomRouting } from './mapping.js';
+import { normalizeTelegramAttachments } from './normalization.js';
+import { pickTelegramMessage, readTelegramString, resolveActiveTelegramBinding, } from './utils.js';
+import { TELEGRAM_REPLY_LIMIT, chunkTelegramReply, } from './chunking.js';
+function collapseWhitespace(value) {
+    return readTelegramString(value)?.replace(/\s+/gu, ' ') ?? null;
+}
+function extractMessageText(message) {
+    return collapseWhitespace(message?.text ?? message?.caption);
+}
+function stripNewRoomPrefix(body) {
+    return body.replace(/^\/new(?:\s+|$)/u, '').replace(/^(?:new room|new topic):\s*/iu, '').trim();
+}
+function shouldCreateNewRoom(message, linkedRoomId) {
+    if (!linkedRoomId) {
+        return true;
+    }
+    const body = extractMessageText(message)?.toLowerCase() ?? '';
+    return body === '/new'
+        || body.startsWith('/new ')
+        || body.startsWith('new room:')
+        || body.startsWith('new topic:');
+}
+function buildInboundBody(message) {
+    const rawText = extractMessageText(message);
+    const strippedText = rawText ? stripNewRoomPrefix(rawText) : null;
+    const attachments = message ? normalizeTelegramAttachments(message) : [];
+    const attachmentLabel = attachments.length > 0
+        ? `Attachments: ${attachments.map((attachment) => attachment.kind).join(', ')}`
+        : null;
+    if (strippedText && attachmentLabel) {
+        return `${strippedText}\n\n${attachmentLabel}`;
+    }
+    if (strippedText) {
+        return strippedText;
+    }
+    if (attachmentLabel) {
+        return attachmentLabel;
+    }
+    return 'Telegram message received.';
+}
+function resolveSenderName(message, receipt, sender = message?.from ?? null) {
+    const firstName = readTelegramString(sender?.first_name);
+    const lastName = readTelegramString(sender?.last_name);
+    const displayName = [firstName, lastName].filter(Boolean).join(' ').trim();
+    if (displayName) {
+        return displayName;
+    }
+    if (receipt.messageSummary?.senderUsername) {
+        return `@${receipt.messageSummary.senderUsername}`;
+    }
+    return 'Telegram';
+}
+function truncateLabel(value, limit) {
+    return value.length <= limit ? value : `${value.slice(0, Math.max(1, limit - 1))}…`;
+}
+const TELEGRAM_IMPLICIT_PRODUCT_INTENT_CALLBACK_PREFIX = 'ipi:v1';
+const TELEGRAM_CAT_PRODUCT_INTENT_CALLBACK_PREFIX = 'cpi:v2';
+const TELEGRAM_WORK_INTAKE_PROPOSAL_CALLBACK_PREFIX = 'wip:v1';
+const TELEGRAM_WORK_EXECUTION_PREPARATION_CALLBACK_PREFIX = 'wep:v1';
+const WORK_INTAKE_PROPOSAL_CAPTURE_OPTION_ID = 'capture_work_items';
+const WORK_INTAKE_PROPOSAL_DECLINE_OPTION_ID = 'decline';
+const WORK_INTAKE_PROPOSAL_METADATA_KEY = 'workIntakeProposal';
+const WORK_EXECUTION_PREPARATION_CREATE_TASKS_OPTION_ID = 'create_ready_execution_tasks';
+const WORK_EXECUTION_PREPARATION_DECLINE_OPTION_ID = 'decline_execution_preparation';
+const WORK_EXECUTION_PREPARATION_PROPOSAL_METADATA_KEY = 'workExecutionPreparationProposal';
+const WORK_ITEM_PROPOSE_SPLIT_TOOL = 'work.item.propose_split';
+const WORK_ITEM_PREPARE_EXECUTION_TOOL = 'work.item.prepare_execution';
+function readTelegramImplicitProductIntentCandidate(message) {
+    const metadata = message.metadata?.implicitProductIntentCandidate;
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
+        return null;
+    }
+    const record = metadata;
+    const source = record.source;
+    const candidate = record.candidate;
+    if (record.version !== 1
+        || record.event !== 'suggested'
+        || typeof record.candidateId !== 'string'
+        || !source
+        || typeof source !== 'object'
+        || Array.isArray(source)
+        || typeof source.messageId !== 'string'
+        || !candidate
+        || typeof candidate !== 'object'
+        || Array.isArray(candidate)
+        || (candidate.targetProduct !== 'work'
+            && candidate.targetProduct !== 'code')) {
+        return null;
+    }
+    return {
+        candidateId: record.candidateId,
+        sourceMessageId: source.messageId,
+        targetProduct: candidate.targetProduct,
+    };
+}
+function readTelegramCatProductIntentProposal(message) {
+    const metadata = message.metadata?.catProductIntentProposal;
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
+        return null;
+    }
+    const record = metadata;
+    const source = record.source;
+    const proposal = record.proposal;
+    if (record.version !== 2
+        || record.event !== 'proposed'
+        || typeof record.proposalId !== 'string'
+        || !source
+        || typeof source !== 'object'
+        || Array.isArray(source)
+        || typeof source.messageId !== 'string'
+        || !proposal
+        || typeof proposal !== 'object'
+        || Array.isArray(proposal)
+        || (proposal.targetProduct !== 'work'
+            && proposal.targetProduct !== 'code')) {
+        return null;
+    }
+    return {
+        proposalId: record.proposalId,
+        sourceMessageId: source.messageId,
+        targetProduct: proposal.targetProduct,
+    };
+}
+function readTelegramWorkIntakeProposal(message) {
+    const metadata = message.metadata?.[WORK_INTAKE_PROPOSAL_METADATA_KEY];
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
+        return null;
+    }
+    const record = metadata;
+    if (record.schemaVersion !== 1
+        || record.phase !== 'intake'
+        || record.toolName !== WORK_ITEM_PROPOSE_SPLIT_TOOL
+        || typeof record.proposalId !== 'string'
+        || typeof record.sourceMessageId !== 'string') {
+        return null;
+    }
+    return {
+        proposalId: record.proposalId,
+        sourceMessageId: record.sourceMessageId,
+    };
+}
+function readTelegramWorkExecutionPreparationProposal(message) {
+    const metadata = message.metadata?.[WORK_EXECUTION_PREPARATION_PROPOSAL_METADATA_KEY];
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
+        return null;
+    }
+    const record = metadata;
+    if (record.schemaVersion !== 1
+        || record.phase !== 'execution_preparation'
+        || record.toolName !== WORK_ITEM_PREPARE_EXECUTION_TOOL
+        || typeof record.proposalId !== 'string'
+        || typeof record.sourceMessageId !== 'string') {
+        return null;
+    }
+    return {
+        proposalId: record.proposalId,
+        sourceMessageId: record.sourceMessageId,
+    };
+}
+export function buildTelegramImplicitProductIntentCallbackData(input) {
+    const compactTarget = input.targetProduct === 'code' ? 'c' : 'w';
+    return `${TELEGRAM_IMPLICIT_PRODUCT_INTENT_CALLBACK_PREFIX}:${input.sourceMessageId}:${compactTarget}:${input.action}`;
+}
+export function parseTelegramImplicitProductIntentCallbackData(value) {
+    const normalized = readTelegramString(value);
+    if (!normalized?.startsWith(`${TELEGRAM_IMPLICIT_PRODUCT_INTENT_CALLBACK_PREFIX}:`)) {
+        return null;
+    }
+    const [, , sourceMessageId, compactTarget, action] = normalized.split(':');
+    if (!sourceMessageId
+        || (compactTarget !== 'w' && compactTarget !== 'c')
+        || (action !== 'confirm' && action !== 'decline')) {
+        return null;
+    }
+    return {
+        sourceMessageId,
+        targetProduct: compactTarget === 'c' ? 'code' : 'work',
+        action,
+    };
+}
+export function buildTelegramCatProductIntentProposalCallbackData(input) {
+    const compactTarget = input.targetProduct === 'code' ? 'c' : 'w';
+    return `${TELEGRAM_CAT_PRODUCT_INTENT_CALLBACK_PREFIX}:${input.sourceMessageId}:${compactTarget}:${input.action}`;
+}
+export function parseTelegramCatProductIntentProposalCallbackData(value) {
+    const normalized = readTelegramString(value);
+    if (!normalized?.startsWith(`${TELEGRAM_CAT_PRODUCT_INTENT_CALLBACK_PREFIX}:`)) {
+        return null;
+    }
+    const [, , sourceMessageId, compactTarget, action] = normalized.split(':');
+    if (!sourceMessageId
+        || (compactTarget !== 'w' && compactTarget !== 'c')
+        || (action !== 'confirm' && action !== 'decline')) {
+        return null;
+    }
+    return {
+        sourceMessageId,
+        targetProduct: compactTarget === 'c' ? 'code' : 'work',
+        action,
+    };
+}
+export function buildTelegramWorkIntakeProposalCallbackData(input) {
+    return `${TELEGRAM_WORK_INTAKE_PROPOSAL_CALLBACK_PREFIX}:${input.sourceMessageId}:${input.action}`;
+}
+export function parseTelegramWorkIntakeProposalCallbackData(value) {
+    const normalized = readTelegramString(value);
+    if (!normalized?.startsWith(`${TELEGRAM_WORK_INTAKE_PROPOSAL_CALLBACK_PREFIX}:`)) {
+        return null;
+    }
+    const [, , sourceMessageId, action] = normalized.split(':');
+    if (!sourceMessageId
+        || (action !== 'capture' && action !== 'decline')) {
+        return null;
+    }
+    return {
+        sourceMessageId,
+        action,
+    };
+}
+export function buildTelegramWorkExecutionPreparationCallbackData(input) {
+    const compactAction = input.action === 'create_tasks' ? 'create' : 'decline';
+    return `${TELEGRAM_WORK_EXECUTION_PREPARATION_CALLBACK_PREFIX}:${input.sourceMessageId}:${compactAction}`;
+}
+export function parseTelegramWorkExecutionPreparationCallbackData(value) {
+    const normalized = readTelegramString(value);
+    if (!normalized?.startsWith(`${TELEGRAM_WORK_EXECUTION_PREPARATION_CALLBACK_PREFIX}:`)) {
+        return null;
+    }
+    const [, , sourceMessageId, compactAction] = normalized.split(':');
+    if (!sourceMessageId
+        || (compactAction !== 'create' && compactAction !== 'decline')) {
+        return null;
+    }
+    return {
+        sourceMessageId,
+        action: compactAction === 'create' ? 'create_tasks' : 'decline',
+    };
+}
+function parseTelegramProductIntentCallbackData(value) {
+    const workIntakeProposal = parseTelegramWorkIntakeProposalCallbackData(value);
+    if (workIntakeProposal) {
+        return { kind: 'work_intake_proposal', ...workIntakeProposal };
+    }
+    const workExecutionPreparation = parseTelegramWorkExecutionPreparationCallbackData(value);
+    if (workExecutionPreparation) {
+        return { kind: 'work_execution_preparation', ...workExecutionPreparation };
+    }
+    const catProposal = parseTelegramCatProductIntentProposalCallbackData(value);
+    if (catProposal) {
+        return { kind: 'cat_proposal', ...catProposal };
+    }
+    const implicitCandidate = parseTelegramImplicitProductIntentCallbackData(value);
+    return implicitCandidate
+        ? { kind: 'implicit_candidate', ...implicitCandidate }
+        : null;
+}
+function resolveTelegramImplicitProductIntentButtonCallbackData(input) {
+    if (input.optionId === 'decline') {
+        return buildTelegramImplicitProductIntentCallbackData({
+            sourceMessageId: input.candidate.sourceMessageId,
+            targetProduct: input.candidate.targetProduct,
+            action: 'decline',
+        });
+    }
+    const expectedConfirmOption = input.candidate.targetProduct === 'code'
+        ? 'confirm_code'
+        : 'confirm_work';
+    if (input.optionId !== expectedConfirmOption) {
+        return null;
+    }
+    return buildTelegramImplicitProductIntentCallbackData({
+        sourceMessageId: input.candidate.sourceMessageId,
+        targetProduct: input.candidate.targetProduct,
+        action: 'confirm',
+    });
+}
+function resolveTelegramCatProductIntentProposalButtonCallbackData(input) {
+    if (input.optionId === 'decline') {
+        return buildTelegramCatProductIntentProposalCallbackData({
+            sourceMessageId: input.sourceMessageId,
+            targetProduct: input.proposal.targetProduct,
+            action: 'decline',
+        });
+    }
+    const expectedConfirmOption = input.proposal.targetProduct === 'code'
+        ? 'confirm_code'
+        : 'confirm_work';
+    if (input.optionId !== expectedConfirmOption) {
+        return null;
+    }
+    return buildTelegramCatProductIntentProposalCallbackData({
+        sourceMessageId: input.sourceMessageId,
+        targetProduct: input.proposal.targetProduct,
+        action: 'confirm',
+    });
+}
+function resolveTelegramWorkIntakeProposalButtonCallbackData(input) {
+    if (input.optionId === WORK_INTAKE_PROPOSAL_CAPTURE_OPTION_ID) {
+        return buildTelegramWorkIntakeProposalCallbackData({
+            sourceMessageId: input.sourceMessageId,
+            action: 'capture',
+        });
+    }
+    if (input.optionId === WORK_INTAKE_PROPOSAL_DECLINE_OPTION_ID) {
+        return buildTelegramWorkIntakeProposalCallbackData({
+            sourceMessageId: input.sourceMessageId,
+            action: 'decline',
+        });
+    }
+    return null;
+}
+function resolveTelegramWorkExecutionPreparationButtonCallbackData(input) {
+    if (input.optionId === WORK_EXECUTION_PREPARATION_CREATE_TASKS_OPTION_ID) {
+        return buildTelegramWorkExecutionPreparationCallbackData({
+            sourceMessageId: input.sourceMessageId,
+            action: 'create_tasks',
+        });
+    }
+    if (input.optionId === WORK_EXECUTION_PREPARATION_DECLINE_OPTION_ID) {
+        return buildTelegramWorkExecutionPreparationCallbackData({
+            sourceMessageId: input.sourceMessageId,
+            action: 'decline',
+        });
+    }
+    return null;
+}
+export function buildTelegramImplicitProductIntentReplyMarkup(message) {
+    const candidate = readTelegramImplicitProductIntentCandidate(message);
+    const choice = message.choices?.[0] ?? null;
+    if (!candidate || !choice) {
+        return null;
+    }
+    const buttons = choice.options.flatMap((option) => {
+        const callbackData = resolveTelegramImplicitProductIntentButtonCallbackData({
+            candidate,
+            optionId: option.id,
+        });
+        return callbackData
+            ? [{ text: option.label, callback_data: callbackData }]
+            : [];
+    });
+    if (buttons.length === 0) {
+        return null;
+    }
+    return {
+        inline_keyboard: [buttons],
+    };
+}
+export function buildTelegramCatProductIntentProposalReplyMarkup(message) {
+    const proposal = readTelegramCatProductIntentProposal(message);
+    const choice = message.choices?.[0] ?? null;
+    if (!proposal || !choice || !message.id) {
+        return null;
+    }
+    const buttons = choice.options.flatMap((option) => {
+        const callbackData = resolveTelegramCatProductIntentProposalButtonCallbackData({
+            sourceMessageId: message.id,
+            proposal,
+            optionId: option.id,
+        });
+        return callbackData
+            ? [{ text: option.label, callback_data: callbackData }]
+            : [];
+    });
+    if (buttons.length === 0) {
+        return null;
+    }
+    return {
+        inline_keyboard: [buttons],
+    };
+}
+export function buildTelegramWorkIntakeProposalReplyMarkup(message) {
+    const proposal = readTelegramWorkIntakeProposal(message);
+    const choice = message.choices?.[0] ?? null;
+    if (!proposal || !choice || !message.id) {
+        return null;
+    }
+    const buttons = choice.options.flatMap((option) => {
+        const callbackData = resolveTelegramWorkIntakeProposalButtonCallbackData({
+            sourceMessageId: message.id,
+            optionId: option.id,
+        });
+        return callbackData
+            ? [{ text: option.label, callback_data: callbackData }]
+            : [];
+    });
+    if (buttons.length === 0) {
+        return null;
+    }
+    return {
+        inline_keyboard: [buttons],
+    };
+}
+export function buildTelegramWorkExecutionPreparationReplyMarkup(message) {
+    const proposal = readTelegramWorkExecutionPreparationProposal(message);
+    const choice = message.choices?.[0] ?? null;
+    if (!proposal || !choice || !message.id) {
+        return null;
+    }
+    const buttons = choice.options.flatMap((option) => {
+        const callbackData = resolveTelegramWorkExecutionPreparationButtonCallbackData({
+            sourceMessageId: message.id,
+            optionId: option.id,
+        });
+        return callbackData
+            ? [{ text: option.label, callback_data: callbackData }]
+            : [];
+    });
+    if (buttons.length === 0) {
+        return null;
+    }
+    return {
+        inline_keyboard: [buttons],
+    };
+}
+export function buildTelegramProductIntentReplyMarkup(message) {
+    return buildTelegramWorkExecutionPreparationReplyMarkup(message)
+        ?? buildTelegramWorkIntakeProposalReplyMarkup(message)
+        ?? buildTelegramCatProductIntentProposalReplyMarkup(message)
+        ?? buildTelegramImplicitProductIntentReplyMarkup(message);
+}
+function resolveTelegramImplicitCandidateForCallback(input) {
+    return input.channel.messages.find((message) => {
+        const candidate = readTelegramImplicitProductIntentCandidate(message);
+        return candidate?.sourceMessageId === input.sourceMessageId
+            && candidate.targetProduct === input.targetProduct;
+    }) ?? null;
+}
+function resolveTelegramCatProposalForCallback(input) {
+    return input.channel.messages.find((message) => {
+        if (message.id !== input.sourceMessageId) {
+            return false;
+        }
+        const proposal = readTelegramCatProductIntentProposal(message);
+        return proposal?.targetProduct === input.targetProduct;
+    }) ?? null;
+}
+function resolveTelegramWorkIntakeProposalForCallback(input) {
+    return input.channel.messages.find((message) => {
+        if (message.id !== input.sourceMessageId) {
+            return false;
+        }
+        return readTelegramWorkIntakeProposal(message) !== null;
+    }) ?? null;
+}
+function resolveTelegramWorkExecutionPreparationForCallback(input) {
+    return input.channel.messages.find((message) => {
+        if (message.id !== input.sourceMessageId) {
+            return false;
+        }
+        return readTelegramWorkExecutionPreparationProposal(message) !== null;
+    }) ?? null;
+}
+function buildChoiceResponseBody(input) {
+    return input.label;
+}
+export function buildTelegramImplicitProductIntentChoiceResponse(input) {
+    const candidate = readTelegramImplicitProductIntentCandidate(input.message);
+    const choice = input.message.choices?.[0] ?? null;
+    if (!candidate || !choice) {
+        return null;
+    }
+    const optionId = input.action === 'decline'
+        ? 'decline'
+        : candidate.targetProduct === 'code'
+            ? 'confirm_code'
+            : 'confirm_work';
+    const option = choice.options.find((candidateOption) => candidateOption.id === optionId) ?? null;
+    if (!option || !input.message.id) {
+        return null;
+    }
+    return {
+        body: buildChoiceResponseBody({
+            label: option.label,
+        }),
+        choiceResponse: {
+            sourceMessageId: input.message.id,
+            status: 'submitted',
+            submittedAt: input.submittedAt,
+            answers: [
+                {
+                    question: choice.question,
+                    selectedOptionIds: [optionId],
+                },
+            ],
+        },
+    };
+}
+export function buildTelegramCatProductIntentProposalChoiceResponse(input) {
+    const proposal = readTelegramCatProductIntentProposal(input.message);
+    const choice = input.message.choices?.[0] ?? null;
+    if (!proposal || !choice) {
+        return null;
+    }
+    const optionId = input.action === 'decline'
+        ? 'decline'
+        : proposal.targetProduct === 'code'
+            ? 'confirm_code'
+            : 'confirm_work';
+    const option = choice.options.find((candidateOption) => candidateOption.id === optionId) ?? null;
+    if (!option || !input.message.id) {
+        return null;
+    }
+    return {
+        body: buildChoiceResponseBody({
+            label: option.label,
+        }),
+        choiceResponse: {
+            sourceMessageId: input.message.id,
+            status: 'submitted',
+            submittedAt: input.submittedAt,
+            answers: [
+                {
+                    question: choice.question,
+                    selectedOptionIds: [optionId],
+                },
+            ],
+        },
+    };
+}
+export function buildTelegramWorkIntakeProposalChoiceResponse(input) {
+    const proposal = readTelegramWorkIntakeProposal(input.message);
+    const choice = input.message.choices?.[0] ?? null;
+    if (!proposal || !choice) {
+        return null;
+    }
+    const optionId = input.action === 'capture'
+        ? WORK_INTAKE_PROPOSAL_CAPTURE_OPTION_ID
+        : WORK_INTAKE_PROPOSAL_DECLINE_OPTION_ID;
+    const option = choice.options.find((candidateOption) => candidateOption.id === optionId) ?? null;
+    if (!option || !input.message.id) {
+        return null;
+    }
+    return {
+        body: buildChoiceResponseBody({
+            label: option.label,
+        }),
+        choiceResponse: {
+            sourceMessageId: input.message.id,
+            status: 'submitted',
+            submittedAt: input.submittedAt,
+            answers: [
+                {
+                    question: choice.question,
+                    selectedOptionIds: [optionId],
+                },
+            ],
+        },
+    };
+}
+export function buildTelegramWorkExecutionPreparationChoiceResponse(input) {
+    const proposal = readTelegramWorkExecutionPreparationProposal(input.message);
+    const choice = input.message.choices?.[0] ?? null;
+    if (!proposal || !choice) {
+        return null;
+    }
+    const optionId = input.action === 'create_tasks'
+        ? WORK_EXECUTION_PREPARATION_CREATE_TASKS_OPTION_ID
+        : WORK_EXECUTION_PREPARATION_DECLINE_OPTION_ID;
+    const option = choice.options.find((candidateOption) => candidateOption.id === optionId) ?? null;
+    if (!option || !input.message.id) {
+        return null;
+    }
+    return {
+        body: buildChoiceResponseBody({
+            label: option.label,
+        }),
+        choiceResponse: {
+            sourceMessageId: input.message.id,
+            status: 'submitted',
+            submittedAt: input.submittedAt,
+            answers: [
+                {
+                    question: choice.question,
+                    selectedOptionIds: [optionId],
+                },
+            ],
+        },
+    };
+}
+function resolveTelegramProductIntentChoicePayload(input) {
+    if (input.callback.kind === 'work_execution_preparation') {
+        const proposalMessage = resolveTelegramWorkExecutionPreparationForCallback({
+            channel: input.channel,
+            sourceMessageId: input.callback.sourceMessageId,
+        });
+        return proposalMessage
+            ? buildTelegramWorkExecutionPreparationChoiceResponse({
+                message: proposalMessage,
+                action: input.callback.action,
+                submittedAt: input.submittedAt,
+            })
+            : null;
+    }
+    if (input.callback.kind === 'work_intake_proposal') {
+        const proposalMessage = resolveTelegramWorkIntakeProposalForCallback({
+            channel: input.channel,
+            sourceMessageId: input.callback.sourceMessageId,
+        });
+        return proposalMessage
+            ? buildTelegramWorkIntakeProposalChoiceResponse({
+                message: proposalMessage,
+                action: input.callback.action,
+                submittedAt: input.submittedAt,
+            })
+            : null;
+    }
+    if (input.callback.kind === 'cat_proposal') {
+        const proposalMessage = resolveTelegramCatProposalForCallback({
+            channel: input.channel,
+            sourceMessageId: input.callback.sourceMessageId,
+            targetProduct: input.callback.targetProduct,
+        });
+        return proposalMessage
+            ? buildTelegramCatProductIntentProposalChoiceResponse({
+                message: proposalMessage,
+                action: input.callback.action,
+                submittedAt: input.submittedAt,
+            })
+            : null;
+    }
+    const candidateMessage = resolveTelegramImplicitCandidateForCallback({
+        channel: input.channel,
+        sourceMessageId: input.callback.sourceMessageId,
+        targetProduct: input.callback.targetProduct,
+    });
+    return candidateMessage
+        ? buildTelegramImplicitProductIntentChoiceResponse({
+            message: candidateMessage,
+            action: input.callback.action,
+            submittedAt: input.submittedAt,
+        })
+        : null;
+}
+function resolveInternalRoomMode(binding) {
+    return binding?.roomMode === 'direct_message' ? 'direct_message' : 'chat_channel';
+}
+function resolveBoundCat(state, binding, context) {
+    const actorId = binding?.catActorId ?? binding?.bossCatActorId ?? context.bossCatActorId ?? null;
+    if (!actorId) {
+        return { catId: null, catName: context.bossCatName };
+    }
+    const cat = state.cats.find((candidate) => createCatActorId(candidate.id) === actorId) ?? null;
+    return {
+        catId: cat?.id ?? null,
+        catName: cat?.name ?? context.bossCatName,
+    };
+}
+function buildRoomTitle(message, fallbackCatName) {
+    const preview = extractMessageText(message);
+    if (preview) {
+        return truncateLabel(`Telegram · ${preview}`, 72);
+    }
+    return fallbackCatName
+        ? `Telegram · ${fallbackCatName}`
+        : 'Telegram inbox';
+}
+function buildRoomTopic(binding, senderName, chatId) {
+    const viaBot = binding?.botName ? `via @${binding.botName}` : 'via Telegram';
+    const sender = senderName || chatId || 'Telegram';
+    return `Telegram inbox ${viaBot} from ${sender}`;
+}
+function roomExists(state, roomId) {
+    return typeof roomId === 'string'
+        && roomId.length > 0
+        && state.channels.some((channel) => channel.id === roomId);
+}
+function restoreSelection(state, selectedChannelId) {
+    if (!selectedChannelId || state.selectedChannelId === selectedChannelId) {
+        return state;
+    }
+    if (!state.channels.some((channel) => channel.id === selectedChannelId)) {
+        return state;
+    }
+    return {
+        ...state,
+        selectedChannelId,
+    };
+}
+function buildTelegramReplyText(input) {
+    const channel = input.roomBridge.readRoom(input.state, input.roomId);
+    const newMessages = channel.messages.slice(input.messageCountBeforeDispatch);
+    const replyMessage = [...newMessages].reverse().find((message) => message.senderKind === 'orchestrator' || message.senderKind === 'agent') ?? [...newMessages].reverse().find((message) => message.senderKind === 'system') ?? null;
+    const roomNote = input.roomCreated
+        ? `Opened room "${channel.title}" in Cats Chat.`
+        : `Continuing room "${channel.title}" in Cats Chat.`;
+    const detail = replyMessage?.body?.trim() || 'The inbox has been routed into Cats Chat.';
+    const combined = `${roomNote}\n\n${detail}`;
+    return combined.length <= TELEGRAM_REPLY_LIMIT
+        ? combined
+        : `${combined.slice(0, TELEGRAM_REPLY_LIMIT - 1)}…`;
+}
+function roomHasInboundMessage(input) {
+    const channel = input.roomBridge.readRoom(input.state, input.roomId);
+    const messageStartIndex = input.messageCountBeforeDispatch == null
+        ? 0
+        : Math.max(0, input.messageCountBeforeDispatch);
+    return channel.messages
+        .slice(messageStartIndex)
+        .some((message) => message.senderKind === 'user'
+        && message.senderName === input.senderName
+        && message.body === input.inboundBody);
+}
+function describeBridgeFailure(error) {
+    if (error instanceof Error) {
+        return readTelegramString(error.message) ?? 'Unexpected internal Telegram bridge error.';
+    }
+    return 'Unexpected internal Telegram bridge error.';
+}
+export class TelegramWebhookBridgeError extends Error {
+    code;
+    roomId;
+    constructor(code, message, roomId) {
+        super(message);
+        this.code = code;
+        this.roomId = roomId;
+    }
+}
+export async function bridgeTelegramWebhookToRoom(input) {
+    if (input.receipt.status !== 'accepted'
+        || !input.receipt.mappedConversationId) {
+        return {
+            receipt: input.receipt,
+            roomId: null,
+            roomCreated: false,
+            deliveryReceipt: null,
+            messages: [],
+        };
+    }
+    const existingBinding = input.telegramRelay.resolveBinding({
+        conversationId: input.receipt.mappedConversationId,
+        chatId: input.receipt.chatId,
+        bindingId: input.receipt.bindingId,
+    });
+    const lockKey = existingBinding?.linkedRoomId
+        ?? `telegram:${input.receipt.bindingId ?? 'default'}:${input.receipt.mappedConversationId}`;
+    const runExclusive = input.roomBridge.runExclusive
+        ? (operation) => input.roomBridge.runExclusive(lockKey, operation)
+        : (operation) => operation();
+    return runExclusive(async () => {
+        const now = input.now ?? (() => new Date());
+        const timestamp = now();
+        const pickedMessage = pickTelegramMessage(input.update);
+        const { message } = pickedMessage;
+        const senderName = resolveSenderName(message, input.receipt, pickedMessage.sender);
+        const productIntentCallback = parseTelegramProductIntentCallbackData(input.update.callback_query?.data);
+        const activeBinding = resolveActiveTelegramBinding(input.context, input.receipt.bindingId);
+        const currentState = await input.roomBridge.readState();
+        const boundCat = resolveBoundCat(currentState, activeBinding, input.context);
+        let roomId = existingBinding?.linkedRoomId ?? null;
+        let nextState = currentState;
+        let roomCreated = false;
+        let dispatchedState = null;
+        let messageCountBeforeDispatch = null;
+        const inboundBody = buildInboundBody(message);
+        const roomMode = resolveInternalRoomMode(activeBinding);
+        const createRoomInput = {
+            title: roomMode === 'direct_message' ? '' : buildRoomTitle(message, boundCat.catName),
+            topic: buildRoomTopic(activeBinding, senderName, input.receipt.chatId),
+            roomMode,
+            defaultRecipientId: roomMode === 'direct_message' ? boundCat.catId ?? undefined : undefined,
+            participantCatIds: roomMode === 'direct_message' && boundCat.catId ? [boundCat.catId] : [],
+        };
+        try {
+            if (roomMode === 'direct_message') {
+                roomId = input.roomBridge.findReusableRoomId(nextState, createRoomInput);
+            }
+            if (!roomExists(nextState, roomId)
+                || (roomMode !== 'direct_message'
+                    && shouldCreateNewRoom(message, roomId))) {
+                const previousSelection = nextState.selectedChannelId;
+                const nextRoomState = input.roomBridge.createRoom(nextState, createRoomInput, timestamp);
+                roomId = nextRoomState.roomId;
+                nextState = restoreSelection(nextRoomState.state, previousSelection);
+                nextState = await input.roomBridge.writeState(nextState);
+                roomCreated = true;
+            }
+            if (!roomId) {
+                return {
+                    receipt: input.receipt,
+                    roomId: null,
+                    roomCreated: false,
+                    deliveryReceipt: null,
+                    messages: [],
+                };
+            }
+            const linkedBinding = input.telegramRelay.linkRoom({
+                conversationId: input.receipt.mappedConversationId,
+                chatId: input.receipt.chatId,
+                bindingId: input.receipt.bindingId,
+                roomId,
+                linkedAt: timestamp.toISOString(),
+            });
+            const channelBeforeDispatch = input.roomBridge.readRoom(nextState, roomId);
+            messageCountBeforeDispatch = channelBeforeDispatch.messages.length;
+            if (productIntentCallback) {
+                let deliveryReceipt = null;
+                const callbackQueryId = readTelegramString(input.update.callback_query?.id);
+                if (callbackQueryId) {
+                    deliveryReceipt = await input.telegramRelay.deliver({
+                        request: {
+                            operation: 'answer_callback',
+                            conversationId: input.receipt.mappedConversationId,
+                            chatId: input.receipt.chatId,
+                            callbackQueryId,
+                        },
+                        context: input.context,
+                    });
+                }
+                const choicePayload = resolveTelegramProductIntentChoicePayload({
+                    channel: channelBeforeDispatch,
+                    callback: productIntentCallback,
+                    submittedAt: timestamp.toISOString(),
+                });
+                if (!choicePayload) {
+                    return {
+                        receipt: {
+                            ...input.receipt,
+                            roomRouting: describeTelegramRoomRouting(linkedBinding),
+                        },
+                        roomId,
+                        roomCreated,
+                        deliveryReceipt,
+                        messages: [],
+                    };
+                }
+                const dispatch = await input.roomBridge.routeRoomMessage({
+                    state: nextState,
+                    roomId,
+                    body: choicePayload.body,
+                    senderName,
+                    choiceResponse: choicePayload.choiceResponse,
+                    bindingId: input.receipt.bindingId,
+                    transportLocale: input.update.callback_query?.from?.language_code ?? null,
+                    runtimeClient: input.runtimeClient,
+                    memoryService: input.memoryService,
+                    timestamp,
+                });
+                dispatchedState = dispatch.state;
+                const persistedState = await input.roomBridge.writeState(restoreSelection(dispatch.state, currentState.selectedChannelId));
+                nextState = persistedState;
+                const appendedMessages = input.roomBridge
+                    .readRoom(persistedState, roomId)
+                    .messages
+                    .slice(messageCountBeforeDispatch);
+                const replyText = buildTelegramReplyText({
+                    roomBridge: input.roomBridge,
+                    state: persistedState,
+                    roomId,
+                    roomCreated,
+                    messageCountBeforeDispatch,
+                });
+                const chunks = chunkTelegramReply(replyText, TELEGRAM_REPLY_LIMIT);
+                for (const chunk of chunks) {
+                    deliveryReceipt = await input.telegramRelay.deliver({
+                        request: {
+                            operation: 'send',
+                            conversationId: input.receipt.mappedConversationId,
+                            chatId: input.receipt.chatId,
+                            text: chunk,
+                            disableLinkPreview: true,
+                        },
+                        context: input.context,
+                    });
+                }
+                return {
+                    receipt: {
+                        ...input.receipt,
+                        roomRouting: describeTelegramRoomRouting(linkedBinding),
+                    },
+                    roomId,
+                    roomCreated,
+                    deliveryReceipt,
+                    messages: appendedMessages,
+                };
+            }
+            const dispatch = await input.roomBridge.routeRoomMessage({
+                state: nextState,
+                roomId,
+                body: inboundBody,
+                senderName,
+                bindingId: input.receipt.bindingId,
+                transportLocale: message?.from?.language_code ?? null,
+                runtimeClient: input.runtimeClient,
+                memoryService: input.memoryService,
+                timestamp,
+            });
+            dispatchedState = dispatch.state;
+            const persistedState = await input.roomBridge.writeState(restoreSelection(dispatch.state, currentState.selectedChannelId));
+            nextState = persistedState;
+            const appendedMessages = input.roomBridge
+                .readRoom(persistedState, roomId)
+                .messages
+                .slice(messageCountBeforeDispatch);
+            const replyText = buildTelegramReplyText({
+                roomBridge: input.roomBridge,
+                state: persistedState,
+                roomId,
+                roomCreated,
+                messageCountBeforeDispatch,
+            });
+            const chunks = chunkTelegramReply(replyText, TELEGRAM_REPLY_LIMIT);
+            let deliveryReceipt = null;
+            for (const chunk of chunks) {
+                deliveryReceipt = await input.telegramRelay.deliver({
+                    request: {
+                        operation: input.receipt.messageId && !deliveryReceipt ? 'reply' : 'send',
+                        conversationId: input.receipt.mappedConversationId,
+                        chatId: input.receipt.chatId,
+                        replyToMessageId: !deliveryReceipt ? input.receipt.messageId : undefined,
+                        text: chunk,
+                        disableLinkPreview: true,
+                    },
+                    context: input.context,
+                });
+            }
+            for (const message of appendedMessages) {
+                const replyMarkup = buildTelegramProductIntentReplyMarkup(message);
+                if (!replyMarkup) {
+                    continue;
+                }
+                deliveryReceipt = await input.telegramRelay.deliver({
+                    request: {
+                        operation: 'send',
+                        conversationId: input.receipt.mappedConversationId,
+                        chatId: input.receipt.chatId,
+                        text: message.body,
+                        replyMarkup,
+                        disableLinkPreview: true,
+                    },
+                    context: input.context,
+                });
+            }
+            return {
+                receipt: {
+                    ...input.receipt,
+                    roomRouting: describeTelegramRoomRouting(linkedBinding),
+                },
+                roomId,
+                roomCreated,
+                deliveryReceipt,
+                messages: appendedMessages,
+            };
+        }
+        catch (error) {
+            const errorMessage = describeBridgeFailure(error);
+            let surfacedErrorMessage = errorMessage;
+            if (roomId) {
+                const recoverySourceState = dispatchedState ?? nextState;
+                try {
+                    nextState = await input.roomBridge.writeState(restoreSelection(input.roomBridge.buildRecoveryState({
+                        state: recoverySourceState,
+                        roomId,
+                        senderName,
+                        inboundBody,
+                        occurredAt: timestamp,
+                        errorMessage,
+                        includeInboundMessage: !roomHasInboundMessage({
+                            roomBridge: input.roomBridge,
+                            state: recoverySourceState,
+                            roomId,
+                            senderName,
+                            inboundBody,
+                            messageCountBeforeDispatch,
+                        }),
+                        bindingId: input.receipt.bindingId,
+                    }), currentState.selectedChannelId));
+                    input.telegramRelay.linkRoom({
+                        conversationId: input.receipt.mappedConversationId,
+                        chatId: input.receipt.chatId,
+                        bindingId: input.receipt.bindingId,
+                        roomId,
+                        linkedAt: timestamp.toISOString(),
+                    });
+                }
+                catch (recoveryError) {
+                    surfacedErrorMessage =
+                        `${errorMessage} Recovery write also failed: ${describeBridgeFailure(recoveryError)}`;
+                }
+            }
+            input.telegramRelay.recordBridgeDispatchFailure({
+                receipt: input.receipt,
+                context: input.context,
+                binding: activeBinding,
+                deliveredAt: timestamp.toISOString(),
+                errorMessage: surfacedErrorMessage,
+            });
+            throw new TelegramWebhookBridgeError('telegram_room_dispatch_failed', `Telegram webhook was accepted, but Cats Chat could not process the room turn: ${surfacedErrorMessage}`, roomId);
+        }
+    });
+}
+//# sourceMappingURL=bridge.js.map