Skip to content

Commit e884bb3

Browse files
committed
fix(server): fork Codex threads with active writers
1 parent 82b8a93 commit e884bb3

2 files changed

Lines changed: 115 additions & 5 deletions

File tree

‎apps/server/src/provider/Layers/CodexSessionRuntime.test.ts‎

Lines changed: 84 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,7 @@ import {
1919
buildTurnStartParams,
2020
hasConfiguredMcpServer,
2121
isRecoverableThreadResumeError,
22+
isThreadActiveWriterError,
2223
makeMemoryConsolidationNotificationFilter,
2324
openCodexThread,
2425
} from "./CodexSessionRuntime.ts";
@@ -570,13 +571,93 @@ describe("isRecoverableThreadResumeError", () => {
570571
});
571572
});
572573

574+
describe("isThreadActiveWriterError", () => {
575+
it("matches Codex thread writer conflicts", () => {
576+
NodeAssert.equal(
577+
isThreadActiveWriterError(
578+
new CodexErrors.CodexAppServerRequestError({
579+
code: -32603,
580+
errorMessage: "thread provider-thread already has an active writer",
581+
}),
582+
),
583+
true,
584+
);
585+
});
586+
587+
it("ignores unrelated writer errors", () => {
588+
NodeAssert.equal(
589+
isThreadActiveWriterError(
590+
new CodexErrors.CodexAppServerRequestError({
591+
code: -32603,
592+
errorMessage: "log file already has an active writer",
593+
}),
594+
),
595+
false,
596+
);
597+
});
598+
});
599+
573600
describe("openCodexThread", () => {
601+
it.effect("forks the thread when another Codex process owns its writer", () =>
602+
Effect.gen(function* () {
603+
const calls: Array<{
604+
method: "thread/start" | "thread/resume" | "thread/fork";
605+
payload: unknown;
606+
}> = [];
607+
const forked = makeThreadOpenResponse("forked-thread");
608+
const client = {
609+
request: <M extends "thread/start" | "thread/resume" | "thread/fork">(
610+
method: M,
611+
payload: CodexRpc.ClientRequestParamsByMethod[M],
612+
) => {
613+
calls.push({ method, payload });
614+
if (method === "thread/resume") {
615+
return Effect.fail(
616+
new CodexErrors.CodexAppServerRequestError({
617+
code: -32603,
618+
errorMessage: "thread provider-thread already has an active writer",
619+
}),
620+
);
621+
}
622+
return Effect.succeed(forked as CodexRpc.ClientRequestResponsesByMethod[M]);
623+
},
624+
};
625+
626+
const opened = yield* openCodexThread({
627+
client,
628+
threadId: ThreadId.make("thread-1"),
629+
runtimeMode: "full-access",
630+
cwd: "/tmp/project",
631+
requestedModel: "gpt-5.3-codex",
632+
serviceTier: undefined,
633+
resumeThreadId: "provider-thread",
634+
});
635+
636+
NodeAssert.equal(opened.thread.id, "forked-thread");
637+
NodeAssert.deepStrictEqual(
638+
calls.map((call) => call.method),
639+
["thread/resume", "thread/fork"],
640+
);
641+
NodeAssert.deepStrictEqual(calls[1]?.payload, {
642+
threadId: "provider-thread",
643+
cwd: "/tmp/project",
644+
approvalPolicy: "never",
645+
sandbox: "danger-full-access",
646+
approvalsReviewer: "user",
647+
model: "gpt-5.3-codex",
648+
});
649+
}),
650+
);
651+
574652
it.effect("falls back to thread/start when resume fails recoverably", () =>
575653
Effect.gen(function* () {
576-
const calls: Array<{ method: "thread/start" | "thread/resume"; payload: unknown }> = [];
654+
const calls: Array<{
655+
method: "thread/start" | "thread/resume" | "thread/fork";
656+
payload: unknown;
657+
}> = [];
577658
const started = makeThreadOpenResponse("fresh-thread");
578659
const client = {
579-
request: <M extends "thread/start" | "thread/resume">(
660+
request: <M extends "thread/start" | "thread/resume" | "thread/fork">(
580661
method: M,
581662
payload: CodexRpc.ClientRequestParamsByMethod[M],
582663
) => {
@@ -614,7 +695,7 @@ describe("openCodexThread", () => {
614695
it.effect("propagates non-recoverable resume failures", () =>
615696
Effect.gen(function* () {
616697
const client = {
617-
request: <M extends "thread/start" | "thread/resume">(
698+
request: <M extends "thread/start" | "thread/resume" | "thread/fork">(
618699
method: M,
619700
_payload: CodexRpc.ClientRequestParamsByMethod[M],
620701
) => {

‎apps/server/src/provider/Layers/CodexSessionRuntime.ts‎

Lines changed: 31 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -447,11 +447,17 @@ export function isRecoverableThreadResumeError(error: unknown): boolean {
447447
return RECOVERABLE_THREAD_RESUME_ERROR_SNIPPETS.some((snippet) => message.includes(snippet));
448448
}
449449

450+
export function isThreadActiveWriterError(error: unknown): boolean {
451+
const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
452+
return message.includes("thread") && message.includes("already has an active writer");
453+
}
454+
450455
type CodexThreadOpenResponse =
451456
| CodexRpc.ClientRequestResponsesByMethod["thread/start"]
452-
| CodexRpc.ClientRequestResponsesByMethod["thread/resume"];
457+
| CodexRpc.ClientRequestResponsesByMethod["thread/resume"]
458+
| CodexRpc.ClientRequestResponsesByMethod["thread/fork"];
453459

454-
type CodexThreadOpenMethod = "thread/start" | "thread/resume";
460+
type CodexThreadOpenMethod = "thread/start" | "thread/resume" | "thread/fork";
455461

456462
interface CodexThreadOpenClient {
457463
readonly request: <M extends CodexThreadOpenMethod>(
@@ -487,6 +493,29 @@ export const openCodexThread = (input: {
487493
...startParams,
488494
})
489495
.pipe(
496+
Effect.catchIf(isThreadActiveWriterError, (error) =>
497+
Effect.logWarning("codex app-server thread resume forked from active writer", {
498+
threadId: input.threadId,
499+
requestedRuntimeMode: input.runtimeMode,
500+
resumeThreadId,
501+
cause: error,
502+
}).pipe(
503+
Effect.andThen(
504+
Effect.suspend(() => {
505+
const config = runtimeModeToThreadConfig(input.runtimeMode);
506+
return input.client.request("thread/fork", {
507+
threadId: resumeThreadId,
508+
cwd: input.cwd,
509+
approvalPolicy: config.approvalPolicy,
510+
approvalsReviewer: config.approvalsReviewer,
511+
sandbox: config.sandbox,
512+
...(input.requestedModel ? { model: input.requestedModel } : {}),
513+
...(input.serviceTier ? { serviceTier: input.serviceTier } : {}),
514+
});
515+
}),
516+
),
517+
),
518+
),
490519
Effect.catchIf(isRecoverableThreadResumeError, (error) =>
491520
Effect.logWarning("codex app-server thread resume fell back to fresh start", {
492521
threadId: input.threadId,

0 commit comments

Comments
 (0)