work-ally 0.2.0-alpha.1

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

@@ -0,0 +1,143 @@
+import { errorMessageFromUnknown } from './receiver-helpers.ts';
+import { noteStaleTurnSuppressed, isMessageStillLatest, isTurnStillCurrent, markTurnSuppressed } from './receiver-turn-coordination.ts';
+import { normalizeErrorReplyText } from './receiver-runtime-policy.ts';
+import { runtimeRecoveryKindFor } from './receiver-recovery.ts';
+import type { SessionStore } from './session-store.ts';
+import type { ConversationRef, InboundMessage, RuntimeTurnResult } from './types.ts';
+
+interface SendLike {
+  (
+    outbound: {
+      type: 'error_reply';
+      conversationRef: ConversationRef;
+      text: string;
+    },
+    extra?: Record<string, unknown>,
+    delivery?: { trackTurnId?: string | null },
+  ): Promise<boolean>;
+}
+
+interface RuntimeRecoveryRegistry {
+  clear(conversationRef: ConversationRef): void;
+}
+
+interface SupportLike {
+  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>;
+}
+
+interface HandleFailedTurnDeps {
+  sessionStore: SessionStore;
+  runtimeRecovery: RuntimeRecoveryRegistry;
+  support: SupportLike;
+  send: SendLike;
+}
+
+interface HandleFailedTurnArgs {
+  message: InboundMessage;
+  threadId: string;
+  currentTurnId: string | null;
+  turnEntryMessageId: string;
+  startedAt: string;
+  error: unknown;
+}
+
+export async function handleFailedTurnExecution(
+  deps: HandleFailedTurnDeps,
+  args: HandleFailedTurnArgs,
+): Promise<RuntimeTurnResult | null> {
+  const { message, threadId, currentTurnId, turnEntryMessageId, startedAt, error } = args;
+  const errorText = errorMessageFromUnknown(error);
+
+  if (currentTurnId && !isTurnStillCurrent(deps.sessionStore, message.conversationRef, turnEntryMessageId, currentTurnId)) {
+    noteStaleTurnSuppressed({ sessionStore: deps.sessionStore }, message.conversationRef, {
+      messageId: message.messageId,
+      threadId,
+      turnId: currentTurnId,
+      stage: 'failure',
+      reason: 'session advanced before stale turn failure surfaced',
+    });
+    return null;
+  }
+
+  const recovered = await deps.support.tryRecoverTurnResult(
+    message.conversationRef,
+    threadId,
+    currentTurnId,
+    message.messageId,
+    errorText,
+    startedAt,
+    {
+      isTurnStillCurrent: (ref, currentMessageId, turnId) => isTurnStillCurrent(deps.sessionStore, ref, currentMessageId, turnId),
+      markTurnSuppressed: (ref, turnId, currentThreadId, reason) => markTurnSuppressed(deps.sessionStore, ref, turnId, currentThreadId, reason),
+    },
+  );
+  if (recovered) {
+    return recovered;
+  }
+
+  if (currentTurnId && !isTurnStillCurrent(deps.sessionStore, message.conversationRef, turnEntryMessageId, currentTurnId)) {
+    noteStaleTurnSuppressed({ sessionStore: deps.sessionStore }, message.conversationRef, {
+      messageId: message.messageId,
+      threadId,
+      turnId: currentTurnId,
+      stage: 'failure',
+      reason: 'session advanced while runtime recovery was in progress',
+    });
+    return null;
+  }
+
+  if (currentTurnId) {
+    deps.sessionStore.recordTurn(message.conversationRef, {
+      turnId: currentTurnId,
+      threadId,
+      status: 'failed',
+      prompt: message.text,
+      reply: '',
+      startedAt,
+      completedAt: new Date().toISOString(),
+      error: errorText,
+    });
+  }
+
+  const recoveryKind = runtimeRecoveryKindFor(errorText);
+  if (recoveryKind && currentTurnId) {
+    if (isMessageStillLatest(deps.sessionStore, message.conversationRef, message.messageId)) {
+      await deps.support.sendRuntimeRecoveryNotice(message.conversationRef, threadId, currentTurnId, errorText, recoveryKind);
+    } else {
+      noteStaleTurnSuppressed({ sessionStore: deps.sessionStore }, message.conversationRef, {
+        messageId: message.messageId,
+        threadId,
+        turnId: currentTurnId,
+        stage: 'failure',
+        reason: 'session advanced before recovery-required notice became user-visible',
+      });
+    }
+    return null;
+  }
+
+  deps.runtimeRecovery.clear(message.conversationRef);
+  await deps.send({
+    type: 'error_reply',
+    conversationRef: message.conversationRef,
+    text: normalizeErrorReplyText(errorText),
+  }, {}, { trackTurnId: currentTurnId });
+  return null;
+}

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

