Skip to content

Commit c6f4f74

Browse files
committed
fix(acp): 保留关闭前尚未消费的指令失效记录
- 释放会话时读取适配器最后记录的失效状态,覆盖事件仍在队列中的情况。 - 为触发独占会话释放的线程保留写入资格,继续核对会话与运行归属。 - 新增的两条回归均在旧代码上复现,217 个相关测试及 37 个包的类型检查通过。
1 parent b87e7fc commit c6f4f74

5 files changed

Lines changed: 100 additions & 15 deletions

File tree

‎apps/server/src/orchestration-v2/Adapters/AcpAdapterV2.test.ts‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -826,12 +826,14 @@ const makeInstructionCompactionHarness = Effect.fnUntraced(function* (
826826
status: "completed",
827827
},
828828
});
829+
const pendingInvalidations = yield* session.runtime.readInstructionInvalidations!;
829830
const updated = yield* session.runtime.events.pipe(
830831
Stream.filter((event) => event.type === "provider_thread.updated"),
831832
Stream.runHead,
832833
);
833834
providerThread = Option.getOrThrow(updated).providerThread;
834835
assert.isNull(providerThread.nativeMetadata?.acpInstructions);
836+
assert.deepEqual(pendingInvalidations, [providerThread]);
835837
yield* resume();
836838
}
837839
const { runtime } = session;

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

