work-ally 0.2.0-alpha.1

package/bridge/src/receiver-runtime-callbacks.ts

@@ -0,0 +1,367 @@
+import type { OutboundEnvelope } from './channel-types.ts';
+import type { McpToolApprovalRule } from './config.ts';
+import { logInfo, logWarn } from './logger.ts';
+import { compactPreview } from './receiver-helpers.ts';
+import { maybeAutoResolveRuntimeUserInput } from './runtime-user-input.ts';
+import type { SessionStore } from './session-store.ts';
+import { contextCompactionStatusMessage, userInputMessage, waitingApprovalStatusMessage, waitingUserInputStatusMessage, workingNoticeMessage } from './translator.ts';
+import type { ApprovalRecord, ApprovalRequest, ConversationRef, InboundMessage, RuntimeProgressMeta, RuntimeThreadStatus, SessionMeta, UserInputRequest } from './types.ts';
+
+interface SendLike {
+  (
+    outbound: OutboundEnvelope,
+    extra?: Record<string, unknown>,
+    delivery?: { trackTurnId?: string | null },
+  ): Promise<boolean>;
+}
+
+interface RuntimeResolutionLike {
+  resolveApproval(requestId: string | number, decision: 'accept' | 'acceptForSession' | 'decline' | 'cancel'): Promise<void>;
+  resolveUserInput(requestId: string | number, response: { answers: Record<string, { answers: string[] }> }): Promise<void>;
+  resolveElicitation(
+    requestId: string | number,
+    response: { action: 'accept' | 'decline' | 'cancel'; content: unknown | null },
+  ): Promise<void>;
+}
+
+interface RuntimeCallbackState {
+  getCurrentTurnId(): string | null;
+  setCurrentTurnId(turnId: string): void;
+  setLastProgressAt(timestamp: number): void;
+  waitingApprovalNoticeState: { sent: boolean };
+  isWaitingUserInputNoticeSent(): boolean;
+  markWaitingUserInputNoticeSent(): void;
+  contextCompactionNoticeKeys: Set<string>;
+}
+
+interface RuntimeCallbackDeps {
+  sessionStore: SessionStore;
+  runtime: RuntimeResolutionLike;
+  send: SendLike;
+  mcpToolApprovalRules: McpToolApprovalRule[];
+  clearRuntimeRecovery(ref: ConversationRef): void;
+  isTurnStillCurrent(ref: ConversationRef, messageId: string, turnId: string | null): boolean;
+  isBlockingTurnStillRelevant(ref: ConversationRef, threadId: string | null, turnId: string | null): boolean;
+  noteStaleTurnSuppressed(
+    ref: ConversationRef,
+    details: {
+      messageId: string;
+      threadId: string | null;
+      turnId: string | null;
+      stage: 'progress' | 'approval' | 'user_input';
+      reason: string;
+      status?: string | null;
+    },
+  ): void;
+  shouldForwardProgressUpdate(text: string, meta?: RuntimeProgressMeta): boolean;
+  evaluateApprovalAutonomy(approval: ApprovalRecord): {
+    action: 'accept' | 'decline';
+    reason: string;
+    policy: string;
+    matchedRule?: string;
+    ruleSource?: string;
+    commandForm?: string;
+  } | null;
+  scheduleApprovalNotice(
+    conversationRef: ConversationRef,
+    threadId: string,
+    turnId: string,
+    noticeState: { sent: boolean },
+  ): void;
+}
+
+interface RuntimeCallbackContext {
+  message: InboundMessage;
+  threadId: string;
+  turnEntryMessageId: string;
+  fallbackSession: SessionMeta;
+  state: RuntimeCallbackState;
+}
+
+export function createInboundRuntimeCallbacks(
+  deps: RuntimeCallbackDeps,
+  context: RuntimeCallbackContext,
+): {
+  onTurnStarted: (turnId: string) => Promise<void>;
+  onProgress: (text: string, meta?: RuntimeProgressMeta) => Promise<void>;
+  onThreadStatus: (status: RuntimeThreadStatus, meta?: { threadId?: string | null; turnId?: string | null }) => Promise<void>;
+  onApproval: (approval: ApprovalRequest) => Promise<void>;
+  onUserInput: (request: UserInputRequest) => Promise<void>;
+} {
+  return {
+    onTurnStarted: async (turnId) => {
+      context.state.setCurrentTurnId(turnId);
+      deps.clearRuntimeRecovery(context.message.conversationRef);
+      deps.sessionStore.markActiveTurn(context.message.conversationRef, turnId, {
+        messageId: context.message.messageId,
+        promptPreview: context.message.text,
+      });
+      logInfo('receiver', 'turn_started', {
+        messageId: context.message.messageId,
+        conversationId: context.message.conversationRef.conversationId,
+        threadId: context.threadId,
+        turnId,
+      });
+    },
+    onProgress: async (text, meta) => {
+      const currentTurnId = context.state.getCurrentTurnId();
+      if (currentTurnId && !deps.isTurnStillCurrent(context.message.conversationRef, context.turnEntryMessageId, currentTurnId)) {
+        deps.noteStaleTurnSuppressed(context.message.conversationRef, {
+          messageId: context.message.messageId,
+          threadId: context.threadId,
+          turnId: currentTurnId,
+          stage: 'progress',
+          reason: 'session advanced to a newer inbound message',
+        });
+        return;
+      }
+      context.state.setLastProgressAt(Date.now());
+      deps.clearRuntimeRecovery(context.message.conversationRef);
+      if (currentTurnId) {
+        deps.sessionStore.markTurnRunning(context.message.conversationRef, currentTurnId);
+      }
+      const rawText = String(text || '');
+      const preview = compactPreview(rawText, 500);
+      if (preview) {
+        logInfo('receiver', 'runtime_progress', {
+          messageId: context.message.messageId,
+          conversationId: context.message.conversationRef.conversationId,
+          threadId: context.threadId,
+          turnId: currentTurnId,
+          progressKind: meta?.kind || null,
+          progressPhase: meta?.phase || null,
+          itemId: meta?.itemId || null,
+          preview: compactPreview(rawText, 160),
+        });
+      }
+      if (meta?.kind === 'context_compaction') {
+        const dedupeKey = `${context.threadId}:${currentTurnId || meta?.turnId || 'unknown'}:${meta?.itemId || 'unknown'}`;
+        if (context.state.contextCompactionNoticeKeys.has(dedupeKey)) {
+          return;
+        }
+        context.state.contextCompactionNoticeKeys.add(dedupeKey);
+        await deps.send({
+          type: 'status_reply',
+          conversationRef: context.message.conversationRef,
+          text: contextCompactionStatusMessage(),
+        }, {
+          source: 'runtime_context_compaction',
+          thread_id: context.threadId,
+          turn_id: currentTurnId,
+          progress_kind: meta?.kind || null,
+          progress_phase: meta?.phase || null,
+          item_id: meta?.itemId || null,
+        });
+        return;
+      }
+      if (!deps.shouldForwardProgressUpdate(rawText, meta)) {
+        return;
+      }
+      const outboundText = workingNoticeMessage(rawText);
+      if (!outboundText) {
+        return;
+      }
+      await deps.send({
+        type: 'progress_update',
+        conversationRef: context.message.conversationRef,
+        text: outboundText,
+      }, {
+        source: 'runtime_progress',
+        thread_id: context.threadId,
+        turn_id: currentTurnId,
+        progress_kind: meta?.kind || null,
+        progress_phase: meta?.phase || null,
+        item_id: meta?.itemId || null,
+      });
+    },
+    onThreadStatus: async (_status, meta) => {
+      const turnId = meta?.turnId || context.state.getCurrentTurnId();
+      if (!turnId) {
+        return;
+      }
+      if (!deps.isTurnStillCurrent(context.message.conversationRef, context.turnEntryMessageId, turnId)) {
+        return;
+      }
+      const latestSession = deps.sessionStore.getSession(context.message.conversationRef) || context.fallbackSession;
+      if (latestSession.pendingApprovalIds.length > 0) {
+        if (context.state.waitingApprovalNoticeState.sent) {
+          return;
+        }
+        context.state.waitingApprovalNoticeState.sent = true;
+        await deps.send({
+          type: 'status_reply',
+          conversationRef: context.message.conversationRef,
+          text: waitingApprovalStatusMessage(),
+        }, {
+          source: 'waiting_approval',
+          thread_id: meta?.threadId || context.threadId,
+          turn_id: turnId,
+        });
+        return;
+      }
+      if (!latestSession.pendingUserInputRequestId) {
+        return;
+      }
+      if (context.state.isWaitingUserInputNoticeSent()) {
+        return;
+      }
+      context.state.markWaitingUserInputNoticeSent();
+      const pendingInput = deps.sessionStore.getPendingUserInput(context.message.conversationRef) || {
+        questions: [],
+        elicitation: null,
+      };
+      await deps.send({
+        type: 'status_reply',
+        conversationRef: context.message.conversationRef,
+        text: waitingUserInputStatusMessage(pendingInput),
+      }, {
+        source: 'waiting_user_input',
+        thread_id: meta?.threadId || context.threadId,
+        turn_id: turnId,
+      });
+    },
+    onApproval: async (approval) => {
+      const existingApproval = deps.sessionStore.getApproval(context.message.conversationRef, approval.approvalId);
+      if (existingApproval && existingApproval.status !== 'pending') {
+        await deps.runtime.resolveApproval(
+          approval.requestId,
+          existingApproval.status === 'accepted' ? 'accept' : existingApproval.status === 'declined' ? 'decline' : 'cancel',
+        );
+        return;
+      }
+      if (!deps.isTurnStillCurrent(context.message.conversationRef, context.turnEntryMessageId, approval.turnId)
+        && !deps.isBlockingTurnStillRelevant(context.message.conversationRef, approval.threadId, approval.turnId)) {
+        deps.noteStaleTurnSuppressed(context.message.conversationRef, {
+          messageId: context.message.messageId,
+          threadId: approval.threadId,
+          turnId: approval.turnId,
+          stage: 'approval',
+          reason: 'session advanced before approval request reached the user',
+        });
+        await deps.runtime.resolveApproval(approval.requestId, 'cancel');
+        return;
+      }
+      deps.clearRuntimeRecovery(context.message.conversationRef);
+      logWarn('receiver', 'approval_requested', {
+        approvalId: approval.approvalId,
+        kind: approval.kind,
+        threadId: approval.threadId,
+        turnId: approval.turnId,
+      });
+      const latestSession = deps.sessionStore.getSession(context.message.conversationRef);
+      if (existingApproval?.status === 'pending' && latestSession?.pendingApprovalIds.includes(approval.approvalId)) {
+        return;
+      }
+      const record: ApprovalRecord = {
+        approvalId: approval.approvalId,
+        kind: approval.kind,
+        requestId: approval.requestId,
+        threadId: approval.threadId,
+        turnId: approval.turnId,
+        messageId: approval.messageId,
+        command: approval.command,
+        reason: approval.reason,
+        grantRoot: approval.grantRoot,
+        cwd: approval.cwd,
+        createdAt: new Date().toISOString(),
+        status: 'pending',
+        visible: false,
+      };
+      deps.sessionStore.recordApproval(context.message.conversationRef, record, { visible: false });
+      const autonomyDecision = deps.evaluateApprovalAutonomy(record);
+      if (autonomyDecision) {
+        await deps.runtime.resolveApproval(approval.requestId, autonomyDecision.action === 'accept' ? 'accept' : 'decline');
+        deps.sessionStore.resolveApproval(
+          context.message.conversationRef,
+          approval.approvalId,
+          autonomyDecision.action === 'accept' ? 'accepted' : 'declined',
+        );
+        return;
+      }
+      deps.scheduleApprovalNotice(
+        context.message.conversationRef,
+        approval.threadId,
+        approval.turnId,
+        context.state.waitingApprovalNoticeState,
+      );
+    },
+    onUserInput: async (request) => {
+      const currentPendingInput = deps.sessionStore.getPendingUserInput(context.message.conversationRef);
+      const latestSession = deps.sessionStore.getSession(context.message.conversationRef);
+      if (currentPendingInput?.requestId === request.requestId
+        && latestSession?.pendingUserInputRequestId === String(request.requestId)) {
+        return;
+      }
+      if (!deps.isTurnStillCurrent(context.message.conversationRef, context.turnEntryMessageId, request.turnId)
+        && !deps.isBlockingTurnStillRelevant(context.message.conversationRef, request.threadId, request.turnId)) {
+        deps.noteStaleTurnSuppressed(context.message.conversationRef, {
+          messageId: context.message.messageId,
+          threadId: request.threadId,
+          turnId: request.turnId,
+          stage: 'user_input',
+          reason: 'session advanced before user input request reached the user',
+        });
+        if (request.kind === 'mcp_elicitation') {
+          await deps.runtime.resolveElicitation(request.requestId, { action: 'cancel', content: null });
+        } else {
+          await deps.runtime.resolveUserInput(request.requestId, { answers: {} });
+        }
+        return;
+      }
+      deps.clearRuntimeRecovery(context.message.conversationRef);
+      const autoResolution = maybeAutoResolveRuntimeUserInput(request, deps.mcpToolApprovalRules);
+      if (autoResolution) {
+        logInfo('receiver', 'runtime_user_input_auto_resolved', {
+          conversationId: context.message.conversationRef.conversationId,
+          requestId: request.requestId,
+          kind: request.kind || 'questionnaire',
+          serverName: autoResolution.serverName,
+          toolName: autoResolution.toolName,
+          answerLabel: autoResolution.answerLabel,
+          matchedRule: autoResolution.matchedRule,
+        });
+        if (autoResolution.elicitationResponse) {
+          await deps.runtime.resolveElicitation(request.requestId, autoResolution.elicitationResponse);
+        } else if (autoResolution.answers) {
+          await deps.runtime.resolveUserInput(request.requestId, { answers: autoResolution.answers });
+        }
+        return;
+      }
+
+      const pending = deps.sessionStore.notePendingUserInput(
+        context.message.conversationRef,
+        request,
+        { visible: false },
+      );
+      const delivered = await deps.send({
+        type: 'user_input_requested',
+        conversationRef: context.message.conversationRef,
+        request: pending,
+        text: userInputMessage(pending),
+      }, {
+        source: 'user_input_requested',
+        thread_id: request.threadId,
+        turn_id: request.turnId,
+        request_id: request.requestId,
+      });
+      if (!delivered) {
+        return;
+      }
+      const visiblePending = deps.sessionStore.markPendingUserInputVisible(context.message.conversationRef, request.requestId) || pending;
+      if (context.state.isWaitingUserInputNoticeSent()) {
+        return;
+      }
+      context.state.markWaitingUserInputNoticeSent();
+      await deps.send({
+        type: 'status_reply',
+        conversationRef: context.message.conversationRef,
+        text: waitingUserInputStatusMessage(visiblePending),
+      }, {
+        source: 'waiting_user_input',
+        thread_id: request.threadId,
+        turn_id: request.turnId,
+        request_id: request.requestId,
+      });
+    },
+  };
+}