@@ -0,0 +1,185 @@
+import { logInfo } from './logger.ts';
+import type { OutboundEnvelope } from './channel-types.ts';
+import type { SessionStore } from './session-store.ts';
+import type { StaleTurnSuppressedDetails } from './receiver-recovery.ts';
+import { completionWithoutReplyStatusMessage, runtimeFinalStateRecoveryRequiredMessage, runtimeInfrastructureErrorMessage, systemNoticeMessage } from './translator.ts';
+import type { ConversationRef, RuntimeTurnResult } from './types.ts';
+
+interface SendLike {
+  (
+    outbound: OutboundEnvelope,
+    extra?: Record<string, unknown>,
+    delivery?: { trackTurnId?: string | null },
+  ): Promise<boolean>;
+}
+
+interface FinalizeTurnResultDeps {
+  sessionStore: SessionStore;
+  send: SendLike;
+  clearRuntimeRecovery(conversationRef: ConversationRef): void;
+  isTurnStillCurrent(conversationRef: ConversationRef, messageId: string, turnId: string | null): boolean;
+  noteStaleTurnSuppressed(conversationRef: ConversationRef, details: StaleTurnSuppressedDetails): void;
+  markTurnSuppressed(conversationRef: ConversationRef, turnId: string | null, threadId: string | null, reason: string): void;
+  recordPendingFinalReplyDelivery(conversationRef: ConversationRef, threadId: string, turnId: string, text: string): string;
+  markFinalReplyDelivered(conversationRef: ConversationRef, threadId: string, turnId: string): void;
+  isRuntimeInfrastructureError(text: string): boolean;
+  normalizeErrorReplyText(text: string): string;
+  consumeUserRequestedStop(turnId: string): boolean;
+  hasSuppressedInterruptedTurn(turnId: string): boolean;
+  clearSuppressedInterruptedTurn(turnId: string): void;
+}
+
+interface FinalizeTurnResultArgs {
+  conversationRef: ConversationRef;
+  messageId: string;
+  prompt: string;
+  startedAt: string;
+  result: RuntimeTurnResult;
+}
+
+export async function finalizeTurnResult(
+  deps: FinalizeTurnResultDeps,
+  args: FinalizeTurnResultArgs,
+): Promise<boolean> {
+  const { conversationRef, messageId, prompt, startedAt, result } = args;
+
+  if (!deps.isTurnStillCurrent(conversationRef, messageId, result.turnId)) {
+    deps.noteStaleTurnSuppressed(conversationRef, {
+      messageId,
+      threadId: result.threadId,
+      turnId: result.turnId,
+      stage: 'result',
+      reason: 'session advanced before stale turn completed',
+      status: result.status,
+    });
+    deps.clearSuppressedInterruptedTurn(result.turnId);
+    return true;
+  }
+
+  const interrupted = result.status === 'interrupted' || result.error === 'turn interrupted';
+  const userRequestedStop = deps.consumeUserRequestedStop(result.turnId);
+
+  logInfo('receiver', 'turn_completed', {
+    messageId,
+    conversationId: conversationRef.conversationId,
+    threadId: result.threadId,
+    turnId: result.turnId,
+    status: result.status,
+    replyLength: result.reply.length,
+  });
+  deps.sessionStore.recordTurn(conversationRef, {
+    turnId: result.turnId,
+    threadId: result.threadId,
+    status: result.status,
+    prompt,
+    reply: result.reply,
+    startedAt,
+    completedAt: new Date().toISOString(),
+    error: userRequestedStop ? 'user requested stop' : (result.error || null),
+  });
+
+  if (result.status !== 'completed') {
+    if (interrupted && deps.hasSuppressedInterruptedTurn(result.turnId)) {
+      deps.clearSuppressedInterruptedTurn(result.turnId);
+      deps.markTurnSuppressed(conversationRef, result.turnId, result.threadId, 'turn interrupted after session advanced');
+      return true;
+    }
+    deps.clearRuntimeRecovery(conversationRef);
+    const terminalReplyText = String(result.reply || '').trim();
+    if (terminalReplyText) {
+      deps.recordPendingFinalReplyDelivery(conversationRef, result.threadId, result.turnId, result.reply);
+      const delivered = await deps.send({
+        type: 'final_reply',
+        conversationRef,
+        text: result.reply,
+      }, {
+        source: 'non_completed_turn_with_reply',
+        thread_id: result.threadId,
+        turn_id: result.turnId,
+        runtime_status: result.status,
+      }, { trackTurnId: result.turnId });
+      if (delivered) {
+        deps.markFinalReplyDelivered(conversationRef, result.threadId, result.turnId);
+      }
+      return true;
+    }
+    if (interrupted) {
+      if (userRequestedStop) {
+        await deps.send({
+          type: 'status_reply',
+          conversationRef,
+          text: '当前任务已停止。',
+        }, {}, { trackTurnId: result.turnId });
+        return true;
+      }
+
+      if (deps.isRuntimeInfrastructureError(result.error || '')) {
+        await deps.send({
+          type: 'error_reply',
+          conversationRef,
+          text: systemNoticeMessage(runtimeInfrastructureErrorMessage()),
+        }, {
+          source: 'interrupted_without_reply_runtime_disconnect',
+          thread_id: result.threadId,
+          turn_id: result.turnId,
+        }, { trackTurnId: result.turnId });
+        return true;
+      }
+
+      await deps.send({
+        type: 'error_reply',
+        conversationRef,
+        text: systemNoticeMessage(runtimeFinalStateRecoveryRequiredMessage()),
+      }, {
+        source: 'interrupted_without_reply_unconfirmed',
+        thread_id: result.threadId,
+        turn_id: result.turnId,
+      }, { trackTurnId: result.turnId });
+      return true;
+    }
+    await deps.send({
+      type: 'error_reply',
+      conversationRef,
+      text: deps.normalizeErrorReplyText(result.error || '处理失败。'),
+    }, {}, { trackTurnId: result.turnId });
+    return true;
+  }
+
+  deps.clearRuntimeRecovery(conversationRef);
+  const finalReplyText = String(result.reply || '').trim();
+  if (finalReplyText) {
+    deps.recordPendingFinalReplyDelivery(conversationRef, result.threadId, result.turnId, result.reply);
+    const delivered = await deps.send({
+      type: 'final_reply',
+      conversationRef,
+      text: result.reply,
+    }, {}, { trackTurnId: result.turnId });
+    if (delivered) {
+      deps.markFinalReplyDelivered(conversationRef, result.threadId, result.turnId);
+    }
+    logInfo('receiver', 'final_reply_sent', {
+      messageId,
+      conversationId: conversationRef.conversationId,
+      replyLength: result.reply.length,
+      delivered,
+    });
+    return true;
+  }
+
+  await deps.send({
+    type: 'status_reply',
+    conversationRef,
+    text: completionWithoutReplyStatusMessage(),
+  }, {
+    source: 'completion_without_reply',
+    thread_id: result.threadId,
+    turn_id: result.turnId,
+  }, { trackTurnId: result.turnId });
+  logInfo('receiver', 'completion_without_reply_sent', {
+    messageId,
+    conversationId: conversationRef.conversationId,
+    threadId: result.threadId,
+    turnId: result.turnId,
+  });
+  return true;
+}

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

