Skip to content

Commit 00b509d

Browse files
Alb11747codex
andcommitted
fix(server): preserve deferred handoffs through delivery retries
Keep the retry marker until delivery settles and reuse deferred missed-run history across low-budget turns. Update the integration expectation so an oversized handoff allows the turn to complete while preserving its context. Co-Authored-By: GPT-6.1-Sol at high effort <[email protected]> Co-Authored-By: GPT-6.1-Sol at high effort, review subagent for deferred handoff recovery <[email protected]> Co-Authored-By: GPT-6.1-Sol at xhigh effort, review subagent for PR 19414 maintenance rebase <[email protected]>
1 parent 06cc0b2 commit 00b509d

4 files changed

Lines changed: 106 additions & 13 deletions

File tree

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

Lines changed: 52 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -716,10 +716,11 @@ describe("handoff delivery", () => {
716716
handoffs: [durable],
717717
budget: 16_000,
718718
});
719-
assert.isUndefined(durable.deferred);
719+
assert.equal(durable.deferred, native ? undefined : true);
720720
assert.equal(fits.context === "", native);
721721
if (!native) assert.include(fits.context, messages[0]!.text);
722722
yield* fits.delivered;
723+
assert.isUndefined(durable.deferred);
723724
assert.equal(durable.delivery?.status, native ? "injected" : "inline");
724725
const writes = persisted.length;
725726
const later = yield* deliverContextHandoffs({
@@ -748,8 +749,58 @@ describe("handoff delivery", () => {
748749
}),
749750
});
750751
assert.include(delivery.context, messages[0]!.text);
752+
assert.equal(durable.deferred, true);
751753
yield* delivery.delivered;
752754
assert.isUndefined(durable.deferred);
753755
}),
754756
);
757+
758+
it.effect.each([true, false])(
759+
"retains deferred history through an interrupted send (native=%s)",
760+
(native) =>
761+
Effect.gen(function* () {
762+
let durable: OrchestrationV2ContextHandoff = { ...handoff, deferred: true };
763+
const persist = (value: OrchestrationV2ContextHandoff) =>
764+
Effect.sync(() => {
765+
durable = decodePersistedHandoff(encodeHandoff(value));
766+
});
767+
const send = deliverContextHandoffs({
768+
handoffs: [durable],
769+
providerThread: native ? providerThread : { ...providerThread, nativeThreadRef: null },
770+
budget: 16_000,
771+
alreadyDeliveredItemIds: new Set(),
772+
...(native ? { inject: () => Effect.fail("lost injection acknowledgement") } : {}),
773+
persist,
774+
});
775+
if (native) {
776+
assert.equal(yield* send.pipe(Effect.flip), "lost injection acknowledgement");
777+
assert.equal(durable.delivery?.status, "pending");
778+
} else {
779+
const delivery = yield* send;
780+
assert.include(delivery.context, messages[0]!.text);
781+
assert.isUndefined(durable.delivery);
782+
}
783+
assert.equal(durable.deferred, true);
784+
785+
let injectedText = "";
786+
yield* deliverContextHandoffs({
787+
handoffs: [durable],
788+
providerThread: {
789+
...providerThread,
790+
nativeThreadRef: { ...providerThread.nativeThreadRef!, nativeId: "native:replacement" },
791+
},
792+
budget: 16_000,
793+
alreadyDeliveredItemIds: new Set(),
794+
inject: (history) =>
795+
Effect.sync(() => {
796+
injectedText = history.messages.map((message) => message.text).join("\n");
797+
return true;
798+
}),
799+
persist,
800+
});
801+
assert.include(injectedText, messages[0]!.text);
802+
assert.isUndefined(durable.deferred);
803+
assert.equal(durable.delivery?.status, "injected");
804+
}),
805+
);
755806
});

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

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -94,8 +94,9 @@ export const deliverContextHandoffs = Effect.fn("orchestrationV2.deliverContextH
9494
(handoff) =>
9595
input.persist({
9696
...handoff,
97-
// Sent (or possibly sent) now, so later turns must not retry it.
98-
deferred: undefined,
97+
// Keep retries selectable until delivery settles, including after
98+
// an ambiguous send forces replacement of the native thread.
99+
...(status === "pending" ? {} : { deferred: undefined }),
99100
...(nativeThreadId === undefined
100101
? {}
101102
: {

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

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1053,6 +1053,18 @@ export const layer: Layer.Layer<
10531053
!deliveredAttemptIds.has(source.activeAttemptId),
10541054
);
10551055
const missedRunIds = new Set(missedRuns.map((source) => source.id));
1056+
// Deferred history is still delivered below; do not allocate another
1057+
// recovery handoff for the same missed input on every low-budget turn.
1058+
const deferredItemIds = new Set(
1059+
effectiveHandoffs.flatMap((handoff) =>
1060+
handoff.deferred === true
1061+
? [
1062+
...(handoff.history?.messages.map((message) => message.itemId) ?? []),
1063+
...(handoff.history?.omittedItemIds ?? []),
1064+
]
1065+
: [],
1066+
),
1067+
);
10561068
const missedItems =
10571069
missedRunIds.size === 0
10581070
? []
@@ -1061,6 +1073,7 @@ export const layer: Layer.Layer<
10611073
item.runId !== null &&
10621074
missedRunIds.has(item.runId) &&
10631075
!coveredItemIds.has(item.id) &&
1076+
!deferredItemIds.has(item.id) &&
10641077
historicalMessage(item) !== null,
10651078
);
10661079
const startWithHandoffs = (

‎apps/server/src/orchestration-v2/testkit/ProviderSwitch.integration.test.ts‎

Lines changed: 38 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -725,19 +725,18 @@ describe("orchestration v2 provider switching", () => {
725725
}
726726
if (reasoningScenario && replaceNative) {
727727
const replaced = yield* orchestrator.getThreadProjection(threadId);
728-
assert.equal(
729-
replaced.runs.at(-1)?.status,
730-
scenario.includes("small") ? "failed" : "completed",
731-
);
728+
assert.equal(replaced.runs.at(-1)?.status, "completed");
732729
const target = replaced.providerThreads.find(
733730
(thread) => thread.providerInstanceId === CLAUDE_MODEL_SELECTION.instanceId,
734731
)!;
735732
assert.isNull(target.contextUsage);
736733
assert.equal(yield* Ref.get(generation), 2);
737-
assert.equal(
738-
(yield* Ref.get(capturedTurns)).at(-1)!.driver,
739-
scenario.includes("small") ? CODEX_DRIVER : CLAUDE_DRIVER,
740-
);
734+
assert.equal((yield* Ref.get(capturedTurns)).at(-1)!.driver, CLAUDE_DRIVER);
735+
if (scenario.includes("small")) {
736+
const handoff = replaced.contextHandoffs.at(-1)!;
737+
assert.equal(handoff.deferred, true);
738+
assert.isUndefined(handoff.delivery);
739+
}
741740
return;
742741
}
743742
if (replaceNative) {
@@ -1191,12 +1190,13 @@ describe("orchestration v2 provider switching", () => {
11911190
),
11921191
);
11931192

1194-
it.live("keeps the native session after turns refused before reaching the provider", () =>
1193+
it.live.each([false, true])("reuses native sessions after refused turns (%s)", (deferred) =>
11951194
Effect.scoped(
11961195
Effect.gen(function* () {
11971196
const cwd = yield* checkpointWorkspace("refused-start-keeps-native");
11981197
const capturedTurns = yield* Ref.make<ReadonlyArray<CapturedTurn>>([]);
11991198
const refuseStarts = yield* Ref.make(0);
1199+
let modelWindow = 32_000;
12001200
const generation = yield* Ref.make(0);
12011201
const registry = ProviderAdapterRegistry.layerFromAdapters([
12021202
makeTestAdapter({
@@ -1207,6 +1207,7 @@ describe("orchestration v2 provider switching", () => {
12071207
responseByRunOrdinal: {},
12081208
capturedTurns,
12091209
refuseStarts,
1210+
...(deferred ? { getModelContextWindow: () => modelWindow } : {}),
12101211
nativeThreadGeneration: generation,
12111212
}),
12121213
]);
@@ -1253,8 +1254,35 @@ describe("orchestration v2 provider switching", () => {
12531254
worktreePath: null,
12541255
});
12551256
assert.equal(yield* run(1), "completed");
1256-
yield* Ref.set(refuseStarts, 2);
1257+
yield* Ref.set(refuseStarts, deferred ? 1 : 2);
12571258
assert.equal(yield* run(2), "failed");
1259+
if (deferred) {
1260+
modelWindow = 16_000;
1261+
assert.equal(yield* run(3), "completed");
1262+
const first = (yield* orchestrator.getThreadProjection(threadId)).contextHandoffs;
1263+
assert.lengthOf(first, 1);
1264+
assert.equal(first[0]!.deferred, true);
1265+
assert.equal(yield* run(4), "completed");
1266+
const later = (yield* orchestrator.getThreadProjection(threadId)).contextHandoffs;
1267+
assert.lengthOf(later, 1);
1268+
assert.equal(later[0]!.id, first[0]!.id);
1269+
assert.equal(later[0]!.deferred, true);
1270+
1271+
modelWindow = 32_000;
1272+
assert.equal(yield* run(5), "completed");
1273+
const delivered = (yield* orchestrator.getThreadProjection(threadId)).contextHandoffs;
1274+
assert.lengthOf(delivered, 1);
1275+
assert.equal(delivered[0]!.id, first[0]!.id);
1276+
assert.isUndefined(delivered[0]!.deferred);
1277+
assert.equal(delivered[0]!.delivery?.status, "inline");
1278+
const accepted = (yield* Ref.get(capturedTurns)).at(-1)!;
1279+
assert.equal(accepted.text.split("Request 2").length - 1, 1);
1280+
assert.equal(yield* run(6), "completed");
1281+
assert.notInclude((yield* Ref.get(capturedTurns)).at(-1)!.text, "Request 2");
1282+
assert.lengthOf((yield* orchestrator.getThreadProjection(threadId)).contextHandoffs, 1);
1283+
assert.equal(yield* Ref.get(generation), 1);
1284+
return;
1285+
}
12581286
assert.equal(yield* run(3), "failed");
12591287
assert.equal(yield* run(4), "completed");
12601288

0 commit comments

Comments
 (0)