@0xmaxma/claude-gateway 1.8.14 → 2.0.0

package/dist/api/line-webhook-router.js

@@ -40,6 +40,7 @@ exports.markMediaUnavailable = markMediaUnavailable;
 exports.parseCliPostback = parseCliPostback;
 exports.normalizeLinePostback = normalizeLinePostback;
 exports.createLineWebhookHandler = createLineWebhookHandler;
+const line_request_order_1 = require("../shared/line-request-order");
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
@@ -336,7 +337,7 @@ function pairingMessage(code, kind) {
 /**
  * Normalize a LINE webhook event into the gateway's {content, meta} intake shape.
  * Returns null for anything we don't handle (message types other than text/image/
- * file, or a source we can't key a conversation on).
+ * file/audio, or a source we can't key a conversation on).
  *
  * `resolved` lets the caller pass the source it already resolved for the access
  * gate, so a single event isn't re-parsed; omitted, it resolves here.
@@ -345,11 +346,11 @@ function normalizeLineEvent(event, resolved) {
     if (event.type !== 'message')
         return null;
     const msg = event.message;
-    // Text, image, and file are handled. Image/file bytes are fetched separately in
+    // Text, image, file and audio are normalized; audio routing is orchestration-only. Image/file bytes are fetched separately in
     // handlePost (via the LINE blob API) and surfaced to the agent through
     // meta.image_path — the generic "local path the agent should Read" channel,
     // which the runner stages into MediaStore regardless of media kind.
-    if (!msg || (msg.type !== 'text' && msg.type !== 'image' && msg.type !== 'file'))
+    if (!msg || (msg.type !== 'text' && msg.type !== 'image' && msg.type !== 'file' && msg.type !== 'audio'))
         return null;
     // Accept 1:1 user, group, and room sources. chat_id is the conversation key
     // (userId / groupId / roomId — the reply/push target); user_id is the human
@@ -368,9 +369,17 @@ function normalizeLineEvent(event, resolved) {
         ts: new Date(event.timestamp ?? Date.now()).toISOString(),
         line_chat_type: kind, // 'user' | 'group' | 'room'
     };
+    const quoted = msg.quotedMessageId;
+    if (typeof quoted === 'string')
+        meta.replied_message_id = quoted;
     if (msg.type === 'image')
         meta.media_type = 'image';
     let content = text;
+    if (msg.type === 'audio') {
+        meta.media_type = 'audio';
+        meta.attachment_kind = 'voice';
+        content = '(voice message)';
+    }
     if (msg.type === 'file') {
         const file = msg;
         meta.media_type = 'file';
@@ -410,7 +419,7 @@ function normalizeLineEvent(event, resolved) {
 function markMediaUnavailable(norm, mediaType, reason) {
     delete norm.meta.image_path;
     const name = norm.meta.attachment_name;
-    const label = mediaType === 'image' ? 'image' : name ? `file: ${name}` : 'file';
+    const label = mediaType === 'image' ? 'image' : mediaType === 'audio' ? 'audio' : name ? `file: ${name}` : 'file';
     norm.content = `(${label} — not available: ${reason})`;
 }
 /** Parse a `/cli` approve/deny postback payload, or null when it's not ours. */
@@ -509,257 +518,282 @@ function createLineWebhookHandler(agents, logDir, opts = {}) {
             req.headers.host ||
             '';
         persistPublicBase(runner.getAgentConfig().workspace, host, logger);
-        // Acknowledge immediately; process events after responding.
-        res.status(200).json({ ok: true });
-        let events = [];
+        // Orchestrated conversations retain durable admission while draining after opt-out.
+        const orchestrationConfig = runner.getAgentConfig().orchestration;
+        const durableIngress = runner.requiresDurableChannelIngress?.('line') ?? (orchestrationConfig?.enabled && (orchestrationConfig.channels ?? ['api']).includes('line'));
+        if (!durableIngress)
+            res.status(200).json({ ok: true });
         try {
-            events = JSON.parse(buf.toString('utf8')).events ?? [];
-        }
-        catch (err) {
-            logger.warn('LINE webhook: bad JSON', { error: err.message });
-            return;
-        }
-        const token = cfg?.channelAccessToken ?? '';
-        const client = token
-            ? new bot_sdk_1.messagingApi.MessagingApiClient({
-                channelAccessToken: token,
-                ...(opts.apiBase ? { baseURL: opts.apiBase } : {}),
-            })
-            : null;
-        // Blob/data API lives on a different host (api-data.line.me) than the
-        // messaging API, so it takes its own base override (used by tests).
-        const blobClient = token
-            ? new bot_sdk_1.messagingApi.MessagingApiBlobClient({
-                channelAccessToken: token,
-                ...(opts.dataApiBase ? { baseURL: opts.dataApiBase } : {}),
-            })
-            : null;
-        for (const event of events) {
-            // Postback BEFORE access gate: a tap on our slow-LLM button must reach the
-            // cache even if the user's allowlist status changed since the button was sent.
-            // The postback data is opaque (request_id we issued), so bypassing the gate here
-            // is safe — only users who received the button can tap it.
-            const pb = normalizeLinePostback(event);
-            if (pb) {
-                // `/cli` approve/deny — unlock (or reject) a terminal-viewer pairing.
-                // The pairing binds the requesting user; approveCliPairing checks the
-                // tapping user (pb.chatId, a LINE-verified id) matches, so bypassing the
-                // access gate here is safe — same as the slow-LLM postback below.
-                const cli = parseCliPostback(pb.data);
-                if (cli) {
-                    const result = runner.approveCliPairing('line', cli.pairingId, pb.chatId, cli.deny);
-                    if (client && pb.replyToken) {
-                        const text = cli.deny
-                            ? 'Denied.'
-                            : result === 'ok'
-                                ? 'Approved — return to the browser.'
-                                : 'Could not approve (the link may have expired). Send /cli again.';
-                        await client
-                            .replyMessage({ replyToken: pb.replyToken, messages: [{ type: 'text', text }] })
-                            .catch(() => { });
+            let events = [];
+            try {
+                events = JSON.parse(buf.toString('utf8')).events ?? [];
+            }
+            catch (err) {
+                logger.warn('LINE webhook: bad JSON', { error: err.message });
+                return;
+            }
+            const token = cfg?.channelAccessToken ?? '';
+            const client = token
+                ? new bot_sdk_1.messagingApi.MessagingApiClient({
+                    channelAccessToken: token,
+                    ...(opts.apiBase ? { baseURL: opts.apiBase } : {}),
+                })
+                : null;
+            // Blob/data API lives on a different host (api-data.line.me) than the
+            // messaging API, so it takes its own base override (used by tests).
+            const blobClient = token
+                ? new bot_sdk_1.messagingApi.MessagingApiBlobClient({
+                    channelAccessToken: token,
+                    ...(opts.dataApiBase ? { baseURL: opts.dataApiBase } : {}),
+                })
+                : null;
+            for (const event of events) {
+                // Postback BEFORE access gate: a tap on our slow-LLM button must reach the
+                // cache even if the user's allowlist status changed since the button was sent.
+                // The postback data is opaque (request_id we issued), so bypassing the gate here
+                // is safe — only users who received the button can tap it.
+                const pb = normalizeLinePostback(event);
+                if (pb) {
+                    if (/^orch:[a-f0-9-]{36}$/.test(pb.data)) {
+                        if (!(0, line_access_1.isResolvedSourceAllowed)(cfg, (0, line_access_1.resolveLineSource)(event.source)))
+                            continue;
+                        const forwarded = await fetch(`http://127.0.0.1:${runner.getCallbackPort()}/channel`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ content: `/orch ${pb.data.slice(5)}`, meta: { source: 'line', chat_id: pb.chatId, user_id: event.source?.userId ?? pb.chatId, reply_token: pb.replyToken } }) });
+                        if (!forwarded.ok)
+                            throw Error('Control unavailable');
+                        continue;
+                    }
+                    // `/cli` approve/deny — unlock (or reject) a terminal-viewer pairing.
+                    // The pairing binds the requesting user; approveCliPairing checks the
+                    // tapping user (pb.chatId, a LINE-verified id) matches, so bypassing the
+                    // access gate here is safe — same as the slow-LLM postback below.
+                    const cli = parseCliPostback(pb.data);
+                    if (cli) {
+                        const result = runner.approveCliPairing('line', cli.pairingId, pb.chatId, cli.deny);
+                        if (client && pb.replyToken) {
+                            const text = cli.deny
+                                ? 'Denied.'
+                                : result === 'ok'
+                                    ? 'Approved — return to the browser.'
+                                    : 'Could not approve (the link may have expired). Send /cli again.';
+                            await client
+                                .replyMessage({ replyToken: pb.replyToken, messages: [{ type: 'text', text }] })
+                                .catch(() => { });
+                        }
+                        continue;
+                    }
+                    try {
+                        await runner.handleLinePostback(pb.chatId, pb.replyToken, pb.data);
+                    }
+                    catch (err) {
+                        logger.error('LINE webhook: postback handling failed', {
+                            error: err.message,
+                        });
                     }
                     continue;
                 }
-                try {
-                    await runner.handleLinePostback(pb.chatId, pb.replyToken, pb.data);
-                }
-                catch (err) {
-                    logger.error('LINE webhook: postback handling failed', {
-                        error: err.message,
+                // Access gate (single choke point — mirrors hermes _dispatch_event):
+                // resolve the source once and gate before any message handling.
+                // Closed by default for both DMs (dmPolicy/dmAllowlist) and groups/rooms
+                // (groupPolicy/groupAllowlist). `'open'` restores answer-to-anyone.
+                const resolved = (0, line_access_1.resolveLineSource)(event.source);
+                if (!(0, line_access_1.isResolvedSourceAllowed)(cfg, resolved)) {
+                    logger.debug('LINE webhook: source not allowed', {
+                        agentId: runner.getAgentConfig().id,
+                        kind: resolved.kind,
+                        policy: (resolved.kind === 'user' ? cfg?.dmPolicy : cfg?.groupPolicy) ?? '(closed)',
+                        conversationId: resolved.conversationId,
                     });
-                }
-                continue;
-            }
-            // Access gate (single choke point — mirrors hermes _dispatch_event):
-            // resolve the source once and gate before any message handling.
-            // Closed by default for both DMs (dmPolicy/dmAllowlist) and groups/rooms
-            // (groupPolicy/groupAllowlist). `'open'` restores answer-to-anyone.
-            const resolved = (0, line_access_1.resolveLineSource)(event.source);
-            if (!(0, line_access_1.isResolvedSourceAllowed)(cfg, resolved)) {
-                logger.debug('LINE webhook: source not allowed', {
-                    agentId: runner.getAgentConfig().id,
-                    kind: resolved.kind,
-                    policy: (resolved.kind === 'user' ? cfg?.dmPolicy : cfg?.groupPolicy) ?? '(closed)',
-                    conversationId: resolved.conversationId,
-                });
-                // Remember the knock so an admin can find + add it from the UI without
-                // grepping logs, and (pairing mode) reply a one-time code the admin can
-                // visually match before +Add. The id we track is the sender (DM) or the
-                // conversation (group/room). Names are backfilled best-effort without
-                // bumping the knock count.
-                const deniedAgentId = runner.getAgentConfig().id;
-                const knockId = resolved.kind === 'user' ? resolved.senderId : resolved.conversationId;
-                if (knockId) {
-                    // Pairing applies only under allowlist/closed-default (open never
-                    // denies; disabled is hard-off) and unless explicitly turned off.
-                    const sourcePolicy = resolved.kind === 'user' ? cfg?.dmPolicy : cfg?.groupPolicy;
-                    const isPairing = cfg?.pairing !== false && sourcePolicy !== 'open' && sourcePolicy !== 'disabled';
-                    const prev = (0, pending_senders_1.getPendingSender)('line', deniedAgentId, knockId);
-                    const code = prev?.code ?? (isPairing ? (0, pending_senders_1.generatePairingCode)() : undefined);
-                    let wasNew = false;
-                    if (resolved.kind === 'user') {
-                        wasNew = (0, pending_senders_1.recordDeniedSender)('line', deniedAgentId, knockId, undefined, Date.now(), code);
-                        if (client) {
-                            void client
-                                .getProfile(knockId)
-                                .then((p) => {
-                                const e = (0, pending_senders_1.getPendingSender)('line', deniedAgentId, knockId);
-                                if (e && p?.displayName && !e.displayName)
-                                    e.displayName = p.displayName;
-                            })
-                                .catch(() => { });
+                    // Remember the knock so an admin can find + add it from the UI without
+                    // grepping logs, and (pairing mode) reply a one-time code the admin can
+                    // visually match before +Add. The id we track is the sender (DM) or the
+                    // conversation (group/room). Names are backfilled best-effort without
+                    // bumping the knock count.
+                    const deniedAgentId = runner.getAgentConfig().id;
+                    const knockId = resolved.kind === 'user' ? resolved.senderId : resolved.conversationId;
+                    if (knockId) {
+                        // Pairing applies only under allowlist/closed-default (open never
+                        // denies; disabled is hard-off) and unless explicitly turned off.
+                        const sourcePolicy = resolved.kind === 'user' ? cfg?.dmPolicy : cfg?.groupPolicy;
+                        const isPairing = cfg?.pairing !== false && sourcePolicy !== 'open' && sourcePolicy !== 'disabled';
+                        const prev = (0, pending_senders_1.getPendingSender)('line', deniedAgentId, knockId);
+                        const code = prev?.code ?? (isPairing ? (0, pending_senders_1.generatePairingCode)() : undefined);
+                        let wasNew = false;
+                        if (resolved.kind === 'user') {
+                            wasNew = (0, pending_senders_1.recordDeniedSender)('line', deniedAgentId, knockId, undefined, Date.now(), code);
+                            if (client) {
+                                void client
+                                    .getProfile(knockId)
+                                    .then((p) => {
+                                    const e = (0, pending_senders_1.getPendingSender)('line', deniedAgentId, knockId);
+                                    if (e && p?.displayName && !e.displayName)
+                                        e.displayName = p.displayName;
+                                })
+                                    .catch(() => { });
+                            }
                         }
-                    }
-                    else if (resolved.kind === 'group') {
-                        wasNew = (0, pending_senders_1.recordDeniedConversation)('line', deniedAgentId, knockId, 'group', undefined, Date.now(), code);
-                        if (client) {
+                        else if (resolved.kind === 'group') {
+                            wasNew = (0, pending_senders_1.recordDeniedConversation)('line', deniedAgentId, knockId, 'group', undefined, Date.now(), code);
+                            if (client) {
+                                void client
+                                    .getGroupSummary(knockId)
+                                    .then((s) => {
+                                    const e = (0, pending_senders_1.getPendingSender)('line', deniedAgentId, knockId);
+                                    if (e && s?.groupName && !e.displayName)
+                                        e.displayName = s.groupName;
+                                })
+                                    .catch(() => { });
+                            }
+                        }
+                        else if (resolved.kind === 'room') {
+                            wasNew = (0, pending_senders_1.recordDeniedConversation)('line', deniedAgentId, knockId, 'room', undefined, Date.now(), code);
+                        }
+                        // Send the pairing code exactly once — on first contact only — via the
+                        // free reply token (never push; don't spend quota on strangers).
+                        const replyToken = event.replyToken;
+                        if (isPairing && wasNew && code && client && typeof replyToken === 'string' && replyToken) {
                             void client
-                                .getGroupSummary(knockId)
-                                .then((s) => {
-                                const e = (0, pending_senders_1.getPendingSender)('line', deniedAgentId, knockId);
-                                if (e && s?.groupName && !e.displayName)
-                                    e.displayName = s.groupName;
+                                .replyMessage({
+                                replyToken,
+                                messages: [{ type: 'text', text: pairingMessage(code, resolved.kind) }],
                             })
-                                .catch(() => { });
+                                .catch((err) => logger.debug('LINE pairing code reply failed', { error: err.message }));
                         }
                     }
-                    else if (resolved.kind === 'room') {
-                        wasNew = (0, pending_senders_1.recordDeniedConversation)('line', deniedAgentId, knockId, 'room', undefined, Date.now(), code);
-                    }
-                    // Send the pairing code exactly once — on first contact only — via the
-                    // free reply token (never push; don't spend quota on strangers).
-                    const replyToken = event.replyToken;
-                    if (isPairing && wasNew && code && client && typeof replyToken === 'string' && replyToken) {
-                        void client
-                            .replyMessage({
-                            replyToken,
-                            messages: [{ type: 'text', text: pairingMessage(code, resolved.kind) }],
-                        })
-                            .catch((err) => logger.debug('LINE pairing code reply failed', { error: err.message }));
+                    continue;
+                }
+                // Normalize the event into our /channel intake format.
+                const norm = normalizeLineEvent(event, resolved);
+                if (!norm)
+                    continue;
+                const userId = norm.meta.chat_id;
+                // `/cli` opens the live terminal viewer (DM only). Mint a pairing and reply
+                // with an open-link + Approve/Deny buttons instead of forwarding to the
+                // agent. Reached only after the access gate above authorized this source.
+                if ((norm.content ?? '').trim().toLowerCase() === '/cli') {
+                    if (norm.meta['line_chat_type'] === 'user' && client) {
+                        const replyToken = norm.meta['reply_token'] ?? '';
+                        const pairing = runner.createCliPairing('line', userId);
+                        if (replyToken) {
+                            const messages = pairing
+                                ? [{
+                                        type: 'template',
+                                        altText: 'Live terminal viewer',
+                                        template: {
+                                            type: 'buttons',
+                                            text: `Live terminal viewer\nCode ${pairing.code} — open, confirm the code, then Approve.`,
+                                            actions: [
+                                                { type: 'uri', label: 'Open terminal', uri: pairing.url },
+                                                { type: 'postback', label: `Approve ${pairing.code}`, data: JSON.stringify({ action: 'cli_approve', pairing_id: pairing.pairingId }), displayText: 'Approve terminal viewer' },
+                                                { type: 'postback', label: 'Deny', data: JSON.stringify({ action: 'cli_deny', pairing_id: pairing.pairingId }) },
+                                            ],
+                                        },
+                                    }]
+                                : [{ type: 'text', text: 'Terminal viewer is not configured. Set gateway.publicUrl in config.json first.' }];
+                            await client.replyMessage({ replyToken, messages }).catch((err) => {
+                                logger.debug('LINE /cli reply failed', { error: err.message });
+                            });
+                        }
                     }
+                    continue;
                 }
-                continue;
-            }
-            // Normalize the event into our /channel intake format.
-            const norm = normalizeLineEvent(event, resolved);
-            if (!norm)
-                continue;
-            const userId = norm.meta.chat_id;
-            // `/cli` opens the live terminal viewer (DM only). Mint a pairing and reply
-            // with an open-link + Approve/Deny buttons instead of forwarding to the
-            // agent. Reached only after the access gate above authorized this source.
-            if ((norm.content ?? '').trim().toLowerCase() === '/cli') {
-                if (norm.meta['line_chat_type'] === 'user' && client) {
-                    const replyToken = norm.meta['reply_token'] ?? '';
-                    const pairing = runner.createCliPairing('line', userId);
-                    if (replyToken) {
-                        const messages = pairing
-                            ? [{
-                                    type: 'template',
-                                    altText: 'Live terminal viewer',
-                                    template: {
-                                        type: 'buttons',
-                                        text: `Live terminal viewer\nCode ${pairing.code} — open, confirm the code, then Approve.`,
-                                        actions: [
-                                            { type: 'uri', label: 'Open terminal', uri: pairing.url },
-                                            { type: 'postback', label: `Approve ${pairing.code}`, data: JSON.stringify({ action: 'cli_approve', pairing_id: pairing.pairingId }), displayText: 'Approve terminal viewer' },
-                                            { type: 'postback', label: 'Deny', data: JSON.stringify({ action: 'cli_deny', pairing_id: pairing.pairingId }) },
-                                        ],
-                                    },
-                                }]
-                            : [{ type: 'text', text: 'Terminal viewer is not configured. Set gateway.publicUrl in config.json first.' }];
-                        await client.replyMessage({ replyToken, messages }).catch((err) => {
-                            logger.debug('LINE /cli reply failed', { error: err.message });
+                // Group/room activation gate: unless requireMention is explicitly false,
+                // only respond when the bot is @mentioned (native isSelf or its name).
+                // DMs (line_chat_type === 'user') always pass. This runs after normalize
+                // so unhandled message types are already filtered out.
+                //
+                // NOTE: LINE attaches `mention` to TEXT messages only, so an image or file
+                // posted in a group can never satisfy this gate — such media reaches the
+                // agent in DMs, and in groups only when requireMention is false. That is
+                // the pre-existing behaviour for images and is left unchanged for files:
+                // waiving the gate for media would let any group member push attachments
+                // at the agent without ever addressing it.
+                if (norm.meta.line_chat_type !== 'user' && cfg?.requireMention !== false) {
+                    const msg = event.message;
+                    if (!(0, line_mention_1.wasBotMentioned)(msg)) {
+                        logger.debug('LINE webhook: group/room message without bot mention, ignoring', {
+                            agentId: runner.getAgentConfig().id,
+                            chatType: norm.meta.line_chat_type,
+                            conversationId: userId,
                         });
+                        continue;
                     }
                 }
-                continue;
-            }
-            // Group/room activation gate: unless requireMention is explicitly false,
-            // only respond when the bot is @mentioned (native isSelf or its name).
-            // DMs (line_chat_type === 'user') always pass. This runs after normalize
-            // so unhandled message types are already filtered out.
-            //
-            // NOTE: LINE attaches `mention` to TEXT messages only, so an image or file
-            // posted in a group can never satisfy this gate — such media reaches the
-            // agent in DMs, and in groups only when requireMention is false. That is
-            // the pre-existing behaviour for images and is left unchanged for files:
-            // waiving the gate for media would let any group member push attachments
-            // at the agent without ever addressing it.
-            if (norm.meta.line_chat_type !== 'user' && cfg?.requireMention !== false) {
-                const msg = event.message;
-                if (!(0, line_mention_1.wasBotMentioned)(msg)) {
-                    logger.debug('LINE webhook: group/room message without bot mention, ignoring', {
-                        agentId: runner.getAgentConfig().id,
-                        chatType: norm.meta.line_chat_type,
-                        conversationId: userId,
-                    });
+                // Inbound media: fetch the bytes via the blob API and hand the agent an
+                // absolute path (meta.image_path). The runner persists it to MediaStore
+                // and instructs the agent to Read it, same as Telegram attachments.
+                // Images and files share that path; meta.media_type tells them apart.
+                const mediaType = norm.meta.media_type;
+                if (mediaType === 'audio' && !(runner.getAgentConfig().orchestration?.enabled && (runner.getAgentConfig().orchestration?.channels ?? ['api']).includes('line')))
                     continue;
+                // Loading animation (best-effort, 1:1 only — LINE rejects it for
+                // groups/rooms, where chat_id is a groupId/roomId).
+                if (client && norm.meta.line_chat_type === 'user') {
+                    await (0, line_request_order_1.orderLineRequest)(runner.getAgentConfig().id, userId, () => client.showLoadingAnimation({ chatId: userId, loadingSeconds: LOADING_SECONDS }))
+                        .catch((err) => logger.debug('showLoadingAnimation failed', { error: err.message }));
                 }
-            }
-            // Inbound media: fetch the bytes via the blob API and hand the agent an
-            // absolute path (meta.image_path). The runner persists it to MediaStore
-            // and instructs the agent to Read it, same as Telegram attachments.
-            // Images and files share that path; meta.media_type tells them apart.
-            const mediaType = norm.meta.media_type;
-            if ((mediaType === 'image' || mediaType === 'file') && blobClient && norm.meta.message_id) {
-                try {
-                    let mediaPath;
-                    if (mediaType === 'image') {
-                        mediaPath = await downloadLineImage(blobClient, norm.meta.message_id);
-                    }
-                    else {
-                        // The extension comes from the RAW event name (safeFileExt sanitises
-                        // it itself) — meta.attachment_name is the display label and has
-                        // already had characters stripped, which could corrupt the suffix.
-                        const file = event.message;
-                        mediaPath = await downloadLineFile(blobClient, norm.meta.message_id, file.fileName, file.fileSize);
+                if ((mediaType === 'image' || mediaType === 'file' || mediaType === 'audio') && blobClient && norm.meta.message_id) {
+                    try {
+                        let mediaPath;
+                        if (mediaType === 'image') {
+                            mediaPath = await downloadLineImage(blobClient, norm.meta.message_id);
+                        }
+                        else if (mediaType === 'audio') {
+                            mediaPath = await downloadLineFile(blobClient, norm.meta.message_id, 'voice.m4a');
+                        }
+                        else {
+                            // The extension comes from the RAW event name (safeFileExt sanitises
+                            // it itself) — meta.attachment_name is the display label and has
+                            // already had characters stripped, which could corrupt the suffix.
+                            const file = event.message;
+                            mediaPath = await downloadLineFile(blobClient, norm.meta.message_id, file.fileName, file.fileSize);
+                        }
+                        // A null path means the blob API answered with zero bytes. Both that and
+                        // a throw leave the agent with no file, so both must say so — see
+                        // markMediaUnavailable.
+                        if (mediaPath) {
+                            norm.meta.image_path = mediaPath;
+                            // Staging copy under os.tmpdir(): the runner owns it from here and
+                            // deletes it once MediaStore has its permanent copy. Nothing else
+                            // sweeps the temp dir, so without this every inbound attachment —
+                            // up to MediaStore.maxUploadBytes each — stays on disk forever.
+                            norm.meta.media_ephemeral = '1';
+                        }
+                        else
+                            markMediaUnavailable(norm, mediaType, 'the sender uploaded no content');
                     }
-                    // A null path means the blob API answered with zero bytes. Both that and
-                    // a throw leave the agent with no file, so both must say so — see
-                    // markMediaUnavailable.
-                    if (mediaPath) {
-                        norm.meta.image_path = mediaPath;
-                        // Staging copy under os.tmpdir(): the runner owns it from here and
-                        // deletes it once MediaStore has its permanent copy. Nothing else
-                        // sweeps the temp dir, so without this every inbound attachment —
-                        // up to MediaStore.maxUploadBytes each — stays on disk forever.
-                        norm.meta.media_ephemeral = '1';
+                    catch (err) {
+                        logger.warn('LINE webhook: media download failed', {
+                            mediaType,
+                            messageId: norm.meta.message_id,
+                            error: err.message,
+                        });
+                        markMediaUnavailable(norm, mediaType, err instanceof MediaTooLargeError
+                            ? `larger than the ${Math.floor(MAX_MEDIA_BYTES / (1024 * 1024))} MB limit`
+                            : 'the download failed');
                     }
-                    else
-                        markMediaUnavailable(norm, mediaType, 'the sender uploaded no content');
+                }
+                // Forward to the agent's existing /channel intake (same path Telegram uses).
+                try {
+                    const forwarded = await fetch(`http://127.0.0.1:${runner.getCallbackPort()}/channel`, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify(norm),
+                    });
+                    if (durableIngress && !forwarded.ok)
+                        throw new Error('Durable input admission failed');
                 }
                 catch (err) {
-                    logger.warn('LINE webhook: media download failed', {
-                        mediaType,
-                        messageId: norm.meta.message_id,
+                    if (durableIngress && !res.headersSent)
+                        res.status(503).json({ error: 'Input admission unavailable' });
+                    logger.error('LINE webhook: failed to forward to callback', {
                         error: err.message,
                     });
-                    markMediaUnavailable(norm, mediaType, err instanceof MediaTooLargeError
-                        ? `larger than the ${Math.floor(MAX_MEDIA_BYTES / (1024 * 1024))} MB limit`
-                        : 'the download failed');
                 }
             }
-            // Loading animation (best-effort, 1:1 only — LINE rejects it for
-            // groups/rooms, where chat_id is a groupId/roomId).
-            if (client && norm.meta.line_chat_type === 'user') {
-                client
-                    .showLoadingAnimation({ chatId: userId, loadingSeconds: LOADING_SECONDS })
-                    .catch((err) => logger.debug('showLoadingAnimation failed', { error: err.message }));
-            }
-            // Forward to the agent's existing /channel intake (same path Telegram uses).
-            try {
-                await fetch(`http://127.0.0.1:${runner.getCallbackPort()}/channel`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(norm),
-                });
-            }
-            catch (err) {
-                logger.error('LINE webhook: failed to forward to callback', {
-                    error: err.message,
-                });
-            }
+        }
+        finally {
+            if (!res.headersSent)
+                res.status(200).json({ ok: true });
         }
     };
     return { verify: handleGet, handlePost };