@cloudcli-ai/cloudcli 1.37.1 → 1.37.3

package/server/modules/providers/list/codex/codex-app-server.client.ts

@@ -0,0 +1,243 @@
+import { spawn } from 'node:child_process';
+import { stat } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import readline from 'node:readline';
+
+import { AppError } from '@/shared/utils.js';
+
+/**
+ * Minimal JSON-RPC client for `codex app-server`.
+ *
+ * Codex ships two entry points and they expose different things. The
+ * `@openai/codex-sdk` this app runs conversations through is a wrapper around
+ * `codex exec`, and its whole surface is `startThread` and `resumeThread` —
+ * there is no way to branch a thread or to resume one partway. The same
+ * binary's `app-server` subcommand speaks JSON-RPC and does have that
+ * primitive, `thread/fork`, which is what the Codex IDE clients build their
+ * own "fork" and "edit an earlier message" on top of.
+ *
+ * So this is a second transport to the same CLI, opened only for the
+ * operations the SDK cannot express. Everything else still goes through the
+ * SDK.
+ */
+
+/** How long a single request may take before the child is killed. */
+const REQUEST_TIMEOUT_MS = 30_000;
+
+type JsonRpcResponse = {
+  id?: number;
+  result?: unknown;
+  error?: { code?: number; message?: string };
+};
+
+/**
+ * One fork of a Codex thread.
+ *
+ * `path` is returned by the server rather than reconstructed: the rollout
+ * lands in today's date directory, not next to the file it was copied from,
+ * so deriving it from the source path would be wrong roughly every day.
+ */
+export type CodexThreadFork = {
+  threadId: string;
+  path: string;
+};
+
+/**
+ * Resolves the `codex` launcher shipped in node_modules.
+ *
+ * Deliberately not the `codex` on PATH: a machine can have a second, older
+ * install, and the protocol this speaks is only guaranteed against the
+ * version this package depends on.
+ */
+function resolveCodexLauncher(): string {
+  const require_ = createRequire(import.meta.url);
+  try {
+    return require_.resolve('@openai/codex/bin/codex.js');
+  } catch {
+    throw new AppError('The Codex CLI package is not installed, so Codex conversations cannot be branched.', {
+      code: 'CODEX_APP_SERVER_UNAVAILABLE',
+      statusCode: 501,
+    });
+  }
+}
+
+/**
+ * Runs one exchange against a freshly spawned `codex app-server`.
+ *
+ * A process per operation rather than a pooled long-lived one: the handshake
+ * costs a fraction of a second, forking happens at most once per user action,
+ * and a shared child would need lifecycle handling — restarts, back-pressure,
+ * a crash taking every pending fork with it — for no measurable gain next to
+ * the model turn that follows.
+ */
+async function withAppServer<T>(
+  run: (call: (method: string, params: unknown) => Promise<unknown>) => Promise<T>,
+): Promise<T> {
+  const launcher = resolveCodexLauncher();
+  const child = spawn(process.execPath, [launcher, 'app-server'], {
+    env: process.env,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+
+  // The server logs sandbox and skill warnings to stderr on every start. They
+  // are not failures and drowning the app log in them helps nobody, so stderr
+  // is only kept around to explain a spawn that dies.
+  let stderr = '';
+  child.stderr?.on('data', (chunk) => {
+    stderr = (stderr + String(chunk)).slice(-2000);
+  });
+
+  let nextRequestId = 1;
+  const pending = new Map<number, (response: JsonRpcResponse) => void>();
+  let exitReason: string | null = null;
+
+  const reader = readline.createInterface({ input: child.stdout });
+  reader.on('line', (line) => {
+    if (!line.trim()) {
+      return;
+    }
+    let message: JsonRpcResponse;
+    try {
+      message = JSON.parse(line) as JsonRpcResponse;
+    } catch {
+      // Server-to-client notifications and any non-JSON banner are not
+      // replies to anything this client asked for.
+      return;
+    }
+    if (typeof message.id !== 'number') {
+      return;
+    }
+    pending.get(message.id)?.(message);
+    pending.delete(message.id);
+  });
+
+  const failPending = (reason: string) => {
+    exitReason = reason;
+    for (const resolve of pending.values()) {
+      resolve({ error: { message: reason } });
+    }
+    pending.clear();
+  };
+
+  child.on('error', (error) => failPending(error.message));
+  child.on('exit', (code, signal) => {
+    failPending(`codex app-server exited (code ${code ?? 'null'}, signal ${signal ?? 'null'})`);
+  });
+  // A child that dies mid-request leaves its pipes broken, and the next write
+  // raises EPIPE on the stream rather than at the call site. Without a
+  // listener that is an unhandled 'error' event, which takes the whole server
+  // down over one failed fork.
+  child.stdin?.on('error', (error) => failPending(error.message));
+  child.stdout?.on('error', (error) => failPending(error.message));
+  child.stderr?.on('error', () => {});
+
+  const call = (method: string, params: unknown): Promise<unknown> =>
+    new Promise((resolve, reject) => {
+      if (exitReason) {
+        reject(new AppError(`Codex app-server is not running: ${exitReason}`, {
+          code: 'CODEX_APP_SERVER_UNAVAILABLE',
+          statusCode: 502,
+        }));
+        return;
+      }
+
+      const id = nextRequestId++;
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        reject(new AppError(`Codex app-server did not answer "${method}" within ${REQUEST_TIMEOUT_MS}ms.`, {
+          code: 'CODEX_APP_SERVER_TIMEOUT',
+          statusCode: 504,
+        }));
+      }, REQUEST_TIMEOUT_MS);
+
+      pending.set(id, (response) => {
+        clearTimeout(timer);
+        if (response.error) {
+          reject(new AppError(response.error.message || `Codex app-server rejected "${method}".`, {
+            code: 'CODEX_APP_SERVER_ERROR',
+            statusCode: 502,
+            details: { method, rpcCode: response.error.code },
+          }));
+          return;
+        }
+        resolve(response.result);
+      });
+
+      child.stdin?.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
+    });
+
+  try {
+    // `capabilities` is deliberately empty. `thread/fork` with `lastTurnId` is
+    // in the stable protocol; only `beforeTurnId` and the turn-listing methods
+    // are gated behind `experimentalApi`, and neither is needed here.
+    await call('initialize', {
+      clientInfo: { name: 'cloudcli', title: 'CloudCLI', version: '1' },
+      capabilities: {},
+    });
+    child.stdin?.write(`${JSON.stringify({ jsonrpc: '2.0', method: 'initialized', params: {} })}\n`);
+
+    return await run(call);
+  } catch (error) {
+    if (error instanceof AppError && exitReason) {
+      throw new AppError(`${error.message}${stderr ? ` — ${stderr.trim().split('\n').slice(-1)[0]}` : ''}`, {
+        code: error.code,
+        statusCode: error.statusCode,
+      });
+    }
+    throw error;
+  } finally {
+    reader.close();
+    child.kill();
+  }
+}
+
+export const codexAppServer = {
+  /**
+   * Copies a thread into a new one that ends at `lastTurnId`, or copies the
+   * whole thread when it is omitted.
+   *
+   * `lastTurnId` is inclusive of the turn it names, which is the same
+   * convention the app's edit anchor uses ("the last row to keep").
+   *
+   * `cwd` decides the working directory recorded in the copy's `session_meta`,
+   * and that field is what the session indexer keys a session's project off —
+   * omitting it would file every fork under whatever directory this server
+   * happens to be running from.
+   */
+  async forkThread(input: {
+    threadId: string;
+    lastTurnId?: string;
+    cwd: string;
+  }): Promise<CodexThreadFork> {
+    return withAppServer(async (call) => {
+      const result = await call('thread/fork', {
+        threadId: input.threadId,
+        ...(input.lastTurnId ? { lastTurnId: input.lastTurnId } : {}),
+        ...(input.cwd ? { cwd: input.cwd } : {}),
+      }) as { thread?: { id?: unknown; path?: unknown } } | undefined;
+
+      const threadId = typeof result?.thread?.id === 'string' ? result.thread.id : '';
+      const path = typeof result?.thread?.path === 'string' ? result.thread.path : '';
+      if (!threadId || !path) {
+        throw new AppError('Codex reported a fork without a thread id or transcript path.', {
+          code: 'FORK_FAILED',
+          statusCode: 502,
+        });
+      }
+
+      // Confirmed rather than trusted: both callers are about to point a
+      // database row at this file, and a row naming a transcript that is not
+      // there is a session that can never be opened.
+      try {
+        await stat(path);
+      } catch {
+        throw new AppError('Codex reported a fork but wrote no transcript for it.', {
+          code: 'FORK_FAILED',
+          statusCode: 502,
+        });
+      }
+
+      return { threadId, path };
+    });
+  },
+};

