work-ally 0.2.0-alpha.1

package/bridge/src/runtime-client-run-turn.ts

@@ -0,0 +1,158 @@
+import type { RuntimeTurnState } from './runtime-client-agent-messages.ts';
+import { logWarn } from './logger.ts';
+import { approvalRequestFrom, elicitationRequestFrom, userInputRequestFrom, type JsonRpcMessage, type RunTurnOptions } from './runtime-client-protocol.ts';
+import { logInfo } from './logger.ts';
+import type { RuntimeProgressMeta, RuntimeThreadStatus, RuntimeTurnResult } from './types.ts';
+
+interface RunTurnEventBridgeDeps {
+  safeEmitTurnProgress(turnId: string, text: string, meta?: RuntimeProgressMeta): Promise<void>;
+  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 RunTurnEventBridgeState {
+  getActiveTurnId(): string | null;
+}
+
+interface StartRuntimeTurnDeps {
+  request(method: string, params: unknown): Promise<any>;
+  cacheThreadStatus(threadId: string, status: RuntimeThreadStatus | null | undefined): RuntimeThreadStatus | null;
+  turnStates: Map<string, RuntimeTurnState>;
+  startTurnFinalPoll(threadId: string, turnId: string): void;
+  rejectTurnResult(turnId: string, error: Error): boolean;
+}
+
+function createRuntimeTurnPromise(
+  turnStates: Map<string, RuntimeTurnState>,
+  options: RunTurnOptions,
+  turnId: string,
+): Promise<RuntimeTurnResult> {
+  return new Promise<RuntimeTurnResult>((resolve, reject) => {
+    turnStates.set(turnId, {
+      threadId: options.threadId,
+      agentMessages: new Map(),
+      nextAgentMessageOrder: 0,
+      onProgress: options.onProgress,
+      onThreadStatus: options.onThreadStatus,
+      completedEventResult: null,
+      emittedContextCompactionKeys: new Set(),
+      resolve,
+      reject,
+    });
+  });
+}
+
+export async function startRuntimeTurn(
+  deps: StartRuntimeTurnDeps,
+  options: RunTurnOptions,
+): Promise<{ turnId: string; turnPromise: Promise<RuntimeTurnResult> }> {
+  logInfo('runtime', 'turn_starting', {
+    threadId: options.threadId,
+    messageId: options.messageId,
+  });
+  const result = await deps.request('turn/start', {
+    threadId: options.threadId,
+    cwd: options.cwd,
+    ...(options.approvalPolicy ? { approvalPolicy: options.approvalPolicy } : {}),
+    ...(options.sandboxPolicy ? { sandboxPolicy: options.sandboxPolicy } : {}),
+    input: [{ type: 'text', text: options.prompt, text_elements: [] }],
+  });
+  const turnId = result.turn.id;
+  deps.cacheThreadStatus(options.threadId, { type: 'active', activeFlags: [] });
+  logInfo('runtime', 'turn_started', {
+    threadId: options.threadId,
+    turnId,
+    messageId: options.messageId,
+  });
+  const turnPromise = createRuntimeTurnPromise(deps.turnStates, options, turnId);
+  deps.startTurnFinalPoll(options.threadId, turnId);
+  try {
+    await options.onTurnStarted?.(turnId);
+  } catch (error) {
+    deps.rejectTurnResult(turnId, error instanceof Error ? error : new Error(String(error)));
+    throw error;
+  }
+  return { turnId, turnPromise };
+}
+
+export function createRunTurnEventBridge(
+  deps: RunTurnEventBridgeDeps,
+  options: RunTurnOptions,
+  state: RunTurnEventBridgeState,
+): {
+  progressHandler: (eventTurnId: string, text: string, meta?: RuntimeProgressMeta) => Promise<void>;
+  serverRequestHandler: (msg: JsonRpcMessage) => Promise<void>;
+} {
+  const progressHandler = async (eventTurnId: string, text: string, meta?: RuntimeProgressMeta) => {
+    const activeTurnId = state.getActiveTurnId();
+    if (activeTurnId && eventTurnId !== activeTurnId) {
+      return;
+    }
+    await deps.safeEmitTurnProgress(activeTurnId || eventTurnId, text, meta);
+  };
+
+  const serverRequestHandler = async (msg: JsonRpcMessage) => {
+    const activeTurnId = state.getActiveTurnId();
+    const eventTurnId = typeof msg.params?.turnId === 'string' ? msg.params.turnId : null;
+    if (activeTurnId && eventTurnId && eventTurnId !== activeTurnId) {
+      return;
+    }
+
+    const approval = approvalRequestFrom(msg, options.messageId);
+    if (approval) {
+      if (activeTurnId && approval.turnId !== activeTurnId) {
+        return;
+      }
+      if (!options.onApproval) {
+        await deps.resolveApproval(approval.requestId, 'cancel');
+        return;
+      }
+      await options.onApproval(approval);
+      return;
+    }
+
+    const userInput = userInputRequestFrom(msg, options.messageId);
+    if (userInput) {
+      if (activeTurnId && userInput.turnId !== activeTurnId) {
+        return;
+      }
+      if (!options.onUserInput) {
+        logWarn('runtime', 'user_input_requested_without_handler', {
+          threadId: userInput.threadId,
+          turnId: userInput.turnId,
+          requestId: userInput.requestId,
+        });
+        await deps.resolveUserInput(userInput.requestId, { answers: {} });
+        return;
+      }
+      await options.onUserInput(userInput);
+      return;
+    }
+
+    const elicitation = elicitationRequestFrom(msg, options.messageId);
+    if (!elicitation) {
+      return;
+    }
+    if (activeTurnId && elicitation.turnId && elicitation.turnId !== activeTurnId) {
+      return;
+    }
+    if (!options.onUserInput) {
+      logWarn('runtime', 'elicitation_requested_without_handler', {
+        threadId: elicitation.threadId,
+        turnId: elicitation.turnId || null,
+        requestId: elicitation.requestId,
+        serverName: elicitation.elicitation?.serverName || null,
+        mode: elicitation.elicitation?.mode || null,
+      });
+      await deps.resolveElicitation(elicitation.requestId, { action: 'cancel', content: null });
+      return;
+    }
+    await options.onUserInput(elicitation);
+  };
+
+  return { progressHandler, serverRequestHandler };
+}

package/bridge/src/runtime-client-thread-ops.ts

@@ -0,0 +1,270 @@
+import { buildReplyFromThreadItems } from './runtime-client-agent-messages.ts';
+import { readPersistedFinalReplyFromCodexHome, readTurnResult } from './runtime-client-turn-read.ts';
+import { logInfo, logWarn } from './logger.ts';
+import type { ApprovalDecision, RuntimeThreadStatus, RuntimeTurnResult } from './types.ts';
+import { normalizeRuntimeError, normalizeThreadStatus, type ThreadOptions } from './runtime-client-protocol.ts';
+
+const TURN_RESULT_RECOVERY_TIMEOUT_MS = Number(process.env.WORK_ALLY_TURN_RESULT_RECOVERY_TIMEOUT_MS || '60000');
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+interface RequestLike {
+  (method: string, params: unknown): Promise<any>;
+}
+
+interface ConnectLike {
+  (): Promise<void>;
+}
+
+interface ThreadStatusCacheLike {
+  set(threadId: string, status: RuntimeThreadStatus): void;
+  get(threadId: string): RuntimeThreadStatus | undefined;
+}
+
+interface ThreadRequestDeps {
+  request: RequestLike;
+  cacheThreadStatus(threadId: string, status: RuntimeThreadStatus | null | undefined): RuntimeThreadStatus | null;
+}
+
+interface ResumeThreadDeps extends ThreadRequestDeps {
+  startThread(cwd: string, options?: ThreadOptions): Promise<{ id: string }> ;
+}
+
+interface ThreadStatusReadDeps extends ThreadRequestDeps {
+  cachedThreadStatus(threadId: string): RuntimeThreadStatus | null;
+}
+
+interface SteerTurnDeps {
+  connect: ConnectLike;
+  request: RequestLike;
+  isRecoverableRuntimeError(error: unknown): boolean;
+  scheduleReconnect(reason: string): void;
+}
+
+interface RecoverTurnResultDeps {
+  request: RequestLike;
+  cacheThreadStatus(threadId: string, status: RuntimeThreadStatus | null | undefined): RuntimeThreadStatus | null;
+  readPersistedFinalReply(turnId: string): string | null;
+}
+
+interface SendRawLike {
+  (payload: unknown): void;
+}
+
+export function threadParamsFor(cwd: string, options: ThreadOptions = {}) {
+  return {
+    cwd,
+    ...(options.approvalPolicy ? { approvalPolicy: options.approvalPolicy } : {}),
+    ...(options.sandbox ? { sandbox: options.sandbox } : {}),
+    ...(options.developerInstructions ? { developerInstructions: options.developerInstructions } : {}),
+    ...(options.baseInstructions ? { baseInstructions: options.baseInstructions } : {}),
+  };
+}
+
+export function cacheThreadStatusFor(
+  cache: ThreadStatusCacheLike,
+  threadId: string,
+  status: RuntimeThreadStatus | null | undefined,
+): RuntimeThreadStatus | null {
+  if (!threadId || !status) {
+    return null;
+  }
+  const normalized = {
+    type: status.type,
+    activeFlags: [...status.activeFlags],
+  } satisfies RuntimeThreadStatus;
+  cache.set(threadId, normalized);
+  return normalized;
+}
+
+export function cachedThreadStatusFor(cache: ThreadStatusCacheLike, threadId: string): RuntimeThreadStatus | null {
+  const status = cache.get(threadId);
+  if (!status) {
+    return null;
+  }
+  return {
+    type: status.type,
+    activeFlags: [...status.activeFlags],
+  };
+}
+
+export function readPersistedFinalReply(codexHome: string | null, turnId: string): string | null {
+  return readPersistedFinalReplyFromCodexHome(codexHome, turnId);
+}
+
+export async function startThreadRequest(
+  deps: ThreadRequestDeps,
+  cwd: string,
+  options: ThreadOptions = {},
+): Promise<{ id: string }> {
+  const result = await deps.request('thread/start', {
+    ...threadParamsFor(cwd, options),
+    experimentalRawEvents: false,
+    persistExtendedHistory: true,
+  });
+  const threadId = result.thread.id;
+  deps.cacheThreadStatus(threadId, normalizeThreadStatus(result?.thread?.status));
+  return { id: threadId };
+}
+
+export async function resumeThreadRequest(
+  deps: ResumeThreadDeps,
+  threadId: string,
+  cwd: string,
+  options: ThreadOptions = {},
+): Promise<{ id: string }> {
+  try {
+    const result = await deps.request('thread/resume', {
+      threadId,
+      ...threadParamsFor(cwd, options),
+      persistExtendedHistory: true,
+    });
+    const resumedThreadId = result.thread.id;
+    deps.cacheThreadStatus(resumedThreadId, normalizeThreadStatus(result?.thread?.status));
+    return { id: resumedThreadId };
+  } catch (error: any) {
+    const message = error?.message || '';
+    const code = error?.code;
+    if (String(code || '') === '-32600' && typeof message === 'string' && /no rollout found for thread id/i.test(message)) {
+      logWarn('runtime', 'thread_resume_missing_rollout', {
+        threadId,
+        cwd,
+      });
+      return deps.startThread(cwd, options);
+    }
+    throw error;
+  }
+}
+
+export async function readThreadRequest(
+  deps: ThreadRequestDeps,
+  threadId: string,
+  includeTurns = false,
+): Promise<{ id: string; status: RuntimeThreadStatus | null; turns: any[] | null }> {
+  const result = await deps.request('thread/read', { threadId, includeTurns });
+  const resolvedThreadId = result?.thread?.id || threadId;
+  const status = deps.cacheThreadStatus(resolvedThreadId, normalizeThreadStatus(result?.thread?.status));
+  if (resolvedThreadId !== threadId && status) {
+    deps.cacheThreadStatus(threadId, status);
+  }
+  const turns = includeTurns && Array.isArray(result?.thread?.turns) ? result.thread.turns : null;
+  return { id: resolvedThreadId, status, turns };
+}
+
+export async function readThreadStatusRequest(
+  deps: ThreadStatusReadDeps,
+  threadId: string,
+): Promise<RuntimeThreadStatus | null> {
+  try {
+    const { status } = await readThreadRequest(deps, threadId, false);
+    return status || deps.cachedThreadStatus(threadId);
+  } catch (error) {
+    logWarn('runtime', 'thread_read_failed', {
+      threadId,
+      error: error instanceof Error ? (error.stack || error.message) : String(error),
+    });
+    return deps.cachedThreadStatus(threadId);
+  }
+}
+
+export async function interruptTurnRequest(request: RequestLike, threadId: string, turnId: string): Promise<void> {
+  await request('turn/interrupt', { threadId, turnId });
+}
+
+export async function steerTurnRequest(
+  deps: SteerTurnDeps,
+  threadId: string,
+  turnId: string,
+  prompt: string,
+): Promise<void> {
+  await deps.connect();
+  logInfo('runtime', 'turn_steering', {
+    threadId,
+    turnId,
+  });
+  try {
+    await deps.request('turn/steer', {
+      threadId,
+      turnId,
+      expectedTurnId: turnId,
+      input: [{ type: 'text', text: prompt, text_elements: [] }],
+    });
+  } catch (error) {
+    if (deps.isRecoverableRuntimeError(error)) {
+      const message = error instanceof Error ? error.message : String(error);
+      deps.scheduleReconnect(message);
+    }
+    throw error;
+  }
+}
+
+export async function recoverTurnResultRequest(
+  deps: RecoverTurnResultDeps,
+  threadId: string,
+  turnId: string,
+  options: { timeoutMs?: number; pollMs?: number } = {},
+): Promise<RuntimeTurnResult | null> {
+  const timeoutMs = Number.isFinite(options.timeoutMs) ? Number(options.timeoutMs) : TURN_RESULT_RECOVERY_TIMEOUT_MS;
+  const pollMs = Number.isFinite(options.pollMs) ? Math.max(1, Number(options.pollMs)) : 1000;
+  const deadline = Date.now() + timeoutMs;
+  let lastError: Error | null = null;
+
+  while (Date.now() <= deadline) {
+    try {
+      const recovered = await readTurnResult({
+        request: (method, params) => deps.request(method, params),
+        cacheThreadStatus: (currentThreadId, status) => deps.cacheThreadStatus(currentThreadId, status),
+        buildReplyFromThreadItems: (items) => buildReplyFromThreadItems(items),
+        readPersistedFinalReply: (currentTurnId) => deps.readPersistedFinalReply(currentTurnId),
+      }, threadId, turnId);
+      if (recovered && recovered.status !== 'inProgress') {
+        deps.cacheThreadStatus(recovered.threadId, { type: 'idle', activeFlags: [] });
+        return recovered;
+      }
+    } catch (error) {
+      lastError = normalizeRuntimeError(error);
+    }
+    await sleep(pollMs);
+  }
+
+  logWarn('runtime', 'turn_recovery_unavailable', {
+    threadId,
+    turnId,
+    error: lastError ? (lastError.stack || lastError.message) : null,
+  });
+  return null;
+}
+
+export function resolveApprovalRequest(sendRaw: SendRawLike, requestId: string | number, decision: ApprovalDecision): void {
+  sendRaw({
+    jsonrpc: '2.0',
+    id: requestId,
+    result: { decision },
+  });
+}
+
+export function resolveUserInputRequest(
+  sendRaw: SendRawLike,
+  requestId: string | number,
+  response: { answers: Record<string, { answers: string[] }> },
+): void {
+  sendRaw({
+    jsonrpc: '2.0',
+    id: requestId,
+    result: response,
+  });
+}
+
+export function resolveElicitationRequest(
+  sendRaw: SendRawLike,
+  requestId: string | number,
+  response: { action: 'accept' | 'decline' | 'cancel'; content: unknown | null },
+): void {
+  sendRaw({
+    jsonrpc: '2.0',
+    id: requestId,
+    result: response,
+  });
+}