Skip to content

Commit 332bda6

Browse files
committed
fix(server): release Claude fork frames after task registration
1 parent 5e427b2 commit 332bda6

2 files changed

Lines changed: 160 additions & 111 deletions

File tree

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

Lines changed: 105 additions & 91 deletions
Original file line numberDiff line numberDiff line change
@@ -17933,103 +17933,117 @@ describe("ClaudeAdapterV2 background wake turns", () => {
1793317933
),
1793417934
);
1793517935

17936-
it.effect("reports forked skill models without guessing their effort", () =>
17937-
Effect.scoped(
17938-
Effect.gen(function* () {
17939-
const harness = yield* makeWakeHarness;
17940-
const parentModel = "claude-opus-4-6";
17941-
yield* harness.runtime.startTurn(
17942-
makeClaudeTestTurnInput({
17943-
threadId: harness.threadId,
17944-
providerThread: harness.providerThread,
17945-
now: yield* DateTime.now,
17946-
attemptId: RunAttemptId.make("attempt-forked-skill-model"),
17947-
text: "Run two forked skills.",
17948-
attachments: [],
17949-
modelSelection: {
17950-
...CLAUDE_TEST_MODEL_SELECTION,
17951-
model: parentModel,
17952-
options: [{ id: "effort", value: "high" }],
17953-
},
17954-
}),
17955-
);
17956-
for (const frame of [
17957-
...["one", "two"].map((name, index) =>
17958-
claudeSdkFrame({
17959-
type: "system",
17960-
subtype: "task_started",
17961-
task_id: `fork-${name}`,
17962-
description: `/${name}`,
17963-
task_type: "local_agent",
17964-
skip_transcript: true,
17965-
ambient: true,
17966-
uuid: `00000000-0000-4000-8000-00000000024${index}`,
17967-
session_id: WAKE_NATIVE_SESSION,
17968-
}),
17969-
),
17970-
...["one", "two"].map((name, index) =>
17971-
claudeSdkFrame({
17972-
type: "system",
17973-
subtype: "task_notification",
17974-
task_id: `fork-${name}`,
17975-
status: "completed",
17976-
summary: `/${name}`,
17977-
uuid: `00000000-0000-4000-8000-00000000026${index}`,
17978-
session_id: WAKE_NATIVE_SESSION,
17979-
}),
17980-
),
17981-
...["one", "two"].map((name, index) =>
17982-
claudeSdkFrame({
17983-
type: "assistant",
17984-
parent_tool_use_id: `forked-command-${name}`,
17985-
agent_id: `fork-${name}`,
17986-
message: {
17987-
model: index === 0 ? "claude-haiku-4-5-20251001" : parentModel,
17988-
id: `msg_fork_${name}`,
17989-
type: "message",
17990-
role: "assistant",
17991-
content: [{ type: "text", text: "Done." }],
17936+
it.effect.each([false, true])(
17937+
"reports forked skill models without guessing their effort (frames before start: %s)",
17938+
(framesBeforeStart) =>
17939+
Effect.scoped(
17940+
Effect.gen(function* () {
17941+
const harness = yield* makeWakeHarness;
17942+
const parentModel = "claude-opus-4-6";
17943+
yield* harness.runtime.startTurn(
17944+
makeClaudeTestTurnInput({
17945+
threadId: harness.threadId,
17946+
providerThread: harness.providerThread,
17947+
now: yield* DateTime.now,
17948+
attemptId: RunAttemptId.make("attempt-forked-skill-model"),
17949+
text: "Run two forked skills.",
17950+
attachments: [],
17951+
modelSelection: {
17952+
...CLAUDE_TEST_MODEL_SELECTION,
17953+
model: parentModel,
17954+
options: [{ id: "effort", value: "high" }],
1799217955
},
17993-
uuid: `00000000-0000-4000-8000-00000000025${index}`,
17994-
session_id: WAKE_NATIVE_SESSION,
1799517956
}),
17996-
),
17997-
makeResultFrame({ uuid: "00000000-0000-4000-8000-000000000252", result: "Done." }),
17998-
]) {
17999-
yield* Queue.offer(harness.sdkMessages, frame);
18000-
}
18001-
yield* Queue.take(harness.terminalReceipts);
18002-
const subagents = harness.events.filter((event) => event.type === "subagent.updated");
18003-
const children = harness.events.filter((event) => event.type === "app_thread.created");
18004-
assert.lengthOf(children, 2);
18005-
for (const child of children) {
18006-
assert.isUndefined(
18007-
getModelSelectionStringOptionValue(child.appThread.modelSelection, "effort"),
1800817957
);
18009-
}
18010-
for (const [name, expectedModel] of [
18011-
["one", "claude-haiku-4-5"],
18012-
["two", parentModel],
18013-
] as const) {
18014-
const task = subagents.findLast(
18015-
(event) => event.subagent.nativeTaskRef?.nativeId === `fork-${name}`,
18016-
)?.subagent;
18017-
assert.equal(task?.model, expectedModel);
18018-
assert.equal(task?.modelSelection?.model, expectedModel);
18019-
assert.equal(task?.status, "completed");
18020-
assert.isUndefined(getModelSelectionStringOptionValue(task?.modelSelection, "effort"));
18021-
}
18022-
}).pipe(
18023-
Effect.provide(
18024-
Layer.mergeAll(
18025-
IdAllocator.layer,
18026-
McpProviderSessions.layer,
18027-
NodeServices.layer,
18028-
NodeCrypto.layer,
17958+
const tasks = [
17959+
{ id: "first-one", command: "one", model: "claude-haiku-4-5" },
17960+
{ id: "first-two", command: "two", model: parentModel },
17961+
{ id: "second-one", command: "one", model: parentModel },
17962+
{ id: "second-two", command: "two", model: "claude-haiku-4-5" },
17963+
];
17964+
let uuidOrdinal = 240;
17965+
const uuid = () => `00000000-0000-4000-8000-${String(++uuidOrdinal).padStart(12, "0")}`;
17966+
for (const round of [tasks.slice(0, 2), tasks.slice(2)]) {
17967+
const starts = round.map(({ id, command }) =>
17968+
claudeSdkFrame({
17969+
type: "system",
17970+
subtype: "task_started",
17971+
task_id: id,
17972+
description: `/${command}`,
17973+
task_type: "local_agent",
17974+
skip_transcript: true,
17975+
ambient: true,
17976+
uuid: uuid(),
17977+
session_id: WAKE_NATIVE_SESSION,
17978+
}),
17979+
);
17980+
const completions = round.map(({ id, command }) =>
17981+
claudeSdkFrame({
17982+
type: "system",
17983+
subtype: "task_notification",
17984+
task_id: id,
17985+
status: "completed",
17986+
summary: `/${command}`,
17987+
uuid: uuid(),
17988+
session_id: WAKE_NATIVE_SESSION,
17989+
}),
17990+
);
17991+
const assistants = round.map(({ id, command, model }) =>
17992+
claudeSdkFrame({
17993+
type: "assistant",
17994+
parent_tool_use_id: `forked-command-${command}`,
17995+
agent_id: id,
17996+
message: {
17997+
model: model === parentModel ? model : "claude-haiku-4-5-20251001",
17998+
id: `msg_fork_${id}`,
17999+
type: "message",
18000+
role: "assistant",
18001+
content: [{ type: "text", text: `Done ${id}.` }],
18002+
},
18003+
uuid: uuid(),
18004+
session_id: WAKE_NATIVE_SESSION,
18005+
}),
18006+
);
18007+
for (const frame of framesBeforeStart
18008+
? [...assistants, ...starts, ...completions]
18009+
: [...starts, ...completions, ...assistants]) {
18010+
yield* Queue.offer(harness.sdkMessages, frame);
18011+
}
18012+
}
18013+
yield* Queue.offer(
18014+
harness.sdkMessages,
18015+
makeResultFrame({ uuid: uuid(), result: "Done." }),
18016+
);
18017+
yield* Queue.take(harness.terminalReceipts);
18018+
const subagents = harness.events.filter((event) => event.type === "subagent.updated");
18019+
const children = harness.events.filter((event) => event.type === "app_thread.created");
18020+
assert.lengthOf(children, tasks.length);
18021+
for (const child of children) {
18022+
assert.isUndefined(
18023+
getModelSelectionStringOptionValue(child.appThread.modelSelection, "effort"),
18024+
);
18025+
}
18026+
for (const { id, model: expectedModel } of tasks) {
18027+
const task = subagents.findLast(
18028+
(event) => event.subagent.nativeTaskRef?.nativeId === id,
18029+
)?.subagent;
18030+
assert.isDefined(task?.childThreadId);
18031+
assert.equal(task?.model, expectedModel);
18032+
assert.equal(task?.modelSelection?.model, expectedModel);
18033+
assert.equal(task?.status, "completed");
18034+
assert.isUndefined(getModelSelectionStringOptionValue(task?.modelSelection, "effort"));
18035+
}
18036+
}).pipe(
18037+
Effect.provide(
18038+
Layer.mergeAll(
18039+
IdAllocator.layer,
18040+
McpProviderSessions.layer,
18041+
NodeServices.layer,
18042+
NodeCrypto.layer,
18043+
),
1802918044
),
1803018045
),
1803118046
),
18032-
),
1803318047
);
1803418048

1803518049
it.effect("resolves a subagent's model and effort against the instance's custom models", () =>

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

Lines changed: 55 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -9795,16 +9795,21 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
97959795

97969796
const forkToolUseId = parentToolUseIdFromSdkMessage(message);
97979797
const forkAgentId = text(field(message, "agent_id"));
9798-
if (
9799-
forkToolUseId?.startsWith("forked-command-") === true &&
9800-
forkAgentId !== undefined &&
9801-
(yield* Ref.get(sessionSubagentsByTaskId)).has(forkAgentId)
9802-
) {
9803-
yield* Ref.update(sessionSubagentTaskIdsByToolUseId, (current) =>
9804-
current.get(forkToolUseId) === forkAgentId
9805-
? current
9806-
: new Map(current).set(forkToolUseId, forkAgentId),
9807-
);
9798+
if (forkToolUseId?.startsWith("forked-command-") === true && forkAgentId !== undefined) {
9799+
const registered = (yield* Ref.get(sessionSubagentsByTaskId)).has(forkAgentId);
9800+
if (!registered) context.subagentsByToolUseId.delete(forkToolUseId);
9801+
yield* Ref.update(sessionSubagentTaskIdsByToolUseId, (current) => {
9802+
if (registered) {
9803+
return current.get(forkToolUseId) === forkAgentId
9804+
? current
9805+
: new Map(current).set(forkToolUseId, forkAgentId);
9806+
}
9807+
// Slash-command IDs are reused; an early frame must not reach the previous run.
9808+
if (!current.has(forkToolUseId)) return current;
9809+
const next = new Map(current);
9810+
next.delete(forkToolUseId);
9811+
return next;
9812+
});
98089813
}
98099814

98109815
if (message.type === "stream_event" && !message.parent_tool_use_id) {
@@ -10206,6 +10211,8 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
1020610211
yield* emitContextUsage(context, stream.usage);
1020710212
}
1020810213
}
10214+
}
10215+
if (message.type === "assistant") {
1020910216
const parentToolUseId = message.parent_tool_use_id;
1021010217
const snapshotModel =
1021110218
typeof message.message.model === "string" ? message.message.model.trim() : "";
@@ -10942,23 +10949,51 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* (
1094210949
(message.subtype !== "task_started" &&
1094310950
message.subtype !== "task_progress" &&
1094410951
message.subtype !== "task_notification") ||
10945-
message.tool_use_id === undefined ||
1094610952
!(yield* Ref.get(sessionSubagentsByTaskId)).has(message.task_id)
1094710953
) {
1094810954
return [];
1094910955
}
10950-
const toolUseId = message.tool_use_id;
1095110956
const taskId = message.task_id;
10952-
yield* Ref.update(sessionSubagentTaskIdsByToolUseId, (current) =>
10953-
current.get(toolUseId) === taskId ? current : new Map(current).set(toolUseId, taskId),
10954-
);
10955-
return yield* Ref.modify(pendingSubagentFramesByToolUseId, (current) => {
10956-
const frames = current.get(toolUseId);
10957-
if (frames === undefined) {
10958-
return [[] as ReadonlyArray<SDKMessage>, current] as const;
10957+
const toolUseIds = new Set<string>();
10958+
if (message.tool_use_id !== undefined) toolUseIds.add(message.tool_use_id);
10959+
if (message.subtype === "task_started") {
10960+
for (const [toolUseId, frames] of yield* Ref.get(pendingSubagentFramesByToolUseId)) {
10961+
if (
10962+
toolUseId.startsWith("forked-command-") &&
10963+
frames.some((frame) => text(field(frame, "agent_id")) === taskId)
10964+
) {
10965+
toolUseIds.add(toolUseId);
10966+
}
1095910967
}
10968+
}
10969+
if (toolUseIds.size === 0) return [];
10970+
yield* Ref.update(sessionSubagentTaskIdsByToolUseId, (current) => {
10971+
if ([...toolUseIds].every((toolUseId) => current.get(toolUseId) === taskId))
10972+
return current;
10973+
const next = new Map(current);
10974+
for (const toolUseId of toolUseIds) next.set(toolUseId, taskId);
10975+
return next;
10976+
});
10977+
return yield* Ref.modify(pendingSubagentFramesByToolUseId, (current) => {
10978+
if (current.size === 0) return [[] as ReadonlyArray<SDKMessage>, current] as const;
10979+
const frames: Array<SDKMessage> = [];
1096010980
const next = new Map(current);
10961-
next.delete(toolUseId);
10981+
for (const toolUseId of toolUseIds) {
10982+
const pending = current.get(toolUseId);
10983+
if (pending === undefined) continue;
10984+
const remaining = pending.filter((frame) => {
10985+
if (
10986+
toolUseId === message.tool_use_id ||
10987+
text(field(frame, "agent_id")) === taskId
10988+
) {
10989+
frames.push(frame);
10990+
return false;
10991+
}
10992+
return true;
10993+
});
10994+
if (remaining.length === 0) next.delete(toolUseId);
10995+
else next.set(toolUseId, remaining);
10996+
}
1096210997
return [frames, next] as const;
1096310998
});
1096410999
});

0 commit comments

Comments
 (0)