@@ -0,0 +1,70 @@
+import type { OutboundEnvelope } from './channel-types.ts';
+import { errorDetailsFromUnknown, errorMessageFromUnknown } from './receiver-helpers.ts';
+import { buildPrompt, isMissingThreadError, isStaleTurnError, normalizeErrorReplyText } from './receiver-runtime-policy.ts';
+import type { SessionStore } from './session-store.ts';
+import type { InboundMessage, SessionMeta } from './types.ts';
+
+interface SendLike {
+  (
+    outbound: OutboundEnvelope,
+    extra?: Record<string, unknown>,
+    delivery?: { trackTurnId?: string | null },
+  ): Promise<boolean>;
+}
+
+interface RuntimeSteerLike {
+  steerTurn?(threadId: string, turnId: string, prompt: string): Promise<void>;
+}
+
+interface SteerActiveTurnDeps {
+  sessionStore: SessionStore;
+  runtime: RuntimeSteerLike;
+  send: SendLike;
+  reactEmoji?: string | null;
+}
+
+export async function steerActiveTurn(
+  deps: SteerActiveTurnDeps,
+  message: InboundMessage,
+  session: SessionMeta,
+  runtimeWaitingState: 'approval' | 'user_input' | null,
+): Promise<'handled' | 'retry_start' | null> {
+  if (!session.threadId || !session.activeTurnId || typeof deps.runtime.steerTurn !== 'function') {
+    return null;
+  }
+
+  deps.sessionStore.noteLatestInbound(message.conversationRef, {
+    messageId: message.messageId,
+    promptPreview: message.text,
+  });
+  await deps.send({
+    type: 'ack_received',
+    conversationRef: message.conversationRef,
+    messageId: message.messageId,
+    emoji: deps.reactEmoji || undefined,
+  });
+
+  try {
+    await deps.runtime.steerTurn(session.threadId, session.activeTurnId, buildPrompt(message));
+    return 'handled';
+  } catch (error) {
+    const errorDetails = errorDetailsFromUnknown(error);
+    if (isMissingThreadError(error) || isStaleTurnError(error) || runtimeWaitingState === null) {
+      deps.sessionStore.clearActiveTurn(message.conversationRef);
+      return 'retry_start';
+    }
+    const errorText = errorMessageFromUnknown(error);
+    await deps.send({
+      type: 'error_reply',
+      conversationRef: message.conversationRef,
+      text: normalizeErrorReplyText(errorText),
+    }, {
+      source: 'turn_steer_blocked_by_visible_waiting_state',
+      message_id: message.messageId,
+      thread_id: session.threadId,
+      turn_id: session.activeTurnId,
+      waiting_state: runtimeWaitingState,
+    });
+    return 'handled';
+  }
+}