Lines changed: 55 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -433,6 +433,9 @@ const makeProviderAdapter = Effect.fnUntraced(function* (
433433
state: Ref.Ref<TestProviderRuntimeState>,
434434
options: {
435435
readonly failEventStream?: boolean;
436+
readonly readInstructionInvalidations?: Effect.Effect<
437+
ReadonlyArray<OrchestrationV2ProviderThread>
438+
>;
436439
readonly normalizeThreadLoadModelSelection?: (selection: ModelSelection) => ModelSelection;
437440
readonly capabilities?: OrchestrationV2ProviderCapabilities;
438441
readonly extensionStatuses?: OrchestrationV2ProviderSession["extensionStatuses"];
@@ -520,6 +523,9 @@ const makeProviderAdapter = Effect.fnUntraced(function* (
520523
instanceId: ProviderInstanceId.make("codex"),
521524
driver: CODEX_DRIVER,
522525
providerSessionId: input.providerSessionId,
526+
...(options.readInstructionInvalidations === undefined
527+
? {}
528+
: { readInstructionInvalidations: options.readInstructionInvalidations }),
523529
...(options.normalizeThreadLoadModelSelection === undefined
524530
? {}
525531
: { normalizeThreadLoadModelSelection: options.normalizeThreadLoadModelSelection }),
@@ -605,6 +611,9 @@ function layerTest(input: {
605611
readonly flakyReleaseWrites?: FlakyReleaseWrites;
606612
readonly pauseAttachWrite?: Parameters<typeof layerPausingAttachEventSink>[0];
607613
readonly beforeUnchangedWrite?: Ref.Ref<Effect.Effect<void, EventSink.EventSinkWriteError>>;
614+
readonly readInstructionInvalidations?: Effect.Effect<
615+
ReadonlyArray<OrchestrationV2ProviderThread>
616+
>;
608617
readonly pauseResolve?: {
609618
readonly armed: Ref.Ref<boolean>;
610619
readonly paused: Deferred.Deferred<void>;
@@ -635,6 +644,9 @@ function layerTest(input: {
635644
const layerRegistry = Layer.unwrap(
636645
makeProviderAdapter(input.state, {
637646
failEventStream: input.failEventStream ?? false,
647+
...(input.readInstructionInvalidations === undefined
648+
? {}
649+
: { readInstructionInvalidations: input.readInstructionInvalidations }),
638650
...(input.normalizeThreadLoadModelSelection === undefined
639651
? {}
640652
: { normalizeThreadLoadModelSelection: input.normalizeThreadLoadModelSelection }),
@@ -3782,6 +3794,8 @@ it.effect.each([
37823794
"failed-event",
37833795
"release-after-failed-event",
37843796
"retry-after-failed-release",
3797+
"detach-after-failed-event",
3798+
"release-before-event",
37853799
"newer-run",
37863800
"newer-session",
37873801
] as const)(
@@ -3792,6 +3806,9 @@ it.effect.each([
37923806
const beforeUnchangedWrite = yield* Ref.make<
37933807
Effect.Effect<void, EventSink.EventSinkWriteError>
37943808
>(Effect.void);
3809+
const adapterInvalidations = yield* Ref.make<ReadonlyArray<OrchestrationV2ProviderThread>>(
3810+
[],
3811+
);
37953812
yield* Effect.gen(function* () {
37963813
const eventSink = yield* EventSink.EventSinkV2;
37973814
const idAllocator = yield* IdAllocator.IdAllocatorV2;
@@ -3842,24 +3859,34 @@ it.effect.each([
38423859
modelSelection,
38433860
runtimePolicy,
38443861
});
3862+
const invalidation = {
3863+
...providerThread,
3864+
nativeMetadata: { title: "stale title", acpInstructions: null },
3865+
};
3866+
if (owner === "release-before-event") {
3867+
// The adapter has recorded compaction, but the event pump has not seen it.
3868+
yield* Ref.set(adapterInvalidations, [invalidation]);
3869+
yield* manager.release({ providerSessionId, reason: "manual_shutdown" });
3870+
const projection = yield* projectionStore.getThreadRecords(threadId, ["providerThreads"]);
3871+
assert.isNull(projection.providerThreads[0]?.nativeMetadata?.acpInstructions);
3872+
return;
3873+
}
38453874
const subscription = yield* runtime.subscribeEvents!;
38463875
const queue = (yield* Ref.get(state)).eventQueues.get(String(providerSessionId));
38473876
assert.isDefined(queue);
38483877
const failedWrite = Effect.fail(new EventSink.EventSinkWriteError({ eventCount: 1 }));
38493878
if (
38503879
owner === "failed-event" ||
38513880
owner === "release-after-failed-event" ||
3852-
owner === "retry-after-failed-release"
3881+
owner === "retry-after-failed-release" ||
3882+
owner === "detach-after-failed-event"
38533883
) {
38543884
yield* Ref.set(beforeUnchangedWrite, failedWrite);
38553885
}
38563886
yield* Queue.offer(queue!, {
38573887
type: "provider_thread.updated",
38583888
driver: CODEX_DRIVER,
3859-
providerThread: {
3860-
...providerThread,
3861-
nativeMetadata: { title: "stale title", acpInstructions: null },
3862-
},
3889+
providerThread: invalidation,
38633890
});
38643891
const completionEventId = yield* idAllocator.allocate.event({
38653892
threadId,
@@ -3923,9 +3950,13 @@ it.effect.each([
39233950
yield* manager.release({ providerSessionId, reason: "manual_shutdown" });
39243951
if (
39253952
owner === "release-after-failed-event" ||
3926-
owner === "retry-after-failed-release"
3953+
owner === "retry-after-failed-release" ||
3954+
owner === "detach-after-failed-event"
39273955
) {
3928-
const release = manager.release({ providerSessionId, reason: "manual_shutdown" });
3956+
const release =
3957+
owner === "detach-after-failed-event"
3958+
? manager.detach({ providerSessionId, threadId })
3959+
: manager.release({ providerSessionId, reason: "manual_shutdown" });
39293960
if (owner === "retry-after-failed-release") {
39303961
yield* Ref.set(beforeUnchangedWrite, failedWrite);
39313962
assert.isTrue(Exit.isFailure(yield* Effect.exit(release)));
@@ -3995,7 +4026,8 @@ it.effect.each([
39954026
owner === "failed-close" ||
39964027
owner === "failed-event" ||
39974028
owner === "release-after-failed-event" ||
3998-
owner === "retry-after-failed-release"
4029+
owner === "retry-after-failed-release" ||
4030+
owner === "detach-after-failed-event"
39994031
? {
40004032
...before,
40014033
nativeMetadata: {
@@ -4006,7 +4038,21 @@ it.effect.each([
40064038
}
40074039
: before,
40084040
);
4009-
}).pipe(Effect.provide(layerTest({ state, idleTimeoutMs: 1000, beforeUnchangedWrite })));
4041+
}).pipe(
4042+
Effect.provide(
4043+
layerTest({
4044+
state,
4045+
idleTimeoutMs: 1000,
4046+
beforeUnchangedWrite,
4047+
...(owner === "detach-after-failed-event"
4048+
? { capabilities: ExclusiveCapabilities }
4049+
: {}),
4050+
...(owner === "release-before-event"
4051+
? { readInstructionInvalidations: Ref.get(adapterInvalidations) }
4052+
: {}),
4053+
}),
4054+
),
4055+
);
40104056
}),
40114057
);
40124058

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

Lines changed: 32 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -941,7 +941,7 @@ export const layerWithOptions = (
941941
),
942942
),
943943
Effect.exit(writeReleasedBackgroundWorkEvents(input.releasedBackgroundTasks)),
944-
Effect.exit(flushInstructionInvalidations(input.entry)),
944+
Effect.exit(flushInstructionInvalidations(input.entry, input)),
945945
],
946946
{ concurrency: 1 },
947947
).pipe(Effect.flatMap(Exit.asVoidAll));
@@ -2245,7 +2245,11 @@ export const layerWithOptions = (
22452245

22462246
const persistInstructionInvalidation = Effect.fn(
22472247
"ProviderSessionManager.persistInstructionInvalidation",
2248-
)(function* (entry: LiveSessionEntry, offered: OrchestrationV2ProviderThread) {
2248+
)(function* (
2249+
entry: LiveSessionEntry,
2250+
offered: OrchestrationV2ProviderThread,
2251+
detachedThreadId?: ThreadId,
2252+
) {
22492253
const threadId = offered.appThreadId;
22502254
if (threadId === null || offered.nativeMetadata?.acpInstructions !== null) return;
22512255
// Idle updates outlive run subscribers; invalidate only the receipt, not newer thread state.
@@ -2255,7 +2259,12 @@ export const layerWithOptions = (
22552259
sessionKey(entry.runtime.providerSessionId),
22562260
);
22572261
if (current !== undefined && current.runtime !== entry.runtime) return true;
2258-
if (!(current?.attachedThreadIds ?? entry.attachedThreadIds).has(threadId)) return true;
2262+
if (
2263+
!(current?.attachedThreadIds ?? entry.attachedThreadIds).has(threadId) &&
2264+
(current !== undefined || detachedThreadId !== threadId)
2265+
) {
2266+
return true;
2267+
}
22592268
const projection = yield* projectionStore.getThreadRecords(threadId, ["providerThreads"]);
22602269
const stored = projection.providerThreads.find(
22612270
(candidate) => candidate.id === offered.id,
@@ -2291,10 +2300,27 @@ export const layerWithOptions = (
22912300
);
22922301
});
22932302

2294-
const flushInstructionInvalidations = (entry: LiveSessionEntry) =>
2295-
Effect.forEach([...entry.instructionInvalidations.values()], (offered) =>
2296-
Effect.exit(persistInstructionInvalidation(entry, offered)),
2303+
const flushInstructionInvalidations = Effect.fn(
2304+
"ProviderSessionManager.flushInstructionInvalidations",
2305+
)(function* (entry: LiveSessionEntry, release?: { readonly detachedThreadId?: ThreadId }) {
2306+
if (release !== undefined && entry.runtime.readInstructionInvalidations !== undefined) {
2307+
// The adapter can have invalidated a receipt before the event pump saw the update.
2308+
yield* entry.runtime.readInstructionInvalidations.pipe(
2309+
Effect.tap((invalidations) =>
2310+
Effect.sync(() => {
2311+
entry.instructionInvalidations.clear();
2312+
for (const invalidation of invalidations) {
2313+
entry.instructionInvalidations.set(invalidation.id, invalidation);
2314+
}
2315+
}),
2316+
),
2317+
entry.requestEventPermit.withPermits(1),
2318+
);
2319+
}
2320+
return yield* Effect.forEach([...entry.instructionInvalidations.values()], (offered) =>
2321+
Effect.exit(persistInstructionInvalidation(entry, offered, release?.detachedThreadId)),
22972322
).pipe(Effect.flatMap(Exit.asVoidAll));
2323+
});
22982324

22992325
const makeRetryStallWatch = (entry: LiveSessionEntry) => {
23002326
const runningRetries = new Map<ProviderTurnId, ProviderRetryItem>();

‎packages/provider-acp/src/server/adapter.ts‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8747,6 +8747,13 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* (
87478747
providerSession,
87488748
canResumeAfterRestart: canLoadSession || canResumeSession,
87498749
events: Stream.fromEffectRepeat(Queue.take(events)),
8750+
readInstructionInvalidations: Ref.get(providerThreadByNativeSessionId).pipe(
8751+
Effect.map((threads) =>
8752+
[...threads.values()].filter(
8753+
(thread) => thread.nativeMetadata?.acpInstructions === null,
8754+
),
8755+
),
8756+
),
87508757
...(flavor.getModelContextWindow === undefined
87518758
? {}
87528759
: {

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

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -656,6 +656,10 @@ export interface ProviderAdapterV2SessionRuntime {
656656
readonly events: Stream.Stream<ProviderAdapterV2Event, ProviderAdapterV2Error>;
657657
/** Manager runtimes broadcast independent subscriptions; adapters may expose only a single-consumer stream. */
658658
readonly subscribeEvents?: Effect.Effect<ProviderAdapterV2EventSubscription>;
659+
/** Instruction receipts invalidated by the adapter, including updates still queued in events. */
660+
readonly readInstructionInvalidations?: Effect.Effect<
661+
ReadonlyArray<OrchestrationV2ProviderThread>
662+
>;
659663
readonly hasPendingBackgroundWork?: Effect.Effect<boolean>;
660664
/** Root-subscription probe; replacement checks opt in to subagents owned by the live process. */
661665
readonly hasPendingBackgroundWorkForThread?: (

0 commit comments

Comments
 (0)