Skip to content
171 changes: 170 additions & 1 deletion apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -66,6 +66,7 @@ import * as Exit from "effect/Exit";
import * as FileSystem from "effect/FileSystem";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Logger from "effect/Logger";
import * as Option from "effect/Option";
import * as Path from "effect/Path";
import * as PubSub from "effect/PubSub";
Expand Down Expand Up @@ -3506,7 +3507,6 @@ describe("ClaudeAdapterV2 background wake turns", () => {
);
if (outcome === "release-before") {
yield* Deferred.succeed(release, undefined);
yield* Fiber.join(pending);
}
yield* harness.offerAndWait(
claudeSdkFrame({
Expand All @@ -3523,6 +3523,9 @@ describe("ClaudeAdapterV2 background wake turns", () => {
} else if (outcome === "release-after") {
yield* Deferred.succeed(release, undefined);
yield* Fiber.join(pending);
} else if (outcome === "release-before") {
// Held until the compaction ended.
yield* Fiber.join(pending);
}
// Flush the budget update through the event stream before trying again.
yield* harness.offerAndWait(
Expand Down Expand Up @@ -3593,6 +3596,172 @@ describe("ClaudeAdapterV2 background wake turns", () => {
),
);

// Forks a steer and returns once the adapter holds it for the running compaction.
const holdSteerForCompaction = Effect.fnUntraced(function* (
harness: Effect.Success<typeof makeWakeHarness>,
input: {
readonly runId: ProviderAdapter.ProviderAdapterV2SteerInput["runId"];
readonly providerTurnId: ProviderAdapter.ProviderAdapterV2SteerInput["providerTurnId"];
readonly text: string;
},
) {
const held = yield* Deferred.make<void>();
const logger = Logger.make(({ message }) => {
if (String(message).includes("claude-steer-held-for-compaction")) {
Deferred.doneUnsafe(held, Effect.void);
}
});
const steer = yield* harness.runtime
.steerTurn({
threadId: harness.threadId,
runId: input.runId,
providerThread: harness.providerThread,
providerTurnId: input.providerTurnId,
message: {
createdBy: "user",
creationSource: "web",
messageId: MessageId.make(`compaction-${input.text}`),
text: input.text,
attachments: [],
},
})
.pipe(Effect.provide(Logger.layer([logger], { mergeWithExisting: true })), Effect.forkChild);
yield* Deferred.await(held);
return steer;
});

const startCompactingTurn = Effect.fnUntraced(function* (
harness: Effect.Success<typeof makeWakeHarness>,
attemptId: string,
) {
const idAllocator = yield* IdAllocator.IdAllocatorV2;
const input = makeClaudeTestTurnInput({
threadId: harness.threadId,
providerThread: harness.providerThread,
now: yield* DateTime.now,
attemptId: RunAttemptId.make(attemptId),
text: "Keep going.",
attachments: [],
});
yield* harness.runtime.startTurn(input);
yield* harness.offerAndWait(
claudeSdkFrame({
type: "system",
subtype: "status",
status: "compacting",
uuid: "00000000-0000-4000-8000-000000000821",
session_id: WAKE_NATIVE_SESSION,
}),
);
return {
runId: input.runId,
providerTurnId: idAllocator.derive.providerTurn({
driver: ClaudeAdapterV2.CLAUDE_PROVIDER,
nativeTurnId: `turn:${input.attemptId}`,
}),
};
});

// regression: #25796 a `now` steer offered mid-compaction aborts the compaction
it.effect("holds steers sent during compaction until the compaction ends", () =>
Effect.gen(function* () {
const harness = yield* makeWakeHarness;
const turn = yield* startCompactingTurn(harness, "steer-during-compaction");
const pending = [];
for (const text of ["First steer.", "Second steer."]) {
pending.push(yield* holdSteerForCompaction(harness, { ...turn, text }));
}
assert.lengthOf(
harness.offeredMessages,
1,
"a steer sent while compacting reached Claude before the compaction ended",
);
// Settled while held, so the thread's outbox is free for a Stop.
yield* Fiber.joinAll(pending);
yield* harness.offerAndWait(
claudeSdkFrame({
type: "system",
subtype: "status",
status: null,
compact_result: "success",
uuid: "00000000-0000-4000-8000-000000000822",
session_id: WAKE_NATIVE_SESSION,
}),
);
const steers = harness.offeredMessages.slice(1);
assert.deepEqual(
steers.map((message) => message.priority),
["now", "now"],
);
assert.match(encodeJsonString(steers[0]?.message.content), /First steer/);
assert.match(encodeJsonString(steers[1]?.message.content), /Second steer/);
}).pipe(
Effect.provide(
Layer.mergeAll(
IdAllocator.layer,
McpProviderSessions.layer,
NodeServices.layer,
NodeCrypto.layer,
),
),
),
);

it.effect("sends a steer held for compaction before the turn is stopped", () =>
Effect.gen(function* () {
let offeredAtInterrupt: number | undefined;
const harness = yield* makeWakeHarnessWithOptions({
close: (sdkMessages) => Queue.shutdown(sdkMessages),
interrupt: Effect.sync(() => {
offeredAtInterrupt = harness.offeredMessages.length;
}),
});
const turn = yield* startCompactingTurn(harness, "steer-then-stop-during-compaction");
const steer = yield* holdSteerForCompaction(harness, { ...turn, text: "Then stop." });
yield* harness.runtime.interruptTurn({
providerThread: harness.providerThread,
providerTurnId: turn.providerTurnId,
});
assert.equal(offeredAtInterrupt, 2);
yield* Fiber.join(steer);
const terminal = yield* Queue.take(harness.terminalReceipts);
assert.equal(terminal.status, "interrupted");
assert.match(encodeJsonString(harness.offeredMessages[1]?.message.content), /Then stop/);
}).pipe(
Effect.provide(
Layer.mergeAll(
IdAllocator.layer,
McpProviderSessions.layer,
NodeServices.layer,
NodeCrypto.layer,
),
),
),
);

it.effect("does not send a held steer once its turn has ended", () =>
Effect.gen(function* () {
const harness = yield* makeWakeHarness;
const turn = yield* startCompactingTurn(harness, "turn-ends-during-compaction");
const steer = yield* holdSteerForCompaction(harness, { ...turn, text: "Too late." });
yield* harness.offerAndWait(
makeResultFrame({ uuid: "00000000-0000-4000-8000-000000000823", result: "Done." }),
);
yield* Fiber.join(steer);
yield* Queue.take(harness.terminalReceipts);
assert.lengthOf(harness.offeredMessages, 1);
}).pipe(
Effect.provide(
Layer.mergeAll(
IdAllocator.layer,
McpProviderSessions.layer,
NodeServices.layer,
NodeCrypto.layer,
),
),
),
);

const attachmentBudgetOutcomes = [
"resume",
"legacy",
Expand Down
Loading
Loading