work-ally 0.2.0-alpha.1

package/bridge/src/receiver-support-actions.ts

@@ -0,0 +1,189 @@
+import type { CommandApprovalRuleset } from './approval-rules.ts';
+import { APPROVAL_BATCH_WINDOW_MS, TURN_RECOVERY_VISIBILITY_DELAY_MS, errorDetailsFromUnknown } from './receiver-helpers.ts';
+import { markFinalReplyDelivered, recordPendingFinalReplyDelivery, redeliverPendingFinalReplies, redeliverPendingTurnResult } from './receiver-delivery.ts';
+import { flushApprovalNotice, maybeHandleWaitingApprovalShortcut, maybeResumePendingUserInput } from './receiver-human-gate.ts';
+import { isRuntimeInfrastructureError, sendRuntimeRecoveryNotice, tryRecoverTurnResult } from './receiver-recovery.ts';
+import { approvalBoundaryReason, evaluateApprovalAutonomy } from './receiver-approval-autonomy.ts';
+import { normalizeErrorReplyText } from './receiver-runtime-policy.ts';
+import { handleConnectionLifecycleEvent, handleServerRequestResolvedEvent } from './receiver-runtime-state.ts';
+import { logWarn } from './logger.ts';
+import type { WorkAllyConfig } from './config.ts';
+import type { SessionStore } from './session-store.ts';
+import type { ConnectionLifecycleEvent, ConversationRef, InboundMessage, RuntimeProgressMeta, RuntimeThreadStatus, RuntimeTurnResult, ServerRequestResolvedEvent, UserInputRequest } from './types.ts';
+
+interface SendLike {
+  (outbound: any, 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>;
+  recoverTurnResult?(threadId: string, turnId: string, options?: { timeoutMs?: number; pollMs?: number }): Promise<RuntimeTurnResult | null>;
+}
+
+interface RuntimeRecoveryRegistry {
+  clear(conversationRef: ConversationRef): void;
+  mark(conversationRef: ConversationRef): void;
+  isActive(conversationRef: ConversationRef): boolean;
+}
+
+interface ReceiverSupportActionDeps {
+  config: WorkAllyConfig;
+  sessionStore: SessionStore;
+  runtime: RuntimeResolutionLike;
+  runtimeRecovery: RuntimeRecoveryRegistry;
+  approvalNoticeTimers: Map<string, NodeJS.Timeout>;
+  commandApprovalRules: CommandApprovalRuleset;
+  send: SendLike;
+}
+
+export function createReceiverSupportActions(deps: ReceiverSupportActionDeps) {
+  const approvalAutonomyDeps = () => ({
+    workspaceRoot: deps.config.workspaceRoot,
+    assistantHome: deps.config.assistant?.assistantHome || deps.config.paths.assistantHome || null,
+    commandApprovalRules: deps.commandApprovalRules,
+  });
+
+  const recoveryAttemptVisibilityDelayMs = (): number => {
+    const raw = Number(process.env.WORK_ALLY_TURN_RECOVERY_VISIBILITY_DELAY_MS || String(TURN_RECOVERY_VISIBILITY_DELAY_MS));
+    return Number.isFinite(raw) ? Math.max(0, raw) : TURN_RECOVERY_VISIBILITY_DELAY_MS;
+  };
+
+  const flushScheduledApprovalNotice = async (
+    conversationRef: InboundMessage['conversationRef'],
+    threadId: string,
+    turnId: string,
+    noticeState: { sent: boolean },
+  ): Promise<void> => flushApprovalNotice({
+    sessionStore: deps.sessionStore,
+    send: deps.send,
+    approvalBoundaryReason: (approval) => approvalBoundaryReason(approvalAutonomyDeps(), approval),
+  }, conversationRef, threadId, turnId, noticeState);
+
+  return {
+    handleConnectionLifecycle: async (event: ConnectionLifecycleEvent): Promise<void> => {
+      await handleConnectionLifecycleEvent({
+        sessionStore: deps.sessionStore,
+        runtimeRecovery: deps.runtimeRecovery,
+        send: deps.send,
+      }, event);
+    },
+
+    handleServerRequestResolved: (event: ServerRequestResolvedEvent): void => {
+      handleServerRequestResolvedEvent({
+        sessionStore: deps.sessionStore,
+      }, event);
+    },
+
+    sendRuntimeRecoveryNotice: async (
+      conversationRef: InboundMessage['conversationRef'],
+      threadId: string,
+      turnId: string | null,
+      errorText: string,
+      recoveryKind: 'infrastructure' | 'final_state_unconfirmed',
+    ): Promise<void> => sendRuntimeRecoveryNotice({
+      clearRuntimeRecovery: (ref) => deps.runtimeRecovery.clear(ref),
+      send: deps.send,
+    }, conversationRef, threadId, turnId, errorText, recoveryKind),
+
+    recordPendingFinalReplyDelivery: (
+      conversationRef: InboundMessage['conversationRef'],
+      threadId: string,
+      turnId: string,
+      text: string,
+    ): string => recordPendingFinalReplyDelivery({
+      sessionStore: deps.sessionStore,
+    }, conversationRef, threadId, turnId, text),
+
+    markFinalReplyDelivered: (conversationRef: InboundMessage['conversationRef'], threadId: string, turnId: string): void => {
+      markFinalReplyDelivered({
+        sessionStore: deps.sessionStore,
+      }, conversationRef, threadId, turnId);
+    },
+
+    redeliverPendingFinalReplies: async (conversationRef: InboundMessage['conversationRef']): Promise<number> => redeliverPendingFinalReplies({
+      sessionStore: deps.sessionStore,
+      send: deps.send,
+    }, conversationRef),
+
+    redeliverPendingTurnResult: async (
+      conversationRef: InboundMessage['conversationRef'],
+      ledgerTurnId: string,
+    ): Promise<boolean> => redeliverPendingTurnResult({
+      sessionStore: deps.sessionStore,
+      send: deps.send,
+      isRuntimeInfrastructureError: (text) => isRuntimeInfrastructureError(text),
+      normalizeErrorReplyText: (text) => normalizeErrorReplyText(text),
+    }, conversationRef, ledgerTurnId),
+
+    tryRecoverTurnResult: async (
+      conversationRef: InboundMessage['conversationRef'],
+      threadId: string,
+      turnId: string | null,
+      messageId: string,
+      errorText: string,
+      startedAt: string | null,
+      callbacks: {
+        isTurnStillCurrent(conversationRef: ConversationRef, messageId: string, turnId: string | null): boolean;
+        markTurnSuppressed(conversationRef: ConversationRef, turnId: string | null, threadId: string | null, reason: string): void;
+      },
+    ): Promise<RuntimeTurnResult | null> => tryRecoverTurnResult({
+      runtime: deps.runtime,
+      clearRuntimeRecovery: (ref) => deps.runtimeRecovery.clear(ref),
+      markRuntimeRecovery: (ref) => deps.runtimeRecovery.mark(ref),
+      isTurnStillCurrent: callbacks.isTurnStillCurrent,
+      markTurnSuppressed: callbacks.markTurnSuppressed,
+      visibilityDelayMs: recoveryAttemptVisibilityDelayMs(),
+    }, conversationRef, threadId, turnId, messageId, errorText, startedAt),
+
+    scheduleApprovalNotice: (
+      conversationRef: InboundMessage['conversationRef'],
+      threadId: string,
+      turnId: string,
+      noticeState: { sent: boolean },
+    ): void => {
+      const sessionKey = deps.sessionStore.resolveSessionKey(conversationRef);
+      const existing = deps.approvalNoticeTimers.get(sessionKey);
+      if (existing) {
+        clearTimeout(existing);
+      }
+      const timer = setTimeout(() => {
+        deps.approvalNoticeTimers.delete(sessionKey);
+        void flushScheduledApprovalNotice(conversationRef, threadId, turnId, noticeState).catch((error) => {
+          logWarn('receiver', 'approval_notice_flush_failed', {
+            conversationId: conversationRef.conversationId,
+            threadId,
+            turnId,
+            error: errorDetailsFromUnknown(error),
+          });
+        });
+      }, APPROVAL_BATCH_WINDOW_MS);
+      timer.unref?.();
+      deps.approvalNoticeTimers.set(sessionKey, timer);
+    },
+
+    maybeHandleWaitingApprovalShortcut: async (
+      message: InboundMessage,
+      session: any,
+    ): Promise<boolean> => maybeHandleWaitingApprovalShortcut({
+      sessionStore: deps.sessionStore,
+      runtime: deps.runtime,
+      send: deps.send,
+      reactEmoji: deps.config.feishu.reactEmoji,
+    }, message, session),
+
+    maybeResumePendingUserInput: async (message: InboundMessage): Promise<boolean> => maybeResumePendingUserInput({
+      sessionStore: deps.sessionStore,
+      runtime: deps.runtime,
+      send: deps.send,
+      reactEmoji: deps.config.feishu.reactEmoji,
+    }, message),
+
+    approvalBoundaryReason: (approval: any) => approvalBoundaryReason(approvalAutonomyDeps(), approval),
+    evaluateApprovalAutonomy: (approval: any) => evaluateApprovalAutonomy(approvalAutonomyDeps(), approval),
+  };
+}

package/bridge/src/receiver-thread-start.ts

@@ -0,0 +1,57 @@
+import { logInfo } from './logger.ts';
+import type { OutboundEnvelope } from './channel-types.ts';
+import type { WorkAllyConfig } from './config.ts';
+import type { SessionStore } from './session-store.ts';
+import type { ConversationRef, InboundMessage } from './types.ts';
+
+interface StartRuntimeLike {
+  startThread(cwd: string): Promise<{ id: string }>;
+  resumeThread(threadId: string, cwd: string): Promise<{ id: string }>;
+}
+
+interface SendLike {
+  (
+    outbound: OutboundEnvelope,
+    extra?: Record<string, unknown>,
+    delivery?: { trackTurnId?: string | null },
+  ): Promise<boolean>;
+}
+
+interface PrepareInboundThreadStartDeps {
+  config: Pick<WorkAllyConfig, 'workspaceRoot' | 'feishu'>;
+  runtime: StartRuntimeLike;
+  sessionStore: SessionStore;
+  send: SendLike;
+  clearRuntimeRecovery(conversationRef: ConversationRef): void;
+}
+
+export async function prepareInboundThreadStart(
+  deps: PrepareInboundThreadStartDeps,
+  message: InboundMessage,
+): Promise<{ id: string }> {
+  deps.clearRuntimeRecovery(message.conversationRef);
+  await deps.send({
+    type: 'ack_received',
+    conversationRef: message.conversationRef,
+    messageId: message.messageId,
+    emoji: deps.config.feishu.reactEmoji,
+  });
+  logInfo('receiver', 'ack_sent', {
+    messageId: message.messageId,
+    conversationId: message.conversationRef.conversationId,
+  });
+
+  const effectiveSessionForStart = deps.sessionStore.ensureSession(message.conversationRef);
+  const thread = effectiveSessionForStart.threadId
+    ? await deps.runtime.resumeThread(effectiveSessionForStart.threadId, deps.config.workspaceRoot)
+    : await deps.runtime.startThread(deps.config.workspaceRoot);
+
+  logInfo('receiver', 'thread_ready', {
+    messageId: message.messageId,
+    conversationId: message.conversationRef.conversationId,
+    threadId: thread.id,
+    resumed: Boolean(effectiveSessionForStart.threadId),
+  });
+  deps.sessionStore.bindThread(message.conversationRef, thread.id);
+  return thread;
+}

package/bridge/src/receiver-turn-coordination.ts

@@ -0,0 +1,94 @@
+import { noteStaleTurnSuppressed as recordStaleTurnSuppressed, type StaleTurnSuppressedDetails } from './receiver-recovery.ts';
+import type { SessionStore } from './session-store.ts';
+import type { ConversationRef } from './types.ts';
+
+interface TurnCoordinationDeps {
+  sessionStore: SessionStore;
+}
+
+function currentSessionAdvance(
+  sessionStore: SessionStore,
+  conversationRef: ConversationRef,
+): { messageId: string | null; turnId: string | null } {
+  const latest = sessionStore.getSession(conversationRef);
+  return {
+    messageId: latest?.lastMessageId || null,
+    turnId: latest?.activeTurnId || null,
+  };
+}
+
+export function markTurnSuppressed(
+  sessionStore: SessionStore,
+  conversationRef: ConversationRef,
+  turnId: string | null,
+  threadId: string | null,
+  reason: string,
+): void {
+  if (!turnId) {
+    return;
+  }
+  const latest = currentSessionAdvance(sessionStore, conversationRef);
+  sessionStore.markTurnSuppressed(conversationRef, turnId, {
+    threadId,
+    suppressedByMessageId: latest.messageId,
+    suppressedByTurnId: latest.turnId,
+    reason,
+  });
+}
+
+export function isMessageStillLatest(
+  sessionStore: SessionStore,
+  conversationRef: ConversationRef,
+  messageId: string,
+): boolean {
+  const latest = sessionStore.getSession(conversationRef);
+  if (!latest) {
+    return false;
+  }
+  return latest.lastMessageId === messageId;
+}
+
+export function isTurnStillCurrent(
+  sessionStore: SessionStore,
+  conversationRef: ConversationRef,
+  _messageId: string,
+  turnId: string | null,
+): boolean {
+  if (!turnId) {
+    return false;
+  }
+  const latest = sessionStore.getSession(conversationRef);
+  if (!latest) {
+    return false;
+  }
+  return latest.activeTurnId === turnId;
+}
+
+export function isBlockingTurnStillRelevant(
+  sessionStore: SessionStore,
+  conversationRef: ConversationRef,
+  threadId: string | null,
+  turnId: string | null,
+): boolean {
+  if (!threadId || !turnId) {
+    return false;
+  }
+  const latest = sessionStore.getSession(conversationRef);
+  if (!latest) {
+    return false;
+  }
+  if (latest.threadId != threadId || latest.activeTurnId != turnId) {
+    return false;
+  }
+  return latest.pendingApprovalIds.length > 0 || Boolean(latest.pendingUserInputRequestId);
+}
+
+export function noteStaleTurnSuppressed(
+  deps: TurnCoordinationDeps,
+  conversationRef: ConversationRef,
+  details: StaleTurnSuppressedDetails,
+): void {
+  recordStaleTurnSuppressed({
+    markTurnSuppressed: (ref, turnId, threadId, reason) => markTurnSuppressed(deps.sessionStore, ref, turnId, threadId, reason),
+  }, conversationRef, details);
+}

package/bridge/src/receiver-turn-execution.ts

@@ -0,0 +1,257 @@
+import { logError } from './logger.ts';
+import { createInboundRuntimeCallbacks } from './receiver-runtime-callbacks.ts';
+import { errorDetailsFromUnknown } from './receiver-helpers.ts';
+import { finalizeTurnResult } from './receiver-turn-result.ts';
+import { isRuntimeInfrastructureError } from './receiver-recovery.ts';
+import { buildPrompt, heartbeatMs, interactiveSandboxPolicy, normalizeErrorReplyText, shouldForwardProgressUpdate } from './receiver-runtime-policy.ts';
+import { handleFailedTurnExecution } from './receiver-turn-failure.ts';
+import { heartbeatMessage, workingNoticeMessage } from './translator.ts';
+import { isBlockingTurnStillRelevant, isTurnStillCurrent, markTurnSuppressed, noteStaleTurnSuppressed } from './receiver-turn-coordination.ts';
+import type { WorkAllyConfig } from './config.ts';
+import type { SessionStore } from './session-store.ts';
+import type { ConversationRef, InboundMessage, RuntimeProgressMeta, RuntimeThreadStatus, RuntimeTurnResult, SessionMeta, UserInputRequest } from './types.ts';
+
+interface SendLike {
+  (
+    outbound: {
+      type: 'progress_update' | 'error_reply' | 'status_reply' | 'final_reply';
+      conversationRef: ConversationRef;
+      text: string;
+    },
+    extra?: Record<string, unknown>,
+    delivery?: { trackTurnId?: string | null },
+  ): Promise<boolean>;
+}
+
+interface RuntimeLike {
+  runTurn(options: {
+    threadId: string;
+    prompt: string;
+    messageId: string;
+    cwd: string;
+    onTurnStarted?: (turnId: string) => Promise<void> | void;
+    onProgress?: (text: string, meta?: RuntimeProgressMeta) => Promise<void> | void;
+    onThreadStatus?: (status: RuntimeThreadStatus, meta?: { threadId?: string | null; turnId?: string | null }) => Promise<void> | void;
+    onApproval?: (approval: any) => Promise<void> | void;
+    onUserInput?: (request: UserInputRequest) => Promise<void> | void;
+    approvalPolicy?: 'untrusted' | 'on-failure' | 'on-request' | 'never';
+    sandboxPolicy?: unknown;
+  }): Promise<RuntimeTurnResult>;
+  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 RuntimeRecoveryRegistry {
+  clear(conversationRef: ConversationRef): void;
+  isActive(conversationRef: ConversationRef): boolean;
+}
+
+interface SupportLike {
+  evaluateApprovalAutonomy(approval: any): {
+    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;
+  tryRecoverTurnResult(
+    conversationRef: ConversationRef,
+    threadId: string,
+    turnId: string | null,
+    messageId: string,
+    errorText: string,
+    startedAt: string | null,
+    callbacks: {
+      isTurnStillCurrent(conversationRef: ConversationRef, messageId: string, turnId: string | null): boolean;
+      markTurnSuppressed(conversationRef: ConversationRef, turnId: string | null, threadId: string | null, reason: string): void;
+    },
+  ): Promise<RuntimeTurnResult | null>;
+  sendRuntimeRecoveryNotice(
+    conversationRef: ConversationRef,
+    threadId: string,
+    turnId: string | null,
+    errorText: string,
+    recoveryKind: 'infrastructure' | 'final_state_unconfirmed',
+  ): Promise<void>;
+  recordPendingFinalReplyDelivery(conversationRef: ConversationRef, threadId: string, turnId: string, text: string): string;
+  markFinalReplyDelivered(conversationRef: ConversationRef, threadId: string, turnId: string): void;
+}
+
+interface ExecuteInboundTurnDeps {
+  config: WorkAllyConfig;
+  sessionStore: SessionStore;
+  runtime: RuntimeLike;
+  runtimeRecovery: RuntimeRecoveryRegistry;
+  support: SupportLike;
+  send: SendLike;
+  userRequestedStopTurnIds: Set<string>;
+  suppressedInterruptedTurnIds: Set<string>;
+}
+
+interface ExecuteInboundTurnArgs {
+  message: InboundMessage;
+  fallbackSession: SessionMeta;
+  threadId: string;
+}
+
+export async function executeInboundTurn(
+  deps: ExecuteInboundTurnDeps,
+  args: ExecuteInboundTurnArgs,
+): Promise<boolean> {
+  const { message, fallbackSession, threadId } = args;
+  const startedAt = new Date().toISOString();
+  const heartbeatMsValue = heartbeatMs(deps.config);
+  let currentTurnId: string | null = null;
+  let lastProgressAt = Date.now();
+  let finished = false;
+  const heartbeat = heartbeatMsValue > 0
+    ? setInterval(() => {
+      if (finished || deps.runtimeRecovery.isActive(message.conversationRef)) {
+        return;
+      }
+      const latestSession = deps.sessionStore.getSession(message.conversationRef) || fallbackSession;
+      if (currentTurnId && !isTurnStillCurrent(deps.sessionStore, message.conversationRef, message.messageId, currentTurnId)) {
+        return;
+      }
+      if (latestSession.pendingApprovalIds.length > 0 || latestSession.pendingUserInputRequestId) {
+        return;
+      }
+      const now = Date.now();
+      if (now - lastProgressAt < heartbeatMsValue || !currentTurnId || !deps.runtimeRecovery.isActive(message.conversationRef)) {
+        return;
+      }
+      lastProgressAt = now;
+      deps.send({
+        type: 'progress_update',
+        conversationRef: message.conversationRef,
+        text: workingNoticeMessage(heartbeatMessage(latestSession)),
+      }, {
+        source: 'heartbeat',
+        thread_id: latestSession.threadId,
+        turn_id: latestSession.activeTurnId,
+      }).catch(() => undefined);
+    }, Math.min(heartbeatMsValue, 5000))
+    : null;
+
+  let result: RuntimeTurnResult | null = null;
+  const waitingApprovalNoticeState = { sent: false };
+  let waitingUserInputNoticeSent = false;
+  const contextCompactionNoticeKeys = new Set<string>();
+  const turnEntryMessageId = message.messageId;
+
+  try {
+    result = await deps.runtime.runTurn({
+      threadId,
+      prompt: buildPrompt(message),
+      messageId: message.messageId,
+      cwd: deps.config.workspaceRoot,
+      approvalPolicy: deps.config.runtime.approvalPolicy,
+      sandboxPolicy: interactiveSandboxPolicy(deps.config),
+      ...createInboundRuntimeCallbacks({
+        sessionStore: deps.sessionStore,
+        runtime: deps.runtime,
+        send: deps.send,
+        mcpToolApprovalRules: deps.config.runtime.mcpToolApprovalRules,
+        clearRuntimeRecovery: (ref) => deps.runtimeRecovery.clear(ref),
+        isTurnStillCurrent: (ref, currentMessageId, turnId) => isTurnStillCurrent(deps.sessionStore, ref, currentMessageId, turnId),
+        isBlockingTurnStillRelevant: (ref, currentThreadId, turnId) => isBlockingTurnStillRelevant(deps.sessionStore, ref, currentThreadId, turnId),
+        noteStaleTurnSuppressed: (ref, details) => noteStaleTurnSuppressed({ sessionStore: deps.sessionStore }, ref, details),
+        shouldForwardProgressUpdate: (text, meta) => shouldForwardProgressUpdate(text, meta),
+        evaluateApprovalAutonomy: (approval) => deps.support.evaluateApprovalAutonomy(approval),
+        scheduleApprovalNotice: (ref, currentThreadId, turnId, noticeState) => deps.support.scheduleApprovalNotice(ref, currentThreadId, turnId, noticeState),
+      }, {
+        message,
+        threadId,
+        turnEntryMessageId,
+        fallbackSession,
+        state: {
+          getCurrentTurnId: () => currentTurnId,
+          setCurrentTurnId: (turnId) => {
+            currentTurnId = turnId;
+          },
+          setLastProgressAt: (timestamp) => {
+            lastProgressAt = timestamp;
+          },
+          waitingApprovalNoticeState,
+          isWaitingUserInputNoticeSent: () => waitingUserInputNoticeSent,
+          markWaitingUserInputNoticeSent: () => {
+            waitingUserInputNoticeSent = true;
+          },
+          contextCompactionNoticeKeys,
+        },
+      }),
+    });
+  } catch (error) {
+    finished = true;
+    logError('receiver', 'turn_failed', {
+      messageId: message.messageId,
+      conversationId: message.conversationRef.conversationId,
+      threadId,
+      turnId: currentTurnId,
+      error: errorDetailsFromUnknown(error),
+    });
+    if (heartbeat) {
+      clearInterval(heartbeat);
+    }
+    result = await handleFailedTurnExecution({
+      sessionStore: deps.sessionStore,
+      runtimeRecovery: deps.runtimeRecovery,
+      support: deps.support,
+      send: deps.send,
+    }, {
+      message,
+      threadId,
+      currentTurnId,
+      turnEntryMessageId,
+      startedAt,
+      error,
+    });
+    if (!result) {
+      return true;
+    }
+  } finally {
+    finished = true;
+    if (heartbeat) {
+      clearInterval(heartbeat);
+    }
+  }
+
+  if (!result) {
+    return false;
+  }
+
+  return finalizeTurnResult({
+    sessionStore: deps.sessionStore,
+    send: deps.send,
+    clearRuntimeRecovery: (ref) => deps.runtimeRecovery.clear(ref),
+    isTurnStillCurrent: (ref, currentMessageId, turnId) => isTurnStillCurrent(deps.sessionStore, ref, currentMessageId, turnId),
+    noteStaleTurnSuppressed: (ref, details) => noteStaleTurnSuppressed({ sessionStore: deps.sessionStore }, ref, details),
+    markTurnSuppressed: (ref, turnId, currentThreadId, reason) => markTurnSuppressed(deps.sessionStore, ref, turnId, currentThreadId, reason),
+    recordPendingFinalReplyDelivery: (ref, currentThreadId, turnId, text) => deps.support.recordPendingFinalReplyDelivery(ref, currentThreadId, turnId, text),
+    markFinalReplyDelivered: (ref, currentThreadId, turnId) => deps.support.markFinalReplyDelivered(ref, currentThreadId, turnId),
+    isRuntimeInfrastructureError: (text) => isRuntimeInfrastructureError(text),
+    normalizeErrorReplyText: (text) => normalizeErrorReplyText(text),
+    consumeUserRequestedStop: (turnId) => deps.userRequestedStopTurnIds.delete(turnId),
+    hasSuppressedInterruptedTurn: (turnId) => deps.suppressedInterruptedTurnIds.has(turnId),
+    clearSuppressedInterruptedTurn: (turnId) => {
+      deps.suppressedInterruptedTurnIds.delete(turnId);
+    },
+  }, {
+    conversationRef: message.conversationRef,
+    messageId: message.messageId,
+    prompt: message.text,
+    startedAt,
+    result,
+  });
+}