package/server/modules/providers/list/codex/codex-fork.provider.ts

@@ -0,0 +1,40 @@
+import { codexAppServer } from '@/modules/providers/list/codex/codex-app-server.client.js';
+import type { IProviderFork } from '@/shared/interfaces.js';
+
+/**
+ * Branches a Codex conversation into an independent thread.
+ *
+ * `thread/fork` writes a real rollout with its own thread id and a
+ * `forked_from_id` back-reference, which is what makes the copy resumable
+ * rather than an inert duplicate of the file.
+ *
+ * One difference from the Claude fork worth knowing about: Codex's unit is a
+ * turn, not a row. `upToAnchorId` names the turn a user message belongs to and
+ * the cut is inclusive of it, so forking from a message keeps that message
+ * *and the answer it got*. Claude's `upToMessageId` can stop at the prompt
+ * itself. There is no way to express the finer cut here — a turn is written as
+ * one thing — and the coarser one is the more useful of the two anyway.
+ */
+export class CodexForkProvider implements IProviderFork {
+  async forkSession(input: {
+    providerSessionId: string;
+    jsonlPath: string;
+    projectPath: string;
+    upToAnchorId?: string;
+    title?: string;
+  }): Promise<{ providerSessionId: string; jsonlPath: string }> {
+    // `title` is deliberately not forwarded. The sidebar name lives in this
+    // app's own session row, and naming the thread inside Codex would mean a
+    // second call that could fail after the fork already succeeded.
+    const fork = await codexAppServer.forkThread({
+      threadId: input.providerSessionId,
+      lastTurnId: input.upToAnchorId,
+      cwd: input.projectPath,
+    });
+
+    // The path is the one the server reported and already confirmed on disk,
+    // not one derived from the source: a fork lands in today's date directory
+    // rather than beside the transcript it was copied from.
+    return { providerSessionId: fork.threadId, jsonlPath: fork.path };
+  }
+}

