letagents 0.12.27 → 0.12.28

package/dist/mcp/codex-session/session-start.js

@@ -1,5 +1,6 @@
 import { randomUUID } from "crypto";
 import { resolve } from "path";
+import { CODEX_THREAD_HISTORY_MODE } from "../../../shared/codex-thread-history.mjs";
 import { getCurrentCodexLiveSession, getStoredCodexLiveSession, saveCodexLiveSession, updateCodexLiveSession, } from "../local-state.js";
 import { getGitCurrentBranch } from "../git-remote.js";
 import { isServerReady, launchAppServer, resolveCodexServerUrl, terminateSpawnedProcess, waitForServer, } from "./app-server.js";
@@ -109,7 +110,7 @@ export async function startLocalCodexSession(input) {
             });
         });
         await client.connect();
-        const threadStart = await client.request("thread/start", {});
+        const threadStart = await client.request("thread/start", { historyMode: CODEX_THREAD_HISTORY_MODE });
         const threadId = threadStart.thread?.id;
         if (!threadId) {
             throw new Error("Codex app-server did not return a thread id.");

package/dist/mcp/server/runtime/supervisor-bridge.js

@@ -9,6 +9,9 @@ import { getCurrentSupervisedRoomAuthority } from "./supervised-room-authority.j
 const NEGOTIATION_PROTOCOL_VERSION = 1;
 const SUPPORTED_SUPERVISOR_PROTOCOL_VERSIONS = new Set([1, 2, 3]);
 const DEFAULT_REQUEST_TIMEOUT_MS = 5_000;
+// A signed desktop update can leave the socket absent for roughly 20 seconds.
+// Only unsent operations receive this startup grace; it never permits replay.
+const SUPERVISED_STARTUP_TIMEOUT_MS = 30_000;
 const CONFIRMED_BINDING_VERIFY_TIMEOUT_MS = 250;
 const SUPERVISOR_CONTEXT_FILE = ".letagents-supervisor-context.json";
 const WORK_ATTEMPT_MARKER_FILE = ".letagents-work-attempt.json";
@@ -95,26 +98,9 @@ const activeCursorCheckpointDrains = new Set();
 const cursorCheckpointRetryTimers = new Map();
 const CURSOR_CHECKPOINT_RETRY_DELAYS_MS = [250, 1_000, 3_000];
 export async function executeCurrentSupervisedTool(input, env = process.env, options = {}) {
-    const coordinates = await requireCurrentSupervisedCoordinates(env, options);
-    const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-    const negotiated = await negotiateSupervisor(coordinates.socketPath, timeoutMs);
-    if (negotiated.generation === null)
-        throw new Error("The supervised daemon generation is unavailable.");
-    const response = await supervisorRequest(coordinates.socketPath, {
-        version: negotiated.protocolVersion,
-        id: randomUUID(),
-        method: "supervisor.execute_bounded_tool",
-        params: {
-            entry_id: coordinates.entryId,
-            work_attempt_id: coordinates.workAttemptId,
-            execution_generation_id: coordinates.executionGenerationId,
-            ...(coordinates.providerTurnId ? { provider_turn_id: coordinates.providerTurnId } : {}),
-            daemon_generation: negotiated.generation,
-            mcp_request_id: input.mcpRequestId,
-            tool_name: input.toolName,
-            input: input.input,
-        },
-    }, null);
+    const response = await requestCurrentSupervisedOperation("supervisor.execute_bounded_tool", {
+        mcp_request_id: input.mcpRequestId, tool_name: input.toolName, input: input.input,
+    }, env, options);
     if (!response.ok) {
         if (/Unsupported daemon method:\s*supervisor\.execute_bounded_tool/i.test(response.error ?? "")) {
             return { state: "unsupported" };
@@ -131,27 +117,9 @@ export async function executeCurrentSupervisedTool(input, env = process.env, opt
     return { state: "completed", roomId, result: result.result };
 }
 export async function prepareCurrentSupervisedEffect(input, env = process.env, options = {}) {
-    const coordinates = await requireCurrentSupervisedCoordinates(env, options);
-    const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-    const negotiated = await negotiateSupervisor(coordinates.socketPath, timeoutMs);
-    if (negotiated.generation === null)
-        throw new Error("The supervised daemon generation is unavailable.");
-    const response = await supervisorRequest(coordinates.socketPath, {
-        version: negotiated.protocolVersion,
-        id: randomUUID(),
-        method: "supervisor.prepare_bounded_effect",
-        params: {
-            entry_id: coordinates.entryId,
-            work_attempt_id: coordinates.workAttemptId,
-            execution_generation_id: coordinates.executionGenerationId,
-            ...(coordinates.providerTurnId ? { provider_turn_id: coordinates.providerTurnId } : {}),
-            daemon_generation: negotiated.generation,
-            mcp_request_id: input.mcpRequestId,
-            tool_name: input.toolName,
-            input: input.input,
-            mutation: input.mutation,
-        },
-    }, timeoutMs);
+    const response = await requestCurrentSupervisedOperation("supervisor.prepare_bounded_effect", {
+        mcp_request_id: input.mcpRequestId, tool_name: input.toolName, input: input.input, mutation: input.mutation,
+    }, env, options);
     if (!response.ok)
         throw new Error(response.error || "The supervised effect was rejected.");
     const result = response.result && typeof response.result === "object" ? response.result : {};
@@ -184,6 +152,50 @@ export async function prepareCurrentSupervisedEffect(input, env = process.env, o
     }
     throw new Error("The supervised effect journal returned an unsupported action.");
 }
+async function requestCurrentSupervisedOperation(method, params, env, options) {
+    // Keep the original invocation and authority across an unlink-to-listen gap.
+    const invocation = JSON.parse(JSON.stringify(params));
+    const coordinates = await requireCurrentSupervisedCoordinates(env, options);
+    const requestId = randomUUID();
+    const deadline = Date.now() + (options.requestTimeoutMs ?? SUPERVISED_STARTUP_TIMEOUT_MS);
+    let retryAttempt = 0;
+    while (true) {
+        let negotiated;
+        try {
+            negotiated = await negotiateSupervisor(coordinates.socketPath, remainingRequestTimeout(deadline));
+        }
+        catch (error) {
+            // Negotiation is read-only; no operation has been sent at this point.
+            if (!(error instanceof SupervisorTransportError) || !isRetryableSupervisorBridgeError(error)
+                || !await waitForCompletionHandoffRetry(deadline, retryAttempt++))
+                throw error;
+            continue;
+        }
+        if (negotiated.generation === null)
+            throw new Error("The supervised daemon generation is unavailable.");
+        try {
+            return await supervisorRequest(coordinates.socketPath, {
+                version: negotiated.protocolVersion, id: requestId, method,
+                params: {
+                    ...invocation,
+                    entry_id: coordinates.entryId,
+                    work_attempt_id: coordinates.workAttemptId,
+                    execution_generation_id: coordinates.executionGenerationId,
+                    ...(coordinates.providerTurnId ? { provider_turn_id: coordinates.providerTurnId } : {}),
+                    daemon_generation: negotiated.generation,
+                },
+            }, method === "supervisor.execute_bounded_tool" ? null : remainingRequestTimeout(deadline), remainingRequestTimeout(deadline));
+        }
+        catch (error) {
+            // Once a write begins, failure is ambiguous. Never replay an operation,
+            // even when its error looks like a transient daemon restart.
+            if (!(error instanceof SupervisorTransportError) || error.writeAttempted
+                || !isRetryableSupervisorBridgeError(error)
+                || !await waitForCompletionHandoffRetry(deadline, retryAttempt++))
+                throw error;
+        }
+    }
+}
 export async function completeCurrentSupervisedEffect(input, env = process.env, options = {}) {
     const coordinates = await requireCurrentSupervisedCoordinates(env, options);
     const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
@@ -811,27 +823,44 @@ async function negotiateSupervisor(socketPath, timeoutMs) {
         custodialPollingV1: result.capabilities?.custodialPollingV1 === true,
         custodialPollingOffersV1: result.capabilities?.custodialPollingOffersV1 === true };
 }
-function supervisorRequest(socketPath, request, timeoutMs) {
+class SupervisorTransportError extends Error {
+    writeAttempted;
+    code;
+    constructor(error, writeAttempted) {
+        super(error.message, { cause: error });
+        this.writeAttempted = writeAttempted;
+        this.code = error.code;
+    }
+}
+function supervisorRequest(socketPath, request, timeoutMs, connectTimeoutMs = null) {
     return new Promise((resolve, reject) => {
+        const encoded = `${JSON.stringify(request)}\n`;
         const socket = createConnection(socketPath);
         let buffer = "";
         let finished = false;
-        const timer = timeoutMs === null ? null : setTimeout(() => {
-            socket.destroy();
-            finish(() => reject(new Error("Timed out communicating with the supervisor daemon.")));
-        }, timeoutMs);
-        timer?.unref();
+        let writeAttempted = false;
         const finish = (operation) => {
             if (finished)
                 return;
             finished = true;
             if (timer)
                 clearTimeout(timer);
+            if (connectTimer)
+                clearTimeout(connectTimer);
             operation();
         };
+        const failTransport = (error) => finish(() => reject(new SupervisorTransportError(error, writeAttempted)));
+        const timeout = () => {
+            failTransport(new Error("Timed out communicating with the supervisor daemon."));
+            socket.destroy();
+        };
+        const timer = timeoutMs === null ? null : setTimeout(timeout, timeoutMs);
+        const connectTimer = connectTimeoutMs === null ? null : setTimeout(timeout, connectTimeoutMs);
+        timer?.unref();
+        connectTimer?.unref();
         socket.setEncoding("utf8");
-        socket.once("error", (error) => finish(() => reject(error)));
-        socket.once("close", () => finish(() => reject(new Error("Supervisor connection closed before a response."))));
+        socket.once("error", failTransport);
+        socket.once("close", () => failTransport(new Error("Supervisor connection closed before a response.")));
         socket.on("data", (chunk) => {
             buffer += chunk;
             const newline = buffer.indexOf("\n");
@@ -848,6 +877,19 @@ function supervisorRequest(socketPath, request, timeoutMs) {
                 finish(() => reject(error));
             }
         });
-        socket.once("connect", () => socket.write(`${JSON.stringify(request)}\n`));
+        socket.once("connect", () => {
+            if (finished)
+                return;
+            if (connectTimer)
+                clearTimeout(connectTimer);
+            writeAttempted = true;
+            try {
+                socket.write(encoded);
+            }
+            catch (error) {
+                failTransport(error instanceof Error ? error : new Error(String(error)));
+                socket.destroy();
+            }
+        });
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letagents",
-  "version": "0.12.27",
+  "version": "0.12.28",
   "description": "Let Agents Chat \u2014 MCP server for AI agent communication",
   "type": "module",
   "main": "dist/mcp/server.js",

package/shared/codex-thread-history.d.mts

@@ -0,0 +1 @@
+export const CODEX_THREAD_HISTORY_MODE: "legacy";

package/shared/codex-thread-history.mjs

@@ -0,0 +1,4 @@
+// Attachment and recovery require readable native turn history. Codex 0.153.4
+// can default to paginated threads whose history API is unavailable. Select
+// the verified contract only for creation; never reinterpret an existing thread.
+export const CODEX_THREAD_HISTORY_MODE = "legacy";