Skip to content

Commit d0cd6b9

Browse files
Ubuntuclaude
andcommitted
fix(server): start a new Codex app-server after the old one exits
The Codex adapter never noticed its app-server process dying. The session stayed live, so every later turn on any thread reused the dead client and failed at once with the exit status of the dead process, until the T3 server restarted. The Codex client now exposes when its transport terminates. The adapter fails the session's event stream at that point, and the session manager releases the session as it does for any failed provider stream. The next turn opens a new session and spawns a new app-server. Co-Authored-By: Claude Opus 5.5 <[email protected]>
1 parent 13aa882 commit d0cd6b9

3 files changed

Lines changed: 210 additions & 4 deletions

File tree

‎apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts‎

Lines changed: 19 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1791,7 +1791,25 @@ export const makeCodexAdapterV2 = Effect.fn("makeCodexAdapterV2")(function* (
17911791
model: input.modelSelection.model,
17921792
now,
17931793
});
1794-
const events = yield* Queue.unbounded<ProviderAdapter.ProviderAdapterV2Event>();
1794+
const events = yield* Queue.unbounded<
1795+
ProviderAdapter.ProviderAdapterV2Event,
1796+
ProviderAdapter.ProviderAdapterEventStreamError
1797+
>();
1798+
// Every thread in this session talks to one app-server. Once it is gone,
1799+
// end the session so the next turn starts a new app-server.
1800+
yield* client.awaitTermination.pipe(
1801+
Effect.flatMap((cause) =>
1802+
Queue.fail(
1803+
events,
1804+
new ProviderAdapter.ProviderAdapterEventStreamError({
1805+
driver: CODEX_PROVIDER,
1806+
providerSessionId: input.providerSessionId,
1807+
cause,
1808+
}),
1809+
),
1810+
),
1811+
Effect.forkIn(scope),
1812+
);
17951813
const rateLimitSnapshot = yield* Ref.make<CodexRateLimitSnapshot | undefined>(undefined);
17961814
const limitedTurnItems = yield* Ref.make(
17971815
new Map<ProviderThreadId, Extract<OrchestrationV2TurnItem, { type: "error" }>>(),

‎apps/server/src/orchestration-v2/ProviderSessionManager.test.ts‎

Lines changed: 185 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,8 @@ import {
1717
type ProviderSessionId,
1818
ThreadId,
1919
} from "@t3tools/contracts";
20+
import * as CodexClient from "effect-codex-app-server/client";
21+
import * as CodexReplay from "effect-codex-app-server/replay";
2022
import * as Cause from "effect/Cause";
2123
import * as DateTime from "effect/DateTime";
2224
import * as Deferred from "effect/Deferred";
@@ -33,6 +35,7 @@ import * as Stream from "effect/Stream";
3335
import { TestClock } from "effect/testing";
3436
import { HttpServer } from "effect/http";
3537

38+
import * as ServerConfig from "../config.ts";
3639
import { ProviderWorkspaceMissingError } from "../provider/Errors.ts";
3740
import * as ServerEnvironment from "../environment/ServerEnvironment.ts";
3841
import * as ProjectService from "../project/ProjectService.ts";
@@ -41,7 +44,7 @@ import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderS
4144
import * as McpSessionRegistry from "../mcp/McpSessionRegistry.ts";
4245
import * as SqlitePersistence from "../persistence/Sqlite.ts";
4346
import * as ServerSettings from "../serverSettings.ts";
44-
import { CodexProviderCapabilitiesV2 } from "./Adapters/CodexAdapterV2.ts";
47+
import * as CodexAdapterV2 from "./Adapters/CodexAdapterV2.ts";
4548
import * as EventSink from "./EventSink.ts";
4649
import * as EventStore from "./EventStore.ts";
4750
import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
@@ -160,7 +163,8 @@ const layerBeforeUnchangedWriteEventSink = (before: Ref.Ref<Effect.Effect<void>>
160163
}),
161164
).pipe(Layer.provide(layerTestEventSink));
162165

