Files
EJClaw/src/message-runtime-dispatch.ts
Codex fdd98e9eb8 feat: keep typing during scheduled tasks and tell waiting users
A group-context scheduled task occupies the room queue, so a human message
sent meanwhile waited silently (up to the whole task run) with no typing
indicator; the room looked unresponsive.

- Scheduled tasks (not CI watchers) hold the room's typing indicator for
  their whole run (DiscordChannel.setTypingHold: typing stays on while any
  hold is active, independent of message-turn setTyping(false)).
- A human message that has to wait behind a running scheduled task gets a
  one-time notice per wait: "지금 예약 작업을 진행하고 있습니다. 이 작업을
  마친 뒤 바로 답변드리겠습니다." (GroupQueue.claimScheduledTaskWaitNotice,
  reset when the waiting messages run).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 23:12:00 +09:00

341 lines
10 KiB
TypeScript

import { logger } from './logger.js';
import { getLatestOpenPairedTaskForChat, getMessagesSinceSeq } from './db.js';
import {
buildQueuedTurnDispatch,
executeBotOnlyPairedFollowUpAction,
} from './message-runtime-flow.js';
import { HUMAN_MESSAGE_DETECTED_CLOSE_REASON } from './message-close-reasons.js';
import {
advanceLastAgentCursor,
filterLoopingPairedBotMessages,
getProcessableMessages,
isExternalHumanMessage,
resolveCursorKey,
shouldSkipBotOnlyCollaboration,
} from './message-runtime-rules.js';
import { enqueuePairedFollowUpAfterEvent } from './message-runtime-follow-up.js';
import { stopRoomWorkIfRequested, type RoomStopControls } from './room-stop.js';
import { hasReviewerLease } from './service-routing.js';
import type { ExecuteTurnFn } from './message-runtime-types.js';
import type { ScheduledPairedFollowUpIntentKind } from './paired-follow-up-scheduler.js';
import type {
Channel,
NewMessage,
PairedTask,
PairedRoomRole,
RegisteredGroup,
} from './types.js';
type RuntimeLog = Pick<typeof logger, 'info' | 'debug'>;
function hasExternalHumanMessage(messages: NewMessage[]): boolean {
return messages.some(isExternalHumanMessage);
}
export function enqueueGenericFollowUpAfterDeliveryRetry(args: {
chatJid: string;
runId: string;
deliveryRole: PairedRoomRole;
pendingTask: PairedTask | null | undefined;
workItemId: string | number;
log: RuntimeLog;
enqueueMessageCheck: () => void;
}): void {
const followUpResult = enqueuePairedFollowUpAfterEvent({
chatJid: args.chatJid,
runId: args.runId,
task: args.pendingTask,
source: 'delivery-retry',
completedRole: args.deliveryRole,
fallbackLastTurnOutputRole: args.deliveryRole,
enqueueMessageCheck: args.enqueueMessageCheck,
});
if (followUpResult.kind === 'none') {
args.log.info(
{
workItemId: args.workItemId,
chatJid: args.chatJid,
deliveryRole: args.deliveryRole,
pendingTaskStatus: followUpResult.taskStatus,
},
'No queued follow-up was required after delivery retry',
);
return;
}
if (followUpResult.kind === 'message-check') {
return;
}
if (followUpResult.scheduled) {
args.log.info(
{
workItemId: args.workItemId,
chatJid: args.chatJid,
deliveryRole: args.deliveryRole,
taskId: followUpResult.taskId,
pendingTaskStatus: followUpResult.taskStatus,
taskStatus: followUpResult.taskStatus,
intentKind: followUpResult.intentKind,
},
'Queued paired follow-up after delivery retry',
);
return;
}
if (!followUpResult.scheduled) {
args.log.info(
{
workItemId: args.workItemId,
chatJid: args.chatJid,
deliveryRole: args.deliveryRole,
taskId: followUpResult.taskId,
pendingTaskStatus: followUpResult.taskStatus,
taskStatus: followUpResult.taskStatus,
intentKind: followUpResult.intentKind,
},
'Skipped duplicate paired follow-up enqueue after delivery retry while task state was unchanged',
);
}
}
export async function processQueuedGroupDispatch(args: {
chatJid: string;
group: RegisteredGroup;
channel: Channel;
processableGroupMessages: NewMessage[];
assistantName: string;
failureFinalText: string;
timezone: string;
lastAgentTimestamps: Record<string, string>;
saveState: () => void;
executeTurn: ExecuteTurnFn;
schedulePairedFollowUp: (
task: PairedTask | null | undefined,
intentKind: ScheduledPairedFollowUpIntentKind,
runId: string,
) => boolean;
enqueueMessageCheck: () => void;
sendQueuedMessage: (chatJid: string, text: string) => boolean;
closeStdin: (reason: string) => void;
labelPairedSenders: (chatJid: string, messages: NewMessage[]) => NewMessage[];
formatMessages: (messages: NewMessage[], timezone: string) => string;
}): Promise<void> {
const { chatJid, group, channel, processableGroupMessages } = args;
const loopPendingTask = hasReviewerLease(chatJid)
? getLatestOpenPairedTaskForChat(chatJid)
: null;
const loopCursorKey = resolveCursorKey(chatJid, loopPendingTask?.status);
const rawPendingMessages = getMessagesSinceSeq(
chatJid,
args.lastAgentTimestamps[loopCursorKey] || '0',
args.assistantName,
);
const pendingMessages = filterLoopingPairedBotMessages(
chatJid,
getProcessableMessages(chatJid, rawPendingMessages, channel),
args.failureFinalText,
);
const messagesToSend =
pendingMessages.length > 0 ? pendingMessages : processableGroupMessages;
const labeledMessagesToSend = args.labelPairedSenders(
chatJid,
messagesToSend,
);
const {
formatted,
botOnlyFollowUpAction,
isBotOnlyPairedFollowUp,
loopCursorKey: dispatchCursorKey,
endSeq,
} = buildQueuedTurnDispatch({
chatJid,
timezone: args.timezone,
loopPendingTask,
rawPendingMessages,
messagesToSend,
labeledMessagesToSend,
formatMessages: args.formatMessages,
});
const botOnlyFollowUpRunId = `loop-merge-ready-${Date.now().toString(36)}`;
if (
await executeBotOnlyPairedFollowUpAction({
action: botOnlyFollowUpAction,
chatJid,
timezone: args.timezone,
group,
runId: botOnlyFollowUpRunId,
channel,
log: logger,
saveState: args.saveState,
lastAgentTimestamps: args.lastAgentTimestamps,
executeTurn: args.executeTurn,
schedulePairedFollowUp: (task, intentKind) =>
args.schedulePairedFollowUp(task, intentKind, botOnlyFollowUpRunId),
closeStdin: () => args.closeStdin('paired-pending-turn-follow-up'),
})
) {
return;
}
if (args.sendQueuedMessage(chatJid, formatted)) {
if (endSeq != null) {
advanceLastAgentCursor(
args.lastAgentTimestamps,
args.saveState,
chatJid,
endSeq,
dispatchCursorKey,
);
}
logger.debug(
{
transition: 'typing:on',
source: 'follow-up-queued',
chatJid,
group: group.name,
groupFolder: group.folder,
endSeq: endSeq ?? null,
suppressed: isBotOnlyPairedFollowUp,
},
'Typing indicator transition',
);
if (!isBotOnlyPairedFollowUp) {
await channel
.setTyping?.(chatJid, true)
?.catch((err) =>
logger.warn({ chatJid, err }, 'Failed to set typing indicator'),
);
}
return;
}
args.enqueueMessageCheck();
}
export async function processLoopGroupMessages(args: {
chatJid: string;
group: RegisteredGroup;
groupMessages: NewMessage[];
channel: Channel;
assistantName: string;
failureFinalText: string;
hasImplicitContinuationWindow: (
chatJid: string,
messages: NewMessage[],
) => boolean;
lastAgentTimestamps: Record<string, string>;
saveState: () => void;
timezone: string;
executeTurn: ExecuteTurnFn;
schedulePairedFollowUp: (
task: PairedTask | null | undefined,
intentKind: ScheduledPairedFollowUpIntentKind,
runId: string,
) => boolean;
enqueueMessageCheck: () => void;
sendQueuedMessage: (chatJid: string, text: string) => boolean;
closeStdin: (reason: string) => void;
isRunningMessageTurn: (chatJid: string) => boolean;
/** Tells the room once that its message waits behind a running scheduled task. */
notifyScheduledTaskWait?: (chatJid: string) => Promise<void>;
roomStopControls: RoomStopControls;
labelPairedSenders: (chatJid: string, messages: NewMessage[]) => NewMessage[];
formatMessages: (messages: NewMessage[], timezone: string) => string;
}): Promise<void> {
const { chatJid, group, groupMessages, channel } = args;
const processableGroupMessages = getProcessableMessages(
chatJid,
groupMessages,
channel,
);
if (processableGroupMessages.length === 0) {
const lastIgnored = groupMessages[groupMessages.length - 1];
if (lastIgnored?.seq != null) {
advanceLastAgentCursor(
args.lastAgentTimestamps,
args.saveState,
chatJid,
lastIgnored.seq,
);
}
return;
}
if (shouldSkipBotOnlyCollaboration(chatJid, processableGroupMessages)) {
const lastIgnored =
processableGroupMessages[processableGroupMessages.length - 1];
if (lastIgnored?.seq != null) {
advanceLastAgentCursor(
args.lastAgentTimestamps,
args.saveState,
chatJid,
lastIgnored.seq,
);
}
logger.info(
{ chatJid, group: group.name, groupFolder: group.folder },
'Bot-collaboration timeout: no recent human message, skipping',
);
return;
}
const stopResult = await stopRoomWorkIfRequested({
chatJid,
group,
channel,
messages: processableGroupMessages,
assistantName: args.assistantName,
lastAgentTimestamps: args.lastAgentTimestamps,
saveState: args.saveState,
controls: args.roomStopControls,
});
if (stopResult.stopped) {
if (stopResult.hasMessagesAfterStop) {
args.enqueueMessageCheck();
}
return;
}
if (hasExternalHumanMessage(processableGroupMessages)) {
const interruptedActiveRun = args.isRunningMessageTurn(chatJid);
if (interruptedActiveRun) {
args.closeStdin(HUMAN_MESSAGE_DETECTED_CLOSE_REASON);
}
args.enqueueMessageCheck();
logger.info(
{
chatJid,
group: group.name,
groupFolder: group.folder,
messageCount: processableGroupMessages.length,
interruptedActiveRun,
},
'Queued human message for a fresh turn instead of piping into active agent',
);
await args.notifyScheduledTaskWait?.(chatJid);
return;
}
await processQueuedGroupDispatch({
chatJid,
group,
channel,
processableGroupMessages,
assistantName: args.assistantName,
failureFinalText: args.failureFinalText,
timezone: args.timezone,
lastAgentTimestamps: args.lastAgentTimestamps,
saveState: args.saveState,
executeTurn: args.executeTurn,
schedulePairedFollowUp: args.schedulePairedFollowUp,
enqueueMessageCheck: args.enqueueMessageCheck,
sendQueuedMessage: args.sendQueuedMessage,
closeStdin: args.closeStdin,
labelPairedSenders: args.labelPairedSenders,
formatMessages: args.formatMessages,
});
}