work-ally 0.2.0-alpha.1

package/bridge/src/receiver-inbound-preflight.ts

@@ -0,0 +1,162 @@
+import type { OutboundEnvelope } from './channel-types.ts';
+import { logInfo, logWarn } from './logger.ts';
+import type { SessionStore } from './session-store.ts';
+import type { WaitingState } from './receiver-human-gate.ts';
+import { pendingDeliveryIssueMessage, systemNoticeMessage, waitingUserInputFollowUpMessage } from './translator.ts';
+import type { InboundMessage, RuntimeThreadStatus, SessionMeta } from './types.ts';
+
+interface SendLike {
+  (
+    outbound: OutboundEnvelope,
+    extra?: Record<string, unknown>,
+    delivery?: { trackTurnId?: string | null },
+  ): Promise<boolean>;
+}
+
+interface InboundPreflightDeps {
+  sessionStore: SessionStore;
+  send: SendLike;
+  maybeResumePendingUserInput(message: InboundMessage): Promise<boolean>;
+  replayHiddenPendingApproval(conversationRef: InboundMessage['conversationRef'], threadId: string, turnId: string): Promise<boolean>;
+  replayHiddenPendingUserInput(conversationRef: InboundMessage['conversationRef'], threadId: string, turnId: string): Promise<boolean>;
+  redeliverPendingTurnResult(conversationRef: InboundMessage['conversationRef'], turnId: string): Promise<boolean>;
+  currentRuntimeThreadStatus(session: { threadId: string | null }): Promise<RuntimeThreadStatus | null>;
+  waitingStateFor(session: SessionMeta): WaitingState;
+  runtimeWaitingStateFor(status: RuntimeThreadStatus | null | undefined): WaitingState;
+  runtimeRecoveryKindFor(text: string): unknown;
+  maybeHandleWaitingApprovalShortcut(message: InboundMessage, session: SessionMeta): Promise<boolean>;
+  isActiveTurnStale(runtimeStatus: RuntimeThreadStatus | null): boolean;
+  clearRuntimeRecovery(ref: InboundMessage['conversationRef']): void;
+  steerActiveTurn(
+    message: InboundMessage,
+    session: SessionMeta,
+    runtimeWaitingState: WaitingState,
+  ): Promise<'handled' | 'retry_start' | null>;
+}
+
+export type InboundPreflightResult =
+  | { kind: 'handled' }
+  | { kind: 'continue'; session: SessionMeta };
+
+export async function handleInboundPreflight(
+  deps: InboundPreflightDeps,
+  message: InboundMessage,
+): Promise<InboundPreflightResult> {
+  if (!message.text.trim()) {
+    logWarn('receiver', 'inbound_empty_text', {
+      messageId: message.messageId,
+      conversationId: message.conversationRef.conversationId,
+    });
+    await deps.send({
+      type: 'status_reply',
+      conversationRef: message.conversationRef,
+      text: '收到一条结构化消息，但当前无法稳定提取正文。请改发纯文本，或直接粘贴链接/文档地址。',
+    });
+    return { kind: 'handled' };
+  }
+
+  if (await deps.maybeResumePendingUserInput(message)) {
+    return { kind: 'handled' };
+  }
+
+  const latestSession = deps.sessionStore.getSession(message.conversationRef);
+  const latestDeliveryIssue = deps.sessionStore.findLatestDeliveryIssue(message.conversationRef);
+  if (
+    latestDeliveryIssue
+    && latestDeliveryIssue.messageId
+    && latestDeliveryIssue.messageId !== message.messageId
+    && latestSession?.lastMessageId === latestDeliveryIssue.messageId
+  ) {
+    const redelivered = await deps.redeliverPendingTurnResult(message.conversationRef, latestDeliveryIssue.turnId);
+    if (!redelivered) {
+      await deps.send({
+        type: 'status_reply',
+        conversationRef: message.conversationRef,
+        text: systemNoticeMessage(pendingDeliveryIssueMessage()),
+      }, {
+        source: 'pending_delivery_issue_notice',
+        thread_id: latestDeliveryIssue.threadId,
+        turn_id: latestDeliveryIssue.turnId,
+        failed_message_id: latestDeliveryIssue.messageId,
+      });
+    }
+  }
+
+  const session = deps.sessionStore.ensureSession(message.conversationRef);
+  const runtimeStatus = await deps.currentRuntimeThreadStatus(session);
+  const waitingState = deps.waitingStateFor(session);
+  const runtimeWaitingState = waitingState ? null : deps.runtimeWaitingStateFor(runtimeStatus);
+  if (!session.activeTurnId && session.lastTurnId) {
+    const previousTurn = deps.sessionStore.getTurnLedger(message.conversationRef, session.lastTurnId);
+    if (previousTurn && previousTurn.executionStatus === 'failed' && deps.runtimeRecoveryKindFor(previousTurn.error || '')) {
+      deps.sessionStore.markTurnSuppressed(message.conversationRef, session.lastTurnId, {
+        threadId: previousTurn.threadId || session.threadId,
+        suppressedByMessageId: message.messageId,
+        suppressedByTurnId: null,
+        reason: 'session advanced after unresolved recovery state',
+      });
+    }
+  }
+
+  if (waitingState && session.threadId && session.activeTurnId) {
+    logInfo('receiver', 'waiting_user_follow_up_intercepted', {
+      messageId: message.messageId,
+      conversationId: message.conversationRef.conversationId,
+      threadId: session.threadId,
+      activeTurnId: session.activeTurnId,
+      waitingState,
+    });
+    if (waitingState === 'approval' && await deps.maybeHandleWaitingApprovalShortcut(message, session)) {
+      return { kind: 'handled' };
+    }
+    await deps.send({
+      type: 'status_reply',
+      conversationRef: message.conversationRef,
+      text: systemNoticeMessage(waitingUserInputFollowUpMessage()),
+    }, {
+      source: 'waiting_user_follow_up',
+      thread_id: session.threadId,
+      turn_id: session.activeTurnId,
+      waiting_state: waitingState,
+      message_id: message.messageId,
+    });
+    return { kind: 'handled' };
+  }
+
+  if (!waitingState && runtimeWaitingState && session.threadId && session.activeTurnId) {
+    const replayed = runtimeWaitingState === 'approval'
+      ? await deps.replayHiddenPendingApproval(message.conversationRef, session.threadId, session.activeTurnId)
+      : await deps.replayHiddenPendingUserInput(message.conversationRef, session.threadId, session.activeTurnId);
+    if (replayed) {
+      return { kind: 'handled' };
+    }
+  }
+
+  if (session.threadId && session.activeTurnId && deps.isActiveTurnStale(runtimeStatus)) {
+    const staleTurnId = session.activeTurnId;
+    const staleThreadId = session.threadId;
+    deps.sessionStore.clearActiveTurn(message.conversationRef);
+    deps.sessionStore.markTurnSuppressed(message.conversationRef, staleTurnId, {
+      threadId: staleThreadId,
+      suppressedByMessageId: message.messageId,
+      suppressedByTurnId: null,
+      reason: 'stale active turn cleared before accepting newer inbound message',
+    });
+    deps.clearRuntimeRecovery(message.conversationRef);
+  }
+
+  const latestAfterCleanup = deps.sessionStore.ensureSession(message.conversationRef);
+  if (latestAfterCleanup.threadId && latestAfterCleanup.activeTurnId) {
+    const steerResult = await deps.steerActiveTurn(message, latestAfterCleanup, runtimeWaitingState);
+    if (steerResult === 'handled') {
+      return { kind: 'handled' };
+    }
+    if (steerResult === 'retry_start') {
+    }
+  }
+
+  return {
+    kind: 'continue',
+    session: latestAfterCleanup,
+  };
+}