163-
const CodexCapabilities: OrchestrationV2ProviderCapabilities = CodexProviderCapabilitiesV2;
166+
const CodexCapabilities: OrchestrationV2ProviderCapabilities =
167+
CodexAdapterV2.CodexProviderCapabilitiesV2;
164168
const ExclusiveCapabilities: OrchestrationV2ProviderCapabilities = {
165169
...CodexCapabilities,
166170
sessions: {
@@ -488,6 +492,7 @@ function layerTest(input: {
488492
readonly scopeCloseReached?: Deferred.Deferred<void>;
489493
readonly serverSettingsLayer?: ReturnType<typeof ServerSettings.layerTest>;
490494
readonly projectServiceLayer?: Layer.Layer<ProjectService.ProjectService>;
495+
readonly registry?: Layer.Layer<ProviderAdapterRegistry.ProviderAdapterRegistryV2>;
491496
}) {
492497
const layerConfiguredEventSink =
493498
input.flakyReleaseWrites !== undefined
@@ -554,7 +559,7 @@ function layerTest(input: {
554559
}).pipe(
555560
Layer.provide(
556561
Layer.mergeAll(
557-
layerRegistry.pipe(Layer.provideMerge(McpProviderSessions.layer)),
562+
(input.registry ?? layerRegistry).pipe(Layer.provideMerge(McpProviderSessions.layer)),
558563
CommandOutputHub.layer.pipe(
559564
Layer.provide(Layer.merge(layerConfiguredEventSink, layerTestStores)),
560565
),
@@ -3545,6 +3550,183 @@ it.effect("ProviderSessionManagerV2 releases sessions when provider event stream
35453550
}),
35463551
);
35473552

3553+
const codexAppServerLifetime = (
3554+
nativeThreadId: string,
3555+
): ReadonlyArray<CodexReplay.CodexAppServerReplayEntry> => [
3556+
{
3557+
type: "expect_outbound",
3558+
frame: {
3559+
id: 1,
3560+
method: "initialize",
3561+
params: {
3562+
clientInfo: { name: "T3 Code", title: "T3 Code", version: "ignored" },
3563+
capabilities: {
3564+
experimentalApi: true,
3565+
optOutNotificationMethods: ["turn/diff/updated"],
3566+
extensions: {
3567+
"io.modelcontextprotocol/ui": { mimeTypes: ["text/html;profile=mcp-app"] },
3568+
},
3569+
},
3570+
},
3571+
},
3572+
},
3573+
{
3574+
type: "emit_inbound",
3575+
frame: {
3576+
id: 1,
3577+
result: {
3578+
userAgent: "T3 Code/0.156.1",
3579+
codexHome: "/tmp/codex-home",
3580+
platformFamily: "unix",
3581+
platformOs: "linux",
3582+
},
3583+
},
3584+
},
3585+
{ type: "expect_outbound", frame: { method: "initialized" } },
3586+
{
3587+
type: "expect_outbound",
3588+
frame: {
3589+
id: 2,
3590+
method: "thread/start",
3591+
params: { config: CodexAdapterV2.CODEX_THREAD_CONFIG },
3592+
},
3593+
},
3594+
{
3595+
type: "emit_inbound",
3596+
frame: {
3597+
id: 2,
3598+
result: {
3599+
thread: {
3600+
id: nativeThreadId,
3601+
sessionId: nativeThreadId,
3602+
forkedFromId: null,
3603+
preview: "",
3604+
ephemeral: false,
3605+
modelProvider: "openai",
3606+
createdAt: 1782622440,
3607+
updatedAt: 1782622440,
3608+
status: { type: "idle" },
3609+
path: `/tmp/${nativeThreadId}.jsonl`,
3610+
cwd: "/workspace",
3611+
cliVersion: "0.144.0",
3612+
source: "vscode",
3613+
threadSource: null,
3614+
agentNickname: null,
3615+
agentRole: null,
3616+
gitInfo: null,
3617+
name: null,
3618+
turns: [],
3619+
},
3620+
model: "gpt-5.4",
3621+
modelProvider: "openai",
3622+
serviceTier: null,
3623+
cwd: "/workspace",
3624+
instructionSources: [],
3625+
approvalPolicy: "on-request",
3626+
approvalsReviewer: "user",
3627+
sandbox: { type: "workspaceWrite", writableRoots: [], networkAccess: false },
3628+
reasoningEffort: "medium",
3629+
},
3630+
},
3631+
},
3632+
];
3633+
3634+
it.effect("ProviderSessionManagerV2 starts a new Codex app-server after the old one exits", () =>
3635+
Effect.gen(function* () {
3636+
const driver = yield* CodexReplay.makeReplayDriver({
3637+
provider: "codex",
3638+
protocol: "codex.app-server",
3639+
version: "0.144.0",
3640+
scenario: "app-server-exit",
3641+
entries: [
3642+
...codexAppServerLifetime("native-before-exit"),
3643+
{ type: "runtime_exit", status: "success" },
3644+
...codexAppServerLifetime("native-after-exit"),
3645+
],
3646+
});
3647+
const appServerStarts = yield* Ref.make(0);
3648+
const firstSessionClosed = yield* Deferred.make<void>();
3649+
const clientFactory = Layer.succeed(CodexAdapterV2.CodexAppServerClientFactory, {
3650+
open: (openInput) =>
3651+
Effect.gen(function* () {
3652+
yield* Ref.update(appServerStarts, (count) => count + 1);
3653+
yield* Effect.addFinalizer(() => Deferred.succeed(firstSessionClosed, undefined));
3654+
const context = yield* Layer.build(CodexReplay.layerReplayWithDriver(driver)).pipe(
3655+
Effect.mapError(
3656+
(cause) =>
3657+
new ProviderAdapter.ProviderAdapterOpenSessionError({
3658+
driver: CODEX_DRIVER,
3659+
providerSessionId: openInput.providerSessionId,
3660+
cause,
3661+
}),
3662+
),
3663+
);
3664+
return yield* Effect.service(CodexClient.CodexAppServerClient).pipe(
3665+
Effect.provide(context),
3666+
);
3667+
}),
3668+
});
3669+
const registry = ProviderAdapterRegistry.layerFromDrivers({
3670+
drivers: [CodexAdapterV2.CodexAdapterV2Driver],
3671+
configMap: { [modelSelection.instanceId]: { driver: CODEX_DRIVER } },
3672+
}).pipe(
3673+
Layer.provide(
3674+
Layer.mergeAll(
3675+
clientFactory,
3676+
ServerConfig.layerTest(process.cwd(), { prefix: "t3-codex-app-server-exit-" }),
3677+
IdAllocator.layer,
3678+
McpProviderSessions.layer,
3679+
).pipe(Layer.provideMerge(NodeServices.layer)),
3680+
),
3681+
Layer.orDie,
3682+
);
3683+
3684+
const effect = Effect.gen(function* () {
3685+
const eventSink = yield* EventSink.EventSinkV2;
3686+
const idAllocator = yield* IdAllocator.IdAllocatorV2;
3687+
const manager = yield* ProviderSessionManager.ProviderSessionManagerV2;
3688+
const now = yield* DateTime.now;
3689+
const projectId = yield* idAllocator.allocate.project({
3690+
fixtureName: "provider-session-manager-codex-exit",
3691+
});
3692+
const threadId = yield* idAllocator.allocate.thread({
3693+
fixtureName: "provider-session-manager-codex-exit",
3694+
projectId,
3695+
});
3696+
const providerSessionId = yield* idAllocator.allocate.providerSession({
3697+
providerInstanceId: modelSelection.instanceId,
3698+
threadId,
3699+
});
3700+
yield* eventSink.write({
3701+
events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now })],
3702+
});
3703+
const ensureThread = Effect.gen(function* () {
3704+
const runtime = yield* manager.open({
3705+
threadId,
3706+
providerSessionId,
3707+
modelSelection,
3708+
runtimePolicy,
3709+
});
3710+
return yield* runtime.ensureThread({ threadId, modelSelection, runtimePolicy });
3711+
});
3712+
3713+
const before = yield* ensureThread;
3714+
yield* Deferred.await(firstSessionClosed);
3715+
const after = yield* ensureThread;
3716+
3717+
assert.equal(before.nativeThreadRef?.nativeId, "native-before-exit");
3718+
assert.equal(after.nativeThreadRef?.nativeId, "native-after-exit");
3719+
assert.equal(yield* Ref.get(appServerStarts), 2);
3720+
});
3721+
3722+
yield* effect.pipe(
3723+
Effect.provide(
3724+
layerTest({ state: yield* Ref.make(emptyState), idleTimeoutMs: 60_000, registry }),
3725+
),
3726+
);
3727+
}),
3728+
);
3729+
35483730
it.effect("ProviderSessionManagerV2 marks pending runtime requests non-live on release", () =>
35493731
Effect.gen(function* () {
35503732
const state = yield* Ref.make(emptyState);

‎packages/effect-codex-app-server/src/client.ts‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
import * as Context from "effect/Context";
2+
import * as Deferred from "effect/Deferred";
23
import * as Effect from "effect/Effect";
34
import * as Layer from "effect/Layer";
45
import * as Schema from "effect/Schema";
@@ -40,6 +41,8 @@ export class CodexAppServerClient extends Context.Service<
4041
CodexAppServerClient,
4142
{
4243
readonly raw: CodexAppServerClientRaw;
44+
/** Succeeds with the reason once the app-server exits or its output ends. */
45+
readonly awaitTermination: Effect.Effect<CodexError.CodexAppServerError>;
4346
readonly request: <M extends CodexRpc.ClientRequestMethod>(
4447
method: M,
4548
payload: CodexRpc.ClientRequestParamsByMethod[M],
@@ -195,6 +198,7 @@ export const make = Effect.fn("effect-codex-app-server/CodexAppServerClient.make
195198
: Effect.fail(CodexError.CodexAppServerRequestError.methodNotFound(request.method));
196199
};
197200

201+
const termination = yield* Deferred.make<CodexError.CodexAppServerError>();
198202
const transport = yield* CodexProtocol.makeCodexAppServerPatchedProtocol({
199203
stdio,
200204
...(terminationError ? { terminationError } : {}),
@@ -203,6 +207,7 @@ export const make = Effect.fn("effect-codex-app-server/CodexAppServerClient.make
203207
...(options.logger ? { logger: options.logger } : {}),
204208
onNotification: dispatchNotification,
205209
onRequest: dispatchRequest,
210+
onTermination: (error) => Deferred.succeed(termination, error).pipe(Effect.asVoid),
206211
});
207212

208213
const request = <M extends CodexRpc.ClientRequestMethod>(
@@ -238,6 +243,7 @@ export const make = Effect.fn("effect-codex-app-server/CodexAppServerClient.make
238243
respond: transport.respond,
239244
respondError: transport.respondError,
240245
},
246+
awaitTermination: Deferred.await(termination),
241247
request,
242248
notify,
243249
handleServerRequest: (method, handler) =>

0 commit comments

Comments
 (0)