package/bridge/src/receiver-work-session.ts

@@ -0,0 +1,76 @@
+import type { ConversationRef, WorkSessionMeta } from './types.ts';
+import { conversationKey } from './utils.ts';
+import { WorkSessionStore } from './work-session-store.ts';
+
+interface ReceiverWorkSessionDeps {
+  assistantName: string;
+  workSessionStore: WorkSessionStore;
+}
+
+interface EnsureLinkedWorkSessionDeps extends ReceiverWorkSessionDeps {
+  assistantCodexHome: string | null;
+  workspaceRoot: string;
+}
+
+export function resolveDeliveryConversationKey(ref: ConversationRef): string {
+  return conversationKey(ref.channel, ref.conversationId);
+}
+
+export function activeWorkSessionFor(
+  deps: ReceiverWorkSessionDeps,
+  ref: ConversationRef,
+): WorkSessionMeta | null {
+  return deps.workSessionStore.getActiveWorkSessionForDelivery(ref.channel, resolveDeliveryConversationKey(ref));
+}
+
+export function ensureLinkedWorkSessionForThread(
+  deps: EnsureLinkedWorkSessionDeps,
+  ref: ConversationRef,
+  runtimeThreadId: string | null | undefined,
+): WorkSessionMeta | null {
+  const nextRuntimeThreadId = typeof runtimeThreadId === 'string' ? runtimeThreadId.trim() : '';
+  if (!nextRuntimeThreadId) {
+    return activeWorkSessionFor(deps, ref);
+  }
+
+  const linked = activeWorkSessionFor(deps, ref);
+  if (linked) {
+    if (linked.runtimeThreadId === nextRuntimeThreadId) {
+      return linked;
+    }
+    return deps.workSessionStore.rebindRuntimeThread(linked.workSessionId, nextRuntimeThreadId);
+  }
+
+  return deps.workSessionStore.createWorkSession({
+    assistantName: deps.assistantName,
+    assistantCodexHome: deps.assistantCodexHome,
+    workspaceRoot: deps.workspaceRoot,
+    runtimeThreadId: nextRuntimeThreadId,
+    cliResumeRef: nextRuntimeThreadId,
+    cliResumeRefType: 'session_id',
+    origin: 'work_ally',
+    deliveryChannel: ref.channel,
+    deliveryConversationKey: resolveDeliveryConversationKey(ref),
+    activeSurface: 'work_ally_channel',
+    ownershipSource: 'new_session',
+  });
+}
+
+export function syncLinkedWorkSessionThread(
+  deps: ReceiverWorkSessionDeps,
+  ref: ConversationRef,
+  runtimeThreadId: string | null | undefined,
+): WorkSessionMeta | null {
+  const nextRuntimeThreadId = typeof runtimeThreadId === 'string' ? runtimeThreadId.trim() : '';
+  if (!nextRuntimeThreadId) {
+    return activeWorkSessionFor(deps, ref);
+  }
+  const linked = activeWorkSessionFor(deps, ref);
+  if (!linked) {
+    return null;
+  }
+  if (linked.runtimeThreadId === nextRuntimeThreadId) {
+    return linked;
+  }
+  return deps.workSessionStore.rebindRuntimeThread(linked.workSessionId, nextRuntimeThreadId);
+}