package/bridge/src/receiver-recovery.ts

@@ -0,0 +1,236 @@
+import type { OutboundEnvelope } from './channel-types.ts';
+import { logInfo, logWarn } from './logger.ts';
+import { runtimeFinalStateRecoveryRequiredMessage, runtimeRecoveryRequiredMessage, systemNoticeMessage } from './translator.ts';
+import type { ConversationRef, RuntimeThreadStatus, RuntimeTurnResult } from './types.ts';
+
+export type RecoveryKind = 'infrastructure' | 'final_state_unconfirmed';
+
+export interface StaleTurnSuppressedDetails {
+  messageId: string;
+  threadId: string | null;
+  turnId: string | null;
+  stage: 'progress' | 'approval' | 'user_input' | 'failure' | 'result';
+  reason: string;
+  status?: string | null;
+}
+
+interface SendLike {
+  (
+    outbound: OutboundEnvelope,
+    extra?: Record<string, unknown>,
+    delivery?: { trackTurnId?: string | null },
+  ): Promise<boolean>;
+}
+
+interface RecoveryRuntimeLike {
+  recoverTurnResult?(threadId: string, turnId: string, options?: { timeoutMs?: number; pollMs?: number }): Promise<RuntimeTurnResult | null>;
+}
+
+interface StaleDeps {
+  markTurnSuppressed(conversationRef: ConversationRef, turnId: string | null, threadId: string | null, reason: string): void;
+}
+
+interface RecoveryNoticeDeps {
+  clearRuntimeRecovery(conversationRef: ConversationRef): void;
+  send: SendLike;
+}
+
+interface TryRecoverDeps extends StaleDeps {
+  runtime: RecoveryRuntimeLike;
+  clearRuntimeRecovery(conversationRef: ConversationRef): void;
+  markRuntimeRecovery(conversationRef: ConversationRef): void;
+  isTurnStillCurrent(conversationRef: ConversationRef, messageId: string, turnId: string | null): boolean;
+  visibilityDelayMs: number;
+}
+
+export function isActiveTurnStale(runtimeStatus: RuntimeThreadStatus | null): boolean {
+  return runtimeStatus?.type === 'idle' || runtimeStatus?.type === 'notLoaded';
+}
+
+export function isRuntimeInfrastructureError(text: string): boolean {
+  return /runtime (?:stdio|transport) is not connected|runtime child process exited|runtime connect timed out/i.test(text || '');
+}
+
+export function isRuntimeFinalStateUnconfirmedError(text: string): boolean {
+  return /runtime turn final state unavailable|runtime turn reconciliation failed/i.test(text || '');
+}
+
+export function runtimeRecoveryKindFor(text: string): RecoveryKind | null {
+  if (isRuntimeInfrastructureError(text)) {
+    return 'infrastructure';
+  }
+  if (isRuntimeFinalStateUnconfirmedError(text)) {
+    return 'final_state_unconfirmed';
+  }
+  return null;
+}
+
+export function recoveryAttemptSilentWindowMs(startedAt: string | null, visibilityDelayMs: number): number {
+  if (visibilityDelayMs <= 0) {
+    return 0;
+  }
+  const startedMs = startedAt ? Date.parse(startedAt) : Number.NaN;
+  if (!Number.isFinite(startedMs)) {
+    return visibilityDelayMs;
+  }
+  return Math.max(0, visibilityDelayMs - Math.max(0, Date.now() - startedMs));
+}
+
+export function noteStaleTurnSuppressed(
+  deps: StaleDeps,
+  conversationRef: ConversationRef,
+  details: StaleTurnSuppressedDetails,
+): void {
+  logWarn('receiver', 'stale_turn_output_suppressed', {
+    conversationId: conversationRef.conversationId,
+    messageId: details.messageId,
+    threadId: details.threadId,
+    turnId: details.turnId,
+    stage: details.stage,
+    reason: details.reason,
+    status: details.status || null,
+  });
+  deps.markTurnSuppressed(conversationRef, details.turnId, details.threadId, details.reason);
+}
+
+export async function sendRuntimeRecoveryNotice(
+  deps: RecoveryNoticeDeps,
+  conversationRef: ConversationRef,
+  threadId: string,
+  turnId: string | null,
+  errorText: string,
+  recoveryKind: RecoveryKind,
+): Promise<void> {
+  deps.clearRuntimeRecovery(conversationRef);
+  const text = systemNoticeMessage(
+    recoveryKind === 'final_state_unconfirmed'
+      ? runtimeFinalStateRecoveryRequiredMessage()
+      : runtimeRecoveryRequiredMessage(),
+  );
+  await deps.send({
+    type: 'error_reply',
+    conversationRef,
+    text,
+  }, {
+    source: 'runtime_recovery_notice_sent',
+    thread_id: threadId,
+    turn_id: turnId,
+    recovery_kind: recoveryKind,
+  }, { trackTurnId: turnId });
+}
+
+function finishRecoveredTurnResult(
+  deps: TryRecoverDeps,
+  conversationRef: ConversationRef,
+  threadId: string,
+  turnId: string,
+  messageId: string,
+  recoveryKind: RecoveryKind,
+  recovered: RuntimeTurnResult,
+  noticeVisible: boolean,
+): RuntimeTurnResult | null {
+  if (!deps.isTurnStillCurrent(conversationRef, messageId, turnId)) {
+    noteStaleTurnSuppressed(deps, conversationRef, {
+      messageId,
+      threadId: recovered.threadId,
+      turnId: recovered.turnId,
+      stage: 'result',
+      reason: 'session advanced before recovered turn result became user-visible',
+      status: recovered.status,
+    });
+    return null;
+  }
+  logInfo('receiver', 'turn_recovered', {
+    conversationId: conversationRef.conversationId,
+    threadId: recovered.threadId,
+    turnId: recovered.turnId,
+    status: recovered.status,
+    recoveryKind,
+    recoveryNoticeVisible: noticeVisible,
+  });
+  deps.clearRuntimeRecovery(conversationRef);
+  return recovered;
+}
+
+export async function tryRecoverTurnResult(
+  deps: TryRecoverDeps,
+  conversationRef: ConversationRef,
+  threadId: string,
+  turnId: string | null,
+  messageId: string,
+  errorText: string,
+  startedAt: string | null,
+): Promise<RuntimeTurnResult | null> {
+  const recoveryKind = runtimeRecoveryKindFor(errorText);
+  if (!turnId || !recoveryKind || typeof deps.runtime.recoverTurnResult !== 'function') {
+    return null;
+  }
+  if (!deps.isTurnStillCurrent(conversationRef, messageId, turnId)) {
+    noteStaleTurnSuppressed(deps, conversationRef, {
+      messageId,
+      threadId,
+      turnId,
+      stage: 'failure',
+      reason: 'session advanced before turn recovery attempt became user-visible',
+    });
+    return null;
+  }
+
+  deps.markRuntimeRecovery(conversationRef);
+
+  const silentWindowMs = recoveryAttemptSilentWindowMs(startedAt, deps.visibilityDelayMs);
+  if (silentWindowMs > 0) {
+    const recoveredDuringGrace = await deps.runtime.recoverTurnResult(threadId, turnId, {
+      timeoutMs: silentWindowMs,
+      pollMs: Math.min(250, silentWindowMs),
+    });
+    if (recoveredDuringGrace) {
+      return finishRecoveredTurnResult(
+        deps,
+        conversationRef,
+        threadId,
+        turnId,
+        messageId,
+        recoveryKind,
+        recoveredDuringGrace,
+        false,
+      );
+    }
+  }
+
+  if (!deps.isTurnStillCurrent(conversationRef, messageId, turnId)) {
+    noteStaleTurnSuppressed(deps, conversationRef, {
+      messageId,
+      threadId,
+      turnId,
+      stage: 'failure',
+      reason: 'session advanced before turn recovery attempt became user-visible',
+    });
+    return null;
+  }
+
+  try {
+    const recovered = await deps.runtime.recoverTurnResult(threadId, turnId);
+    if (!recovered) {
+      return null;
+    }
+    return finishRecoveredTurnResult(
+      deps,
+      conversationRef,
+      threadId,
+      turnId,
+      messageId,
+      recoveryKind,
+      recovered,
+      true,
+    );
+  } catch (recoveryError) {
+    logWarn('receiver', 'turn_recovery_failed', {
+      conversationId: conversationRef.conversationId,
+      threadId,
+      turnId,
+      error: recoveryError instanceof Error ? (recoveryError.stack || recoveryError.message) : String(recoveryError),
+    });
+    return null;
+  }
+}