mcp-codex-worker 0.1.1 → 0.1.3

package/src/services/app-server-client.ts

@@ -352,6 +352,12 @@ export class AppServerClient extends EventEmitter {
     }));
   }
 
+  listOperationsForThread(threadId: string): RuntimeOperation[] {
+    return [...this.operations.values()]
+      .filter((op) => op.threadId === threadId)
+      .map((op) => ({ ...op, pendingRequestIds: [...op.pendingRequestIds] }));
+  }
+
   listServerRequests(includeResolved = false): PendingServerRequest[] {
     return [...this.serverRequests.values()]
       .filter((request) => includeResolved || request.status === 'pending')
@@ -574,8 +580,7 @@ export class AppServerClient extends EventEmitter {
     }
 
     if (notification.method === 'error') {
-      const params = asObject(notification.params);
-      const message = typeof params?.message === 'string' ? params.message : 'Codex reported an error.';
+      const message = this.extractErrorNotificationMessage(notification.params);
       for (const operation of this.operations.values()) {
         if (operation.status === 'running' && operation.threadId === threadId && TURN_LIFECYCLE_METHODS.has(operation.method)) {
           operation.status = 'failed';
@@ -586,6 +591,55 @@ export class AppServerClient extends EventEmitter {
     }
   }
 
+  /**
+   * Pulls a human-readable message out of an `error` notification.
+   *
+   * The Codex app-server emits `ErrorNotification` with shape
+   * `{ error: { message, codexErrorInfo, additionalDetails }, willRetry, threadId, turnId }`
+   * (see src/protocol/v2/ErrorNotification.ts). We surface the nested message and
+   * append the `codexErrorInfo` tag so downstream classifiers in
+   * `codex-runtime.ts` (isAuthSignal / isRateLimitSignal) can match on keywords
+   * like `unauthorized` or `usageLimitExceeded` to drive profile failover.
+   */
+  private extractErrorNotificationMessage(params: unknown): string {
+    const paramsObject = asObject(params);
+    const errorObject = asObject(paramsObject?.error);
+    const nestedMessage = typeof errorObject?.message === 'string'
+      ? errorObject.message
+      : undefined;
+    const flatMessage = typeof paramsObject?.message === 'string'
+      ? paramsObject.message
+      : undefined;
+    const rawMessage = nestedMessage ?? flatMessage;
+
+    const codexErrorInfo = this.normalizeCodexErrorInfo(errorObject?.codexErrorInfo);
+
+    if (rawMessage && codexErrorInfo) {
+      return `${rawMessage} [${codexErrorInfo}]`;
+    }
+    if (rawMessage) {
+      return rawMessage;
+    }
+    if (codexErrorInfo) {
+      return `Codex reported an error: ${codexErrorInfo}`;
+    }
+    return 'Codex reported an error.';
+  }
+
+  private normalizeCodexErrorInfo(value: unknown): string | undefined {
+    if (typeof value === 'string') {
+      return value;
+    }
+    const object = asObject(value);
+    if (object) {
+      const [key] = Object.keys(object);
+      if (key) {
+        return key;
+      }
+    }
+    return undefined;
+  }
+
   private extractThreadIdFromParams(params: unknown): string | undefined {
     const object = asObject(params);
     const threadId = object?.threadId;

package/src/services/codex-runtime.ts

@@ -8,7 +8,7 @@ import {
   CODEX_APP_SERVER_COMMAND_ENV,
   REQUEST_TIMEOUT_MS,
 } from '../config/defaults.js';
-import type { PendingServerRequest } from '../types/codex.js';
+import type { PendingServerRequest, RuntimeOperation } from '../types/codex.js';
 import { AppServerClient, type BridgedOperationResult } from './app-server-client.js';
 import { appendFleetDeveloperInstructions } from './fleet-mode.js';
 import {
@@ -366,6 +366,22 @@ export class CodexRuntime {
     };
   }
 
+  getOperationsForThread(threadId: string): RuntimeOperation[] {
+    try {
+      return this.getCurrentClient().listOperationsForThread(threadId);
+    } catch {
+      return [];
+    }
+  }
+
+  getAllOperations(): RuntimeOperation[] {
+    try {
+      return this.getCurrentClient().listOperations();
+    } catch {
+      return [];
+    }
+  }
+
   async getThreadEvents(threadId: string): Promise<unknown[]> {
     return this.getCurrentClient().getThreadEvents(threadId);
   }