Skip to content

Commit 669aa32

Browse files
Alb11747codex
andauthored
fix(server): keep Codex loaded when reasoning effort changes (pingdotgg#32915)
Co-authored-by: GPT-6.1 Sol at high effort <[email protected]>
1 parent fdaf883 commit 669aa32

4 files changed

Lines changed: 149 additions & 10 deletions

File tree

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

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -188,6 +188,13 @@ function codexFileChangeApprovalPrompt(input: {
188188
return input.grantRoot?.trim() || undefined;
189189
}
190190

191+
export function normalizeCodexThreadLoadModelSelection(selection: ModelSelection): ModelSelection {
192+
// Codex applies effort on turn/start; resume discards its pinned request effort.
193+
const { options, ...rest } = selection;
194+
const loadOptions = options?.filter((option) => option.id !== "reasoningEffort");
195+
return { ...rest, ...(loadOptions?.length ? { options: loadOptions } : {}) };
196+
}
197+
191198
// Reasoning-effort changes preserve the tokenizer and context window; other changes need fresh telemetry.
192199
export function canReuseCodexContextUsage(previous: ModelSelection, next: ModelSelection): boolean {
193200
return modelSelectionsEqual(
@@ -7356,6 +7363,7 @@ export const makeCodexAdapterV2 = Effect.fn("makeCodexAdapterV2")(function* (
73567363
providerSession: session,
73577364
events: Stream.fromEffectRepeat(Queue.take(events)),
73587365
canReuseContextUsage: canReuseCodexContextUsage,
7366+
normalizeThreadLoadModelSelection: normalizeCodexThreadLoadModelSelection,
73597367
// Idle release can beat delayed subagent resumes: Codex reports them completed between turns with no resume-expected signal.
73607368
hasPendingBackgroundWork: Effect.gen(function* () {
73617369
for (const items of (yield* Ref.get(runningCommandItemsByTurn)).values()) {

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

Lines changed: 128 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -42,7 +42,10 @@ import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderS
4242
import * as McpSessionRegistry from "../mcp/McpSessionRegistry.ts";
4343
import * as SqlitePersistence from "../persistence/Sqlite.ts";
4444
import * as ServerSettings from "../serverSettings.ts";
45-
import { CodexProviderCapabilitiesV2 } from "./Adapters/CodexAdapterV2.ts";
45+
import {
46+
CodexProviderCapabilitiesV2,
47+
normalizeCodexThreadLoadModelSelection,
48+
} from "./Adapters/CodexAdapterV2.ts";
4649
import * as EventSink from "./EventSink.ts";
4750
import * as EventStore from "./EventStore.ts";
4851
import * as IdAllocator from "@t3tools/provider-core/server/IdAllocator";
@@ -427,6 +430,7 @@ const makeProviderAdapter = Effect.fnUntraced(function* (
427430
state: Ref.Ref<TestProviderRuntimeState>,
428431
options: {
429432
readonly failEventStream?: boolean;
433+
readonly normalizeThreadLoadModelSelection?: (selection: ModelSelection) => ModelSelection;
430434
readonly capabilities?: OrchestrationV2ProviderCapabilities;
431435
readonly extensionStatuses?: OrchestrationV2ProviderSession["extensionStatuses"];
432436
readonly mcpConfigs?: Ref.Ref<
@@ -513,6 +517,9 @@ const makeProviderAdapter = Effect.fnUntraced(function* (
513517
instanceId: ProviderInstanceId.make("codex"),
514518
driver: CODEX_DRIVER,
515519
providerSessionId: input.providerSessionId,
520+
...(options.normalizeThreadLoadModelSelection === undefined
521+
? {}
522+
: { normalizeThreadLoadModelSelection: options.normalizeThreadLoadModelSelection }),
516523
get providerSession() {
517524
return session;
518525
},
@@ -581,6 +588,7 @@ function layerTest(input: {
581588
readonly idleTimeoutMs: number;
582589
readonly maxIdlePinMs?: number;
583590
readonly failEventStream?: boolean;
591+
readonly normalizeThreadLoadModelSelection?: (selection: ModelSelection) => ModelSelection;
584592
readonly capabilities?: OrchestrationV2ProviderCapabilities;
585593
readonly extensionStatuses?: OrchestrationV2ProviderSession["extensionStatuses"];
586594
readonly mcpConfigs?: Ref.Ref<
@@ -623,6 +631,9 @@ function layerTest(input: {
623631
const layerRegistry = Layer.unwrap(
624632
makeProviderAdapter(input.state, {
625633
failEventStream: input.failEventStream ?? false,
634+
...(input.normalizeThreadLoadModelSelection === undefined
635+
? {}
636+
: { normalizeThreadLoadModelSelection: input.normalizeThreadLoadModelSelection }),
626637
...(input.capabilities === undefined ? {} : { capabilities: input.capabilities }),
627638
...(input.extensionStatuses === undefined
628639
? {}
@@ -4054,9 +4065,15 @@ it.effect(
40544065
}),
40554066
);
40564067

4057-
it.effect(
4058-
"ProviderSessionManagerV2 opens one shared runtime, broadcasts events, and detaches threads independently",
4059-
() =>
4068+
it.effect.each([
4069+
{ name: "default load key", normalizeThreadLoadModelSelection: undefined },
4070+
{
4071+
name: "Codex load key",
4072+
normalizeThreadLoadModelSelection: normalizeCodexThreadLoadModelSelection,
4073+
},
4074+
])(
4075+
"ProviderSessionManagerV2 opens one shared runtime, broadcasts events, and detaches threads independently ($name)",
4076+
({ normalizeThreadLoadModelSelection }) =>
40604077
Effect.gen(function* () {
40614078
const state = yield* Ref.make(emptyState);
40624079
const settings = yield* ServerSettings.ServerSettingsService.pipe(
@@ -4153,25 +4170,91 @@ it.effect(
41534170
const resumeSecondThread = secondRuntime.resumeThread({
41544171
providerThread: secondProviderThread,
41554172
threadId: secondThreadId,
4156-
modelSelection,
4173+
modelSelection: {
4174+
...modelSelection,
4175+
options: [{ id: "reasoningEffort", value: "medium" }],
4176+
},
41574177
runtimePolicy,
41584178
});
41594179
yield* resumeSecondThread;
41604180
yield* resumeSecondThread;
41614181
assert.equal((yield* Ref.get(state)).resumeCount, 1);
4182+
let resumeCount = 1;
4183+
const projectionStore = yield* ProjectionStore.ProjectionStoreV2;
4184+
const appThread = (yield* projectionStore.getThreadProjection(secondThreadId)).thread;
4185+
const turnEvents = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
4186+
assert.isDefined(turnEvents);
4187+
for (const [index, effort] of ["medium", "high", "medium"].entries()) {
4188+
const selection = {
4189+
...modelSelection,
4190+
options: [{ id: "reasoningEffort", value: effort }],
4191+
} satisfies ModelSelection;
4192+
yield* secondRuntime.resumeThread({
4193+
providerThread: secondProviderThread,
4194+
threadId: secondThreadId,
4195+
modelSelection: selection,
4196+
runtimePolicy,
4197+
});
4198+
const ordinal = index + 1;
4199+
const runId = idAllocator.derive.run({ threadId: secondThreadId, ordinal });
4200+
yield* secondRuntime.startTurn({
4201+
appThread,
4202+
threadId: secondThreadId,
4203+
runId,
4204+
runOrdinal: ordinal,
4205+
providerTurnOrdinal: ordinal,
4206+
attemptId: idAllocator.derive.runAttempt({ runId, attemptOrdinal: 1 }),
4207+
rootNodeId: idAllocator.derive.rootNode({ runId }),
4208+
providerThread: secondProviderThread,
4209+
message: {
4210+
createdBy: "user",
4211+
creationSource: "web",
4212+
messageId: yield* idAllocator.allocate.message({
4213+
threadId: secondThreadId,
4214+
ordinal,
4215+
}),
4216+
text: "turn",
4217+
attachments: [],
4218+
},
4219+
modelSelection: selection,
4220+
runtimePolicy,
4221+
});
4222+
const subscription = yield* secondRuntime.subscribeEvents!;
4223+
const terminal = yield* subscription.events.pipe(
4224+
Stream.filter((event) => event.type === "turn.terminal"),
4225+
Stream.runHead,
4226+
Effect.forkScoped,
4227+
);
4228+
yield* Queue.offer(turnEvents!, {
4229+
type: "turn.terminal",
4230+
driver: CODEX_DRIVER,
4231+
providerThreadId: secondProviderThread.id,
4232+
providerTurnId: idAllocator.derive.providerTurn({
4233+
driver: CODEX_DRIVER,
4234+
nativeTurnId: `native-effort-turn-${ordinal}`,
4235+
}),
4236+
runOrdinal: ordinal,
4237+
status: "completed",
4238+
failure: null,
4239+
threadDisposition: "reusable",
4240+
});
4241+
yield* Fiber.join(terminal);
4242+
if (normalizeThreadLoadModelSelection === undefined && index > 0) resumeCount++;
4243+
assert.equal((yield* Ref.get(state)).resumeCount, resumeCount, `${effort} effort reload`);
4244+
}
41624245
yield* secondRuntime.resumeThread({
41634246
providerThread: secondProviderThread,
41644247
threadId: secondThreadId,
41654248
modelSelection: { ...modelSelection, model: "gpt-5.4-mini" },
41664249
runtimePolicy,
41674250
});
4168-
assert.equal((yield* Ref.get(state)).resumeCount, 2);
4251+
assert.equal((yield* Ref.get(state)).resumeCount, ++resumeCount);
41694252
yield* resumeSecondThread;
4170-
assert.equal((yield* Ref.get(state)).resumeCount, 3);
4253+
assert.equal((yield* Ref.get(state)).resumeCount, ++resumeCount);
41714254
// regression: #26722 a Linked environments change reloads only the idle thread's tools.
41724255
yield* settings.updateSettings({ linkedEnvironmentsEnabled: true });
41734256
yield* resumeSecondThread;
4174-
assert.equal((yield* Ref.get(state)).resumeCount, 4);
4257+
assert.equal((yield* Ref.get(state)).resumeCount, ++resumeCount);
41754258
assert.deepEqual((yield* Ref.get(state)).unloadedNativeThreadIds, ["native-thread"]);
41764259
const subscribe = firstRuntime.subscribeEvents;
41774260
assert.isDefined(subscribe);
@@ -4204,10 +4287,43 @@ it.effect(
42044287
runtimePolicy,
42054288
});
42064289
yield* resumeSecondThread;
4207-
assert.equal((yield* Ref.get(state)).resumeCount, 5);
4290+
assert.equal((yield* Ref.get(state)).resumeCount, ++resumeCount);
42084291

42094292
assert.deepEqual((yield* Ref.get(state)).unloadedNativeThreadIds, ["native-thread"]);
42104293

4294+
const reloadCases = [
4295+
{
4296+
name: "other model options",
4297+
providerThread: secondProviderThread,
4298+
selection: {
4299+
...modelSelection,
4300+
options: [{ id: "serviceTier", value: "priority" }],
4301+
},
4302+
policy: runtimePolicy,
4303+
},
4304+
{
4305+
name: "runtime policy",
4306+
providerThread: secondProviderThread,
4307+
selection: modelSelection,
4308+
policy: { ...runtimePolicy, interactionMode: "plan" },
4309+
},
4310+
] satisfies ReadonlyArray<{
4311+
name: string;
4312+
providerThread: OrchestrationV2ProviderThread;
4313+
selection: ModelSelection;
4314+
policy: ProviderAdapter.ProviderAdapterV2RuntimePolicy;
4315+
}>;
4316+
for (const { name, providerThread, selection, policy } of reloadCases) {
4317+
const before = (yield* Ref.get(state)).resumeCount;
4318+
yield* secondRuntime.resumeThread({
4319+
providerThread,
4320+
threadId: secondThreadId,
4321+
modelSelection: selection,
4322+
runtimePolicy: policy,
4323+
});
4324+
assert.equal((yield* Ref.get(state)).resumeCount, before + 1, `${name} did not reload`);
4325+
}
4326+
42114327
yield* manager.detach({ providerSessionId, threadId: firstThreadId });
42124328
assert.isTrue(Option.isSome(yield* manager.get(providerSessionId)));
42134329
assert.equal((yield* Ref.get(state)).closeCount, 0);
@@ -4228,6 +4344,9 @@ it.effect(
42284344
layerTest({
42294345
state,
42304346
idleTimeoutMs: 1000,
4347+
...(normalizeThreadLoadModelSelection === undefined
4348+
? {}
4349+
: { normalizeThreadLoadModelSelection }),
42314350
serverSettingsLayer: Layer.succeed(ServerSettings.ServerSettingsService, settings),
42324351
}),
42334352
),

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

Lines changed: 11 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -329,15 +329,21 @@ function providerThreadRuntimeKey(
329329
}
330330

331331
function providerThreadLoadKey(input: {
332+
readonly runtime: ProviderAdapter.ProviderAdapterV2SessionRuntime;
332333
readonly providerThread: Parameters<
333334
ProviderAdapter.ProviderAdapterV2SessionRuntime["resumeThread"]
334335
>[0]["providerThread"];
335336
readonly modelSelection?: ModelSelection;
336337
readonly runtimePolicy?: ProviderAdapter.ProviderAdapterV2RuntimePolicy;
337338
}): string {
339+
const modelSelection =
340+
input.modelSelection === undefined
341+
? undefined
342+
: (input.runtime.normalizeThreadLoadModelSelection?.(input.modelSelection) ??
343+
input.modelSelection);
338344
return JSON.stringify({
339345
providerThread: providerThreadRuntimeKey(input.providerThread),
340-
modelSelection: input.modelSelection ?? null,
346+
modelSelection: modelSelection ?? null,
341347
runtimePolicy: input.runtimePolicy ?? null,
342348
});
343349
}
@@ -1984,6 +1990,7 @@ export const layerWithOptions = (
19841990
providerSessionId,
19851991
threadId: input.threadId,
19861992
providerThreadKey: providerThreadLoadKey({
1993+
runtime,
19871994
providerThread,
19881995
modelSelection: input.modelSelection,
19891996
runtimePolicy: input.runtimePolicy,
@@ -1999,6 +2006,7 @@ export const layerWithOptions = (
19992006
return runtime.resumeThread(input);
20002007
}
20012008
const providerThreadKey = providerThreadLoadKey({
2009+
runtime,
20022010
providerThread: input.providerThread,
20032011
...(input.modelSelection === undefined
20042012
? {}
@@ -2043,6 +2051,7 @@ export const layerWithOptions = (
20432051
providerSessionId,
20442052
threadId,
20452053
providerThreadKey: providerThreadLoadKey({
2054+
runtime,
20462055
providerThread,
20472056
...(input.modelSelection === undefined
20482057
? {}
@@ -2072,6 +2081,7 @@ export const layerWithOptions = (
20722081
providerSessionId,
20732082
threadId: input.targetThreadId,
20742083
providerThreadKey: providerThreadLoadKey({
2084+
runtime,
20752085
providerThread,
20762086
...(input.modelSelection === undefined
20772087
? {}

‎packages/provider-core/src/server/ProviderAdapter.ts‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -654,6 +654,8 @@ export interface ProviderAdapterV2SessionRuntime {
654654
cwd?: string | null,
655655
) => number | undefined;
656656
readonly canReuseContextUsage?: (previous: ModelSelection, next: ModelSelection) => boolean;
657+
/** Excludes turn-scoped options from native thread load matching. */
658+
readonly normalizeThreadLoadModelSelection?: (selection: ModelSelection) => ModelSelection;
657659
readonly ensureThread: (
658660
input: ProviderAdapterV2EnsureThreadInput,
659661
) => Effect.Effect<OrchestrationV2ProviderThread, ProviderAdapterV2Error>;

0 commit comments

Comments
 (0)