@minhspark/codex-mcp-bridge 1.12.0 → 1.12.2

package/src/thread-delivery.mjs

@@ -17,12 +17,17 @@ import { runTurn } from "./turn.mjs";
  */
 export const NATIVE_BACKEND = "codex-desktop-native";
 export const APP_SERVER_BACKEND = "app-server";
+const RELEASE_STATUSES = new Set(["completed", "interrupted", "failed"]);
 
 export function createThreadDelivery({
   codex,
   relay = new NativeDesktopRelay(),
   log = () => {},
   timeoutMs = 240000,
+  releaseAfterTurn =
+    process.env.CODEX_BRIDGE_RELEASE_AFTER_TURN !== undefined
+      ? process.env.CODEX_BRIDGE_RELEASE_AFTER_TURN === "1"
+      : process.platform === "win32",
 } = {}) {
   let reportedUnavailable = null;
 
@@ -42,7 +47,7 @@ export function createThreadDelivery({
         reportedUnavailable = null;
         return { backend: NATIVE_BACKEND, threadId, ack };
       } catch (err) {
-        if (err.reachedCompanion) throw err;
+        if (err.reachedCompanion || err.code !== "RELAY_UNREACHABLE") throw err;
         log(`native relay unreachable (${err.message}); falling back to the app-server path`);
       }
     } else if (status.reason !== reportedUnavailable) {
@@ -51,13 +56,24 @@ export function createThreadDelivery({
     }
 
     if (!codex) throw new Error("No Codex app-server client is configured to deliver this message");
-    await codex.ensureThreadAttached(threadId);
-    const turn = await runTurn(codex, {
-      threadId,
-      input: [{ type: "text", text }],
-      timeoutMs,
-    });
-    return { backend: APP_SERVER_BACKEND, threadId, turn };
+    const send = async () => {
+      await codex.ensureThreadAttached(threadId);
+      const turn = await runTurn(codex, {
+        threadId,
+        input: [{ type: "text", text }],
+        timeoutMs,
+      });
+      if (releaseAfterTurn && RELEASE_STATUSES.has(turn.status) && typeof codex.releaseThread === "function") {
+        try {
+          const released = await codex.releaseThread(threadId);
+          if (!released?.released) log("thread release pending: " + (released.reason ?? released.status ?? "awaiting unload"));
+        } catch (err) {
+          log("thread release failed: " + err.message);
+        }
+      }
+      return { backend: APP_SERVER_BACKEND, threadId, turn };
+    };
+    return codex.withThread ? codex.withThread(threadId, send) : send();
   }
 
   function describe() {

package/src/turn.mjs

@@ -54,10 +54,16 @@ export async function runTurn(client, { threadId, input, timeoutMs = 240000, tur
   });
 
   const process = (msg) => {
+    if (settled) return;
     const params = msg.params ?? {};
     if (turnId && params.turnId && params.turnId !== turnId) return;
 
     switch (msg.method) {
+      case "thread/closed": {
+        settled = true;
+        resolveDone({ status: "disconnected", error: { message: "The thread closed before its turn completed" } });
+        return;
+      }
       case "item/completed": {
         const summary = summarizeItem(params.item);
         if (!summary) return;
@@ -90,7 +96,7 @@ export async function runTurn(client, { threadId, input, timeoutMs = 240000, tur
   };
 
   const unsubscribe = client.subscribe(threadId, (msg) => {
-    if (!turnId) {
+    if (!turnId && msg.method !== "thread/closed") {
       buffered.push(msg);
       return;
     }
@@ -113,15 +119,27 @@ export async function runTurn(client, { threadId, input, timeoutMs = 240000, tur
   });
 
   try {
-    const started = await client.request(
-      "turn/start",
-      { threadId, input, ...turnOverrides },
-      { timeoutMs: Math.min(timeoutMs, 60000) },
-    );
-    turnId = started?.turn?.id ?? null;
-    for (const msg of buffered.splice(0)) process(msg);
-
-    const outcome = await done;
+    const start = await Promise.race([
+      client.request(
+        "turn/start",
+        { ...turnOverrides, threadId, input },
+        { timeoutMs: Math.min(timeoutMs, 60000) },
+      ).then((started) => ({ started }), (error) => ({ error })),
+      done.then((outcome) => ({ outcome })),
+    ]);
+    if (start.error) throw start.error;
+    let outcome = start.outcome;
+    if (!outcome) {
+      turnId = start.started?.turn?.id ?? null;
+      if (typeof turnId !== "string" || !turnId.trim()) {
+        throw new Error("Codex app-server did not return a turn id for turn/start");
+      }
+      for (const msg of buffered.splice(0)) process(msg);
+      if (TERMINAL_STATUSES.has(start.started?.turn?.status)) {
+        process({ method: "turn/completed", params: { turn: start.started.turn } });
+      }
+      outcome = await done;
+    }
     return {
       threadId,
       turnId,