agentbox-sdk 0.1.602 → 0.1.603

package/dist/agents/index.js

@@ -15,7 +15,7 @@ import {
   parseHarnessCommandInvocation,
   resolveHarnessCommand,
   skillDirective
-} from "../chunk-UE4LQEL5.js";
+} from "../chunk-JO6LTAAD.js";
 import "../chunk-AE2FQ6YU.js";
 import {
   AGENT_RESERVED_PORTS,

package/dist/{chunk-UE4LQEL5.js → chunk-JO6LTAAD.js}

@@ -4991,6 +4991,18 @@ function codexConfigDir(options) {
 var REMOTE_CODEX_APP_SERVER_PORT = 43181;
 var REMOTE_CODEX_APP_SERVER_ID = "shared-app-server";
 var CODEX_APP_SERVER_TOKEN_FILENAME = "codex-app-server-token";
+var MAX_CODEX_RECONNECTS = 3;
+var CODEX_RECONNECT_TIMEOUT_MS = 3e4;
+function missedCodexNotifications(thread, threadId, turnId, seenItemIds) {
+  const active = thread.status?.type === "active";
+  const turn = turnId ? thread.turns?.find((candidate) => candidate.id === turnId) : void 0;
+  if (!turn) return active ? [] : void 0;
+  const ended = turn.status === "completed" || turn.status === "failed";
+  if (!ended && (turn.status !== "inProgress" || !active)) return void 0;
+  const missed = (turn.items ?? []).filter((item) => typeof item.id === "string" && !seenItemIds.has(item.id) && item.status !== "inProgress").map((item) => ({ method: "item/completed", params: { threadId, turnId, item } }));
+  if (ended) missed.push({ method: "turn/completed", params: { threadId, turn: { ...turn, items: [] } } });
+  return missed;
+}
 function defaultRemoteCodexTokenPath() {
   return path10.posix.join(
     agentboxRoot(AgentProvider.Codex, true),
@@ -5821,25 +5833,28 @@ async function createRuntime(request, inputParts) {
       () => sandbox.getPreviewLink(REMOTE_CODEX_APP_SERVER_PORT)
     );
     const token = await getCodexAppServerToken(sandbox);
-    const transport = await connectRemoteCodexAppServer(
-      toRemoteCodexWebSocketUrl(previewUrl),
-      withCodexAppServerAuthHeaders(sandbox.previewHeaders, token)
-    );
-    debugCodex("\u2605 codex transport established");
-    return {
-      source: transport.source,
-      writeLine: transport.send,
-      cleanup: async () => {
-        await transport?.close().catch(() => void 0);
-      },
-      raw: {
-        transport: transport.raw,
-        previewUrl,
-        port: REMOTE_CODEX_APP_SERVER_PORT,
-        codexDir
-      },
-      inputItems
+    const connect = async () => {
+      const transport = await connectRemoteCodexAppServer(
+        toRemoteCodexWebSocketUrl(previewUrl),
+        withCodexAppServerAuthHeaders(sandbox.previewHeaders, token)
+      );
+      return {
+        source: transport.source,
+        writeLine: transport.send,
+        cleanup: async () => {
+          await transport.close().catch(() => void 0);
+        },
+        raw: {
+          transport: transport.raw,
+          previewUrl,
+          port: REMOTE_CODEX_APP_SERVER_PORT,
+          codexDir
+        }
+      };
     };
+    const connection = await connect();
+    debugCodex("\u2605 codex transport established");
+    return { ...connection, reconnect: connect, inputItems };
   }
   const binary = options.provider?.binary ?? "codex";
   if (options.sandbox) {
@@ -6006,7 +6021,7 @@ var CodexAgentAdapter = class {
         runId: request.runId
       })
     );
-    const client = runtime.client ?? new JsonRpcLineClient(
+    let client = runtime.client ?? new JsonRpcLineClient(
       runtime.source,
       runtime.writeLine
     );
@@ -6064,6 +6079,8 @@ var CodexAgentAdapter = class {
     const pendingFileChanges = /* @__PURE__ */ new Map();
     const fileItemKey = (params, itemId) => typeof params?.threadId === "string" && typeof params.turnId === "string" && typeof itemId === "string" ? `${params.threadId}:${params.turnId}:${itemId}` : void 0;
     let streamedText = "";
+    const completedItemIds = /* @__PURE__ */ new Set();
+    const replayedItemIds = /* @__PURE__ */ new Set();
     const timeoutMs = resolveBackgroundTaskTimeoutMs(request.options.backgroundTaskTimeoutMs);
     const isRootThread = (params) => !params?.threadId || params.threadId === rootThreadId;
     let goalStatus = request.run.goal ? "active" : void 0;
@@ -6100,29 +6117,82 @@ var CodexAgentAdapter = class {
       };
       void (async () => {
         let firstClientMessageLogged = false;
-        const iterator = client.messages()[Symbol.asyncIterator]();
-        for (let next = iterator.next(); ; next = iterator.next()) {
-          let step;
+        let iterator = client.messages()[Symbol.asyncIterator]();
+        let next;
+        const replay = [];
+        let reconnects = 0;
+        const reconnect = async (cause) => {
+          if (!runtime.reconnect || abortInvoked || !rootThreadId || reconnects >= MAX_CODEX_RECONNECTS) return false;
+          reconnects++;
+          debugCodex("\u2605 transport lost (%o); reconnecting (attempt %d)", cause, reconnects);
+          let connection;
           try {
-            step = pendingWait ? await Promise.race([
-              next.then((result) => ({ result })),
-              pendingWait.expired.then((reason) => ({ reason }))
-            ]) : { result: await next };
+            connection = await runtime.reconnect();
+            const nextClient = new JsonRpcLineClient(connection.source, connection.writeLine);
+            const resumed = await withTimeout((async () => {
+              await initializeCodexClient(nextClient);
+              return nextClient.request("thread/resume", { threadId: rootThreadId });
+            })(), CODEX_RECONNECT_TIMEOUT_MS);
+            const missed = resumed?.thread && missedCodexNotifications(resumed.thread, rootThreadId, turnId, completedItemIds);
+            if (!missed || abortInvoked) throw new Error("Codex thread could not be rejoined.");
+            const previous = runtime;
+            runtime = { ...runtime, ...connection };
+            await previous.cleanup().catch(() => void 0);
+            client = nextClient;
+            iterator = client.messages()[Symbol.asyncIterator]();
+            sink.setRaw(runtime.raw);
+            replay.push(...missed);
+            debugCodex("\u2605 rejoined thread %s; replaying %d notification(s)", rootThreadId, missed.length);
+            return true;
           } catch (error) {
-            if (settleOnFailure(error)) return;
-            throw error;
+            debugCodex("\u2605 reconnect failed: %o", error);
+            await connection?.cleanup().catch(() => void 0);
+            return false;
           }
-          if ("reason" in step) {
-            if (!abortInvoked) {
-              debugCodex("\u2605 native goal wait over (%s)", step.reason);
-              settle();
-              return;
+        };
+        for (; ; ) {
+          let step;
+          const replayed = replay.shift();
+          if (replayed) {
+            step = { result: { done: false, value: replayed } };
+          } else {
+            const read = next ??= iterator.next();
+            try {
+              step = pendingWait ? await Promise.race([
+                read.then((result) => ({ result })),
+                pendingWait.expired.then((reason) => ({ reason }))
+              ]) : { result: await read };
+            } catch (error) {
+              next = void 0;
+              if (settleOnFailure(error)) return;
+              if (await reconnect(error)) continue;
+              throw error;
             }
-            endWait();
-            step = { result: await next };
+            if ("reason" in step) {
+              if (!abortInvoked) {
+                debugCodex("\u2605 native goal wait over (%s)", step.reason);
+                settle();
+                return;
+              }
+              endWait();
+              step = { result: await read };
+            }
+            next = void 0;
+          }
+          if (step.result.done) {
+            if (pendingWait && lastTurn) break;
+            if (await reconnect(new Error("Codex transport closed."))) continue;
+            break;
           }
-          if (step.result.done) break;
           const message = step.result.value;
+          if (message.method === "item/completed") {
+            const id = message.params?.item?.id;
+            if (typeof id === "string") {
+              if (replayed) replayedItemIds.add(id);
+              else if (replayedItemIds.has(id)) continue;
+              completedItemIds.add(id);
+            }
+          }
           if (!firstClientMessageLogged) {
             firstClientMessageLogged = true;
             debugCodex(

package/dist/index.js

@@ -15,7 +15,7 @@ import {
   parseHarnessCommandInvocation,
   resolveHarnessCommand,
   skillDirective
-} from "./chunk-UE4LQEL5.js";
+} from "./chunk-JO6LTAAD.js";
 import {
   ProviderLogAssembler,
   createNormalizedEvent,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentbox-sdk",
-  "version": "0.1.602",
+  "version": "0.1.603",
   "description": "Swappable coding agents and sandbox providers for Bun and TypeScript.",
   "license": "MIT",
   "repository": {