package/server/modules/providers/list/codex/codex-models.provider.ts

@@ -18,6 +18,22 @@ import {
 /** Curated Codex catalog shipped as immutable CloudCLI defaults. */
 export const CODEX_PREDEFINED_MODELS: ProviderModelsDefinition = {
   OPTIONS: [
+    {
+      value: 'gpt-6-astra',
+      label: 'GPT-6 Astra',
+      description: 'Our most capable model for complex, demanding work.',
+      effort: {
+        default: 'low',
+        values: [
+          { value: 'low' },
+          { value: 'medium' },
+          { value: 'high' },
+          { value: 'xhigh' },
+          { value: 'max' },
+          { value: 'ultra' },
+        ],
+      },
+    },
     {
       value: 'gpt-5.6-sol',
       label: 'GPT-5.6 Sol',

package/server/modules/providers/list/codex/{codex-runtime.provider.js → codex-runtime.provider.ts}

@@ -8,29 +8,44 @@
  * ## Usage
  *
  * - codexRuntime.run(command, options, writer, context) - Execute a streamed prompt
- * - abortCodexSession(sessionId) - Cancel an active session
- * - isCodexSessionActive(sessionId) - Check if a session is running
- * - getActiveCodexSessions() - List all active sessions
+ * - codexRuntime.abort(sessionId) - Cancel an active session
  */
 
 import { Codex } from '@openai/codex-sdk';
+import type { ModelReasoningEffort, Thread, ThreadOptions } from '@openai/codex-sdk';
 
 import {
   appendFilesInputTag,
   buildCodexInputItems,
-  normalizeImageDescriptors
-} from '@/shared/image-attachments.js';
+  normalizeImageDescriptors,
+  createCompleteMessage,
+  createNormalizedMessage,
+} from '@/shared/index.js';
 import { notifyRunFailed, notifyRunStopped } from '@/modules/notifications/index.js';
-import { createCompleteMessage, createNormalizedMessage } from '@/shared/utils.js';
+import type { AnyRecord, ProviderRuntimeContext, ProviderRuntimeWriter } from '@/shared/index.js';
+
+type ActiveCodexSession = {
+  thread: Thread;
+  codex: Codex;
+  status: 'running' | 'aborted' | 'completed';
+  abortController: AbortController;
+  startedAt: string;
+};
+
+const activeCodexSessions = new Map<string, ActiveCodexSession>();
 
-const activeCodexSessions = new Map();
+/**
+ * Item types whose in-flight updates are worth showing. These are the ones a
+ * user waits on — a shell command's output, an MCP call, and the running plan.
+ */
+const PROGRESSIVE_CODEX_ITEM_TYPES = new Set(['command_execution', 'mcp_tool_call', 'todo_list']);
 
-function readUsageNumber(value) {
+function readUsageNumber(value: unknown) {
   const parsed = Number(value);
   return Number.isFinite(parsed) ? parsed : 0;
 }
 
-function extractCodexTokenBudget(event) {
+function extractCodexTokenBudget(event: AnyRecord) {
   const info = event?.info || event?.payload?.info || event?.usage?.info;
   const usage = info?.total_token_usage || event?.usage?.total_token_usage || event?.usage;
   if (!usage || typeof usage !== 'object') {
@@ -58,7 +73,7 @@ function extractCodexTokenBudget(event) {
  * @param {object} event - SDK event
  * @returns {object} - Transformed event for WebSocket
  */
-function transformCodexEvent(event) {
+function transformCodexEvent(event: AnyRecord): AnyRecord {
   // Map SDK event types to a consistent format
   switch (event.type) {
     case 'item.started':
@@ -69,12 +84,16 @@ function transformCodexEvent(event) {
         return { type: event.type, item: null };
       }
 
-      // Transform based on item type
+      // `itemId` is the SDK's stable per-item id. Carrying it through means an
+      // in-progress row and its later completion normalize to the same message
+      // id, so the client updates one transcript entry instead of appending a
+      // new one for every progress tick.
       switch (item.type) {
         case 'agent_message':
           return {
             type: 'item',
             itemType: 'agent_message',
+            itemId: item.id,
             message: {
               role: 'assistant',
               content: item.text
@@ -85,6 +104,7 @@ function transformCodexEvent(event) {
           return {
             type: 'item',
             itemType: 'reasoning',
+            itemId: item.id,
             message: {
               role: 'assistant',
               content: item.text,
@@ -96,6 +116,7 @@ function transformCodexEvent(event) {
           return {
             type: 'item',
             itemType: 'command_execution',
+            itemId: item.id,
             command: item.command,
             output: item.aggregated_output,
             exitCode: item.exit_code,
@@ -106,6 +127,7 @@ function transformCodexEvent(event) {
           return {
             type: 'item',
             itemType: 'file_change',
+            itemId: item.id,
             changes: item.changes,
             status: item.status
           };
@@ -114,6 +136,7 @@ function transformCodexEvent(event) {
           return {
             type: 'item',
             itemType: 'mcp_tool_call',
+            itemId: item.id,
             server: item.server,
             tool: item.tool,
             arguments: item.arguments,
@@ -126,6 +149,7 @@ function transformCodexEvent(event) {
           return {
             type: 'item',
             itemType: 'web_search',
+            itemId: item.id,
             query: item.query
           };
 
@@ -133,6 +157,7 @@ function transformCodexEvent(event) {
           return {
             type: 'item',
             itemType: 'todo_list',
+            itemId: item.id,
             items: item.items
           };
 
@@ -140,6 +165,7 @@ function transformCodexEvent(event) {
           return {
             type: 'item',
             itemType: 'error',
+            itemId: item.id,
             message: {
               role: 'error',
               content: item.message
@@ -150,6 +176,7 @@ function transformCodexEvent(event) {
           return {
             type: 'item',
             itemType: item.type,
+            itemId: item.id,
             item: item
           };
       }
@@ -196,7 +223,7 @@ function transformCodexEvent(event) {
  * @param {string} permissionMode - 'default', 'acceptEdits', or 'bypassPermissions'
  * @returns {object} - { sandboxMode, approvalPolicy }
  */
-function mapPermissionModeToCodexOptions(permissionMode) {
+function mapPermissionModeToCodexOptions(permissionMode: string): Pick<ThreadOptions, 'sandboxMode' | 'approvalPolicy'> {
   switch (permissionMode) {
     case 'acceptEdits':
       return {
@@ -212,7 +239,9 @@ function mapPermissionModeToCodexOptions(permissionMode) {
     default:
       return {
         sandboxMode: 'workspace-write',
-        approvalPolicy: 'untrusted'
+        // Current Codex CLI versions reject the retired `untrusted` policy.
+        // Keep sandboxing enabled; exec cannot grant interactive approval requests.
+        approvalPolicy: 'on-request'
       };
   }
 }
@@ -223,7 +252,12 @@ function mapPermissionModeToCodexOptions(permissionMode) {
  * @param {object} options - Options including cwd, sessionId, model, permissionMode
  * @param {WebSocket|object} ws - WebSocket connection or response writer
  */
-export async function queryCodex(command, options = {}, ws, context) {
+async function queryCodex(
+  command: string,
+  options: AnyRecord = {},
+  ws: ProviderRuntimeWriter,
+  context: ProviderRuntimeContext,
+) {
   const {
     sessionId,
     sessionSummary,
@@ -248,16 +282,22 @@ export async function queryCodex(command, options = {}, ws, context) {
   const selectedModel = catalog.OPTIONS.find((option) => option.value === resolvedModel) || null;
   const allowedEfforts = selectedModel?.effort?.values?.map((value) => value.value) || [];
   const resolvedEffort = typeof effort === 'string' && effort !== 'default' && allowedEfforts.includes(effort)
-    ? effort
+    ? effort as ModelReasoningEffort
     : undefined;
 
-  let codex;
-  let thread;
+  let codex: Codex;
+  let thread: Thread;
   // Provider-native thread id (starts as the resume id, or is captured from
   // the stream for brand-new sessions).
   let capturedSessionId = providerSessionId;
   let sessionCreatedSent = false;
-  let terminalFailure = null;
+  let terminalFailure: { message: string } | null = null;
+  // Codex surfaces API failures as streamed error items/turn.failed events, and
+  // then the SDK also throws "Codex Exec exited with code N: <stderr>" once the
+  // process dies. Showing both means the rendered error is followed by a raw
+  // stderr dump of unrelated CLI log lines, so the thrown wrapper is dropped
+  // when the stream already reported the failure.
+  let errorSurfaced = false;
   const abortController = new AbortController();
   // Session-map key: the app session id when the caller supplied one, else
   // the provider-native thread id once captured (legacy/direct API callers).
@@ -266,7 +306,7 @@ export async function queryCodex(command, options = {}, ws, context) {
   try {
     codex = new Codex();
 
-    const threadOptions = {
+    const threadOptions: ThreadOptions = {
       workingDirectory,
       skipGitRepoCheck: true,
       sandboxMode,
@@ -281,7 +321,7 @@ export async function queryCodex(command, options = {}, ws, context) {
       thread = codex.startThread(threadOptions);
     }
 
-    const registerSession = (id) => {
+    const registerSession = (id: string | null) => {
       if (!id) {
         return;
       }
@@ -311,7 +351,7 @@ export async function queryCodex(command, options = {}, ws, context) {
     for await (const event of streamedTurn.events) {
       // Capture thread/session id lazily from the stream (Codex emits this asynchronously).
       if (event.type === 'thread.started') {
-        const discoveredSessionId = event.thread_id || event.id || null;
+        const discoveredSessionId = event.thread_id || null;
         if (discoveredSessionId && !capturedSessionId) {
           capturedSessionId = discoveredSessionId;
           registerSession(sessionKey());
@@ -332,17 +372,29 @@ export async function queryCodex(command, options = {}, ws, context) {
         break;
       }
       if (sessionKey()) {
-        const session = activeCodexSessions.get(sessionKey());
+        const session = activeCodexSessions.get(sessionKey() || '');
         if (session?.status === 'aborted') {
           break;
         }
       }
 
-      if (event.type === 'item.started' || event.type === 'item.updated') {
+      // Progress events used to be dropped, so a long shell command or a
+      // growing plan showed nothing until it finished. They are forwarded now;
+      // every item carries a stable id, so the client replaces the row it
+      // already has rather than stacking a new one per tick. Text items are
+      // still skipped mid-flight because assistant prose arrives through the
+      // separate streaming path.
+      if (
+        (event.type === 'item.started' || event.type === 'item.updated')
+        && !PROGRESSIVE_CODEX_ITEM_TYPES.has(event.item?.type)
+      ) {
         continue;
       }
 
       const transformed = transformCodexEvent(event);
+      if (transformed.type === 'error' || transformed.itemType === 'error') {
+        errorSurfaced = true;
+      }
 
       // Normalize the transformed event into NormalizedMessage(s) via adapter
       const normalizedMsgs = context.normalizeMessage(transformed, capturedSessionId || sessionId || null);
@@ -352,6 +404,7 @@ export async function queryCodex(command, options = {}, ws, context) {
 
       if (event.type === 'turn.failed' && !terminalFailure) {
         terminalFailure = event.error || new Error('Turn failed');
+        errorSurfaced = true;
         // Notifications are app-facing, so they carry the app session id.
         notifyRunFailed({
           userId: ws?.userId || null,
@@ -373,7 +426,7 @@ export async function queryCodex(command, options = {}, ws, context) {
 
     // Send the terminal completion event — skipped for aborted runs, whose
     // terminal `complete` (aborted: true) was already sent by abort-session.
-    const runSession = sessionKey() ? activeCodexSessions.get(sessionKey()) : null;
+    const runSession = activeCodexSessions.get(sessionKey() || '');
     const runAborted = runSession?.status === 'aborted' || abortController.signal.aborted;
     if (!runAborted) {
       sendMessage(ws, createCompleteMessage({
@@ -394,22 +447,25 @@ export async function queryCodex(command, options = {}, ws, context) {
     }
 
   } catch (error) {
-    const session = sessionKey() ? activeCodexSessions.get(sessionKey()) : null;
+    const session = activeCodexSessions.get(sessionKey() || '');
+    const runError = error instanceof Error ? error : new Error(String(error));
     const wasAborted =
       session?.status === 'aborted' ||
-      error?.name === 'AbortError' ||
-      String(error?.message || '').toLowerCase().includes('aborted');
+      runError.name === 'AbortError' ||
+      runError.message.toLowerCase().includes('aborted');
 
     if (!wasAborted) {
       console.error('[Codex] Error:', error);
 
-      // Check if Codex SDK is available for a clearer error message
-      const installed = await context.isProviderInstalled();
-      const errorContent = !installed
-        ? 'Codex CLI is not configured. Please set up authentication first.'
-        : error.message;
+      if (!errorSurfaced) {
+        // Check if Codex SDK is available for a clearer error message
+        const installed = await context.isProviderInstalled();
+        const errorContent = !installed
+          ? 'Codex CLI is not configured. Please set up authentication first.'
+          : runError.message;
 
-      sendMessage(ws, createNormalizedMessage({ kind: 'error', content: errorContent, sessionId: capturedSessionId || sessionId || null, provider: 'codex' }));
+        sendMessage(ws, createNormalizedMessage({ kind: 'error', content: errorContent, sessionId: capturedSessionId || sessionId || null, provider: 'codex' }));
+      }
       sendMessage(ws, createCompleteMessage({
         provider: 'codex',
         sessionId: capturedSessionId || sessionId || null,
@@ -429,7 +485,7 @@ export async function queryCodex(command, options = {}, ws, context) {
   } finally {
     // Update session status
     if (sessionKey()) {
-      const session = activeCodexSessions.get(sessionKey());
+      const session = activeCodexSessions.get(sessionKey() || '');
       if (session) {
         session.status = session.status === 'aborted' ? 'aborted' : 'completed';
       }
@@ -442,7 +498,7 @@ export async function queryCodex(command, options = {}, ws, context) {
  * @param {string} sessionId - Session ID to abort
  * @returns {boolean} - Whether abort was successful
  */
-export function abortCodexSession(sessionId) {
+function abortCodexSession(sessionId: string) {
   const session = activeCodexSessions.get(sessionId);
 
   if (!session) {
@@ -459,36 +515,7 @@ export function abortCodexSession(sessionId) {
   return true;
 }
 
-/**
- * Check if a session is active
- * @param {string} sessionId - Session ID to check
- * @returns {boolean} - Whether session is active
- */
-export function isCodexSessionActive(sessionId) {
-  const session = activeCodexSessions.get(sessionId);
-  return session?.status === 'running';
-}
-
-/**
- * Get all active sessions
- * @returns {Array} - Array of active session info
- */
-export function getActiveCodexSessions() {
-  const sessions = [];
-
-  for (const [id, session] of activeCodexSessions.entries()) {
-    if (session.status === 'running') {
-      sessions.push({
-        id,
-        status: session.status,
-        startedAt: session.startedAt
-      });
-    }
-  }
-
-  return sessions;
-}
-
+/** Used by the providers module's CodexProvider to run and abort SDK turns. */
 export const codexRuntime = {
   run: queryCodex,
   abort: abortCodexSession,
@@ -499,7 +526,7 @@ export const codexRuntime = {
  * @param {WebSocket|object} ws - WebSocket or response writer
  * @param {object} data - Data to send
  */
-function sendMessage(ws, data) {
+function sendMessage(ws: ProviderRuntimeWriter, data: unknown) {
   try {
     if (ws.isSSEStreamWriter || ws.isWebSocketWriter) {
       // Writer handles stringification (SSEStreamWriter or WebSocketWriter)