package/bridge/src/receiver-runtime-policy.ts

@@ -0,0 +1,132 @@
+import type { WorkAllyConfig } from './config.ts';
+import { isRuntimeFinalStateUnconfirmedError, isRuntimeInfrastructureError } from './receiver-recovery.ts';
+import { runtimeFinalStateRecoveryRequiredMessage, runtimeInfrastructureErrorMessage, systemNoticeMessage } from './translator.ts';
+import type { InboundMessage, RuntimeProgressMeta } from './types.ts';
+
+export function buildPromptBody(message: InboundMessage): string {
+  const current = message.text.trim();
+  const sourceMessageType = String(message.sourceMessageType || '').trim();
+  const replyToText = String(message.replyToText || '').trim();
+  const sourceContext = sourceMessageType === 'merge_forward'
+    ? [
+      'Inbound source: Feishu forwarded chat record (`merge_forward`).',
+      'Treat the following body as forwarded conversation content, not as plain user-authored single-message input.',
+      '',
+    ]
+    : [];
+
+  if (!replyToText) {
+    return [...sourceContext, current].join('\n');
+  }
+
+  return [
+    ...sourceContext,
+    'User is replying to a previous Feishu message.',
+    '',
+    `ReplyToMessageId: ${message.replyToMessageId || 'unknown'}`,
+    message.rootMessageId ? `RootMessageId: ${message.rootMessageId}` : null,
+    '',
+    'Replied message body:',
+    replyToText,
+    '',
+    'Current user message:',
+    current,
+  ].filter(Boolean).join('\n');
+}
+
+export function buildPrompt(message: InboundMessage): string {
+  const body = buildPromptBody(message);
+  if (message.conversationRef.chatType !== 'group') {
+    return body;
+  }
+
+  const senderName = String(message.senderName || '').trim();
+  const senderLabel = senderName || message.senderId;
+  return [
+    'Channel: Feishu',
+    'Chat type: group',
+    `Sender: ${senderLabel}`,
+    `Sender ID: ${message.senderId}`,
+    '',
+    'Message:',
+    body,
+  ].join('\n');
+}
+
+export function interactiveSandboxPolicy(config: WorkAllyConfig): unknown {
+  const mode = config.runtime.sandboxMode;
+  if (mode === 'danger-full-access') {
+    return { type: 'dangerFullAccess' as const };
+  }
+  if (mode === 'read-only') {
+    return {
+      type: 'readOnly' as const,
+      networkAccess: true,
+      access: {
+        type: 'restricted' as const,
+        includePlatformDefaults: true,
+        readableRoots: [config.workspaceRoot],
+      },
+    };
+  }
+  const writableRoots = [config.workspaceRoot];
+  const assistantHome = config.assistant?.assistantHome;
+  if (assistantHome && !writableRoots.includes(assistantHome)) {
+    writableRoots.push(assistantHome);
+  }
+  return {
+    type: 'workspaceWrite' as const,
+    networkAccess: true,
+    writableRoots,
+    readOnlyAccess: {
+      type: 'restricted' as const,
+      includePlatformDefaults: true,
+      readableRoots: writableRoots,
+    },
+  };
+}
+
+export function heartbeatMs(config: WorkAllyConfig): number {
+  const seconds = Number(config.progressHeartbeatSeconds || 0);
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    return 0;
+  }
+  return Math.max(1, Math.round(seconds * 1000));
+}
+
+export function shouldForwardProgressUpdate(text: string, meta?: RuntimeProgressMeta): boolean {
+  const normalized = String(text || '').trim();
+  if (!meta?.kind) {
+    return !['正在处理...', '正在处理，请稍候。', '正在思考中，请稍候…'].includes(normalized);
+  }
+  if (meta.kind !== 'agent_message') {
+    return false;
+  }
+  return meta.phase !== 'final_answer';
+}
+
+export function isMissingThreadError(error: unknown): boolean {
+  const code = (error && typeof error === 'object' && 'code' in error) ? String((error as { code?: unknown }).code) : '';
+  const message = error instanceof Error
+    ? error.message
+    : (error && typeof error === 'object' && 'message' in error ? String((error as { message?: unknown }).message || '') : String(error || ''));
+  return code === '-32600' && /thread not found|no rollout found for thread id/i.test(message);
+}
+
+export function isStaleTurnError(error: unknown): boolean {
+  const message = error instanceof Error
+    ? error.message
+    : (error && typeof error === 'object' && 'message' in error ? String((error as { message?: unknown }).message || '') : String(error || ''));
+  return /turn not active|turn not found|unknown turn|turn interrupted/i.test(message);
+}
+
+export function normalizeErrorReplyText(text: string): string {
+  const resolved = String(text || '').trim() || '处理失败。';
+  if (isRuntimeFinalStateUnconfirmedError(resolved)) {
+    return systemNoticeMessage(runtimeFinalStateRecoveryRequiredMessage());
+  }
+  if (isRuntimeInfrastructureError(resolved)) {
+    return systemNoticeMessage(runtimeInfrastructureErrorMessage());
+  }
+  return resolved;
+}

package/bridge/src/receiver-runtime-state.ts

@@ -0,0 +1,124 @@
+import { logWarn } from './logger.ts';
+import { connectionLifecycleMessage, systemNoticeMessage } from './translator.ts';
+import type { OutboundEnvelope } from './channel-types.ts';
+import type { SessionStore } from './session-store.ts';
+import type { ConnectionLifecycleEvent, ConversationRef, RuntimeThreadStatus, ServerRequestResolvedEvent, SessionMeta } from './types.ts';
+
+interface RuntimeRecoveryRegistry {
+  isActive(conversationRef: ConversationRef): boolean;
+  mark(conversationRef: ConversationRef): void;
+  clear(conversationRef: ConversationRef): void;
+}
+
+interface RuntimeThreadStatusReader {
+  readThreadStatus(threadId: string): Promise<RuntimeThreadStatus | null>;
+}
+
+interface ConnectionLifecycleDeps {
+  sessionStore: Pick<SessionStore, 'listSessions' | 'hasActiveTurn' | 'resolveSessionKey'>;
+  runtimeRecovery: RuntimeRecoveryRegistry;
+  send: (outbound: OutboundEnvelope, extra?: Record<string, unknown>) => Promise<boolean>;
+}
+
+interface ServerRequestResolvedDeps {
+  sessionStore: Pick<SessionStore, 'findApprovalByRequestId' | 'resolveApproval' | 'findPendingUserInputByRequestId' | 'clearPendingUserInput'>;
+}
+
+function latestFeishuConversationRef(sessions: SessionMeta[]): ConversationRef | null {
+  const prioritized = sessions
+    .filter((session) => session.conversationRef.channel === 'feishu')
+    .sort((left, right) => {
+      const activeDelta = Number(Boolean(right.activeTurnId)) - Number(Boolean(left.activeTurnId));
+      if (activeDelta !== 0) {
+        return activeDelta;
+      }
+      return String(right.updatedAt).localeCompare(String(left.updatedAt));
+    });
+  return prioritized[0]?.conversationRef || null;
+}
+
+export function createRuntimeRecoveryRegistry(
+  sessionStore: Pick<SessionStore, 'resolveSessionKey'>,
+): RuntimeRecoveryRegistry {
+  const activeSessionKeys = new Set<string>();
+  const sessionKeyFor = (conversationRef: ConversationRef): string => sessionStore.resolveSessionKey(conversationRef);
+  return {
+    isActive: (conversationRef) => activeSessionKeys.has(sessionKeyFor(conversationRef)),
+    mark: (conversationRef) => {
+      activeSessionKeys.add(sessionKeyFor(conversationRef));
+    },
+    clear: (conversationRef) => {
+      activeSessionKeys.delete(sessionKeyFor(conversationRef));
+    },
+  };
+}
+
+export async function readCurrentRuntimeThreadStatus(
+  deps: { runtime: RuntimeThreadStatusReader },
+  session: { threadId: string | null },
+): Promise<RuntimeThreadStatus | null> {
+  if (!session.threadId) {
+    return null;
+  }
+  try {
+    return await deps.runtime.readThreadStatus(session.threadId);
+  } catch (error) {
+    logWarn('receiver', 'runtime_thread_status_read_failed', {
+      threadId: session.threadId,
+      error: error instanceof Error ? (error.stack || error.message) : String(error),
+    });
+    return null;
+  }
+}
+
+export async function handleConnectionLifecycleEvent(
+  deps: ConnectionLifecycleDeps,
+  event: ConnectionLifecycleEvent,
+): Promise<void> {
+  const conversationRef = latestFeishuConversationRef(deps.sessionStore.listSessions());
+  if (!conversationRef) {
+    return;
+  }
+
+  const hasActiveTurn = event.hasActiveTurn ?? deps.sessionStore.hasActiveTurn(conversationRef);
+  const activeRuntimeRecovery = event.source === 'runtime' && hasActiveTurn;
+  if (activeRuntimeRecovery) {
+    deps.runtimeRecovery.mark(conversationRef);
+  } else if (event.source === 'runtime' && event.state === 'reconnected') {
+    deps.runtimeRecovery.clear(conversationRef);
+  }
+
+  const suppressed = activeRuntimeRecovery && event.state === 'reconnecting';
+
+  if (event.source === 'runtime' || suppressed) {
+    return;
+  }
+
+  const text = systemNoticeMessage(connectionLifecycleMessage(event, { hasActiveTurn }));
+  await deps.send({
+    type: 'progress_update',
+    conversationRef,
+    text,
+  }, {
+    source: 'connection_lifecycle',
+    connection_source: event.source,
+    connection_state: event.state,
+    runtime_recovery_active: activeRuntimeRecovery,
+    has_active_turn: hasActiveTurn,
+  });
+}
+
+export function handleServerRequestResolvedEvent(
+  deps: ServerRequestResolvedDeps,
+  event: ServerRequestResolvedEvent,
+): void {
+  const approvalMatch = deps.sessionStore.findApprovalByRequestId(event.requestId);
+  if (approvalMatch && approvalMatch.approval.status === 'pending') {
+    deps.sessionStore.resolveApproval(approvalMatch.meta.conversationRef, approvalMatch.approval.approvalId, 'cancelled');
+  }
+
+  const userInputMatch = deps.sessionStore.findPendingUserInputByRequestId(event.requestId);
+  if (userInputMatch && userInputMatch.request.status === 'pending') {
+    deps.sessionStore.clearPendingUserInput(userInputMatch.meta.conversationRef, { requestId: event.requestId });
+  }
+}