Skip to content

armgit / cindy

Public Imported from GitHub
0

Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。

fix(claude-code): 子代理在场时按请求边界判定父级输出完整性

Dash475c55b5a14a
diff --git a/packages/maker-core/src/agents/claude-code/generation-timing.test.ts b/packages/maker-core/src/agents/claude-code/generation-timing.test.ts
index 4f0e0ff31e..95b02b92a6 100644
--- a/packages/maker-core/src/agents/claude-code/generation-timing.test.ts
+++ b/packages/maker-core/src/agents/claude-code/generation-timing.test.ts
@@ -1303,6 +1303,11 @@ describe('claude generation pause boundaries', () => {
queue,
ctx,
);
+ translateSdkMessage(
+ { type: 'stream_event', event: { type: 'message_stop' } },
+ queue,
+ ctx,
+ );
expect(ctx.rt.generation.parentStreamedOutputIncomplete).toBe(false);
translateSdkMessage(
@@ -1493,6 +1498,11 @@ describe('claude generation pause boundaries', () => {
queue,
ctx,
);
+ translateSdkMessage(
+ { type: 'stream_event', event: { type: 'message_stop' } },
+ queue,
+ ctx,
+ );
translateSdkMessage(
{
type: 'stream_event',
@@ -1610,6 +1620,14 @@ describe('claude generation pause boundaries', () => {
queue,
ctx,
);
+ // The assistant envelope precedes its request's message_delta; only the
+ // request boundary proves the usage never came.
+ expect(ctx.rt.generation.parentStreamedOutputIncomplete).toBe(false);
+ translateSdkMessage(
+ { type: 'stream_event', event: { type: 'message_stop' } },
+ queue,
+ ctx,
+ );
expect(ctx.rt.generation.parentStreamedOutputIncomplete).toBe(true);
translateSdkMessage(
@@ -1660,6 +1678,110 @@ describe('claude generation pause boundaries', () => {
vi.useRealTimers();
});
+ it('keeps parent live tok/s when per-block assistant envelopes precede message_delta beside a background subagent', async () => {
+ vi.useFakeTimers();
+ vi.setSystemTime(1_000);
+ const ctx = createTranslatorCtx();
+ const queue = createAsyncQueue<AgentEvent>();
+ const send = (msg: Record<string, unknown>) => translateSdkMessage(msg as never, queue, ctx);
+ const main = (event: Record<string, unknown>) => send({ type: 'stream_event', event });
+ const child = (event: Record<string, unknown>) =>
+ send({ type: 'stream_event', parent_tool_use_id: 'toolu-bg', event });
+
+ // Claude Code yields one assistant envelope per finished content block,
+ // carrying message_start usage; the request's output usage arrives later.
+ main({ type: 'message_start', message: { id: 'msg_p1', model: 'claude-sonnet-4.5', usage: { input_tokens: 10, output_tokens: 3 } } });
+ main({
+ type: 'content_block_start',
+ index: 1,
+ content_block: { type: 'tool_use', id: 'toolu-bg', name: 'Agent', input: {} },
+ });
+ send({
+ type: 'assistant',
+ message: { id: 'msg_p1', content: [{ type: 'thinking', thinking: 'plan' }], usage: { output_tokens: 3 } },
+ });
+ // The tool_use block is last; its envelope lands right before message_delta.
+ vi.setSystemTime(1_500);
+ send({
+ type: 'assistant',
+ message: {
+ id: 'msg_p1',
+ content: [{ type: 'tool_use', id: 'toolu-bg', name: 'Agent', input: { run_in_background: true } }],
+ usage: { output_tokens: 3 },
+ },
+ });
+ expect(ctx.rt.generation.parentStreamedOutputIncomplete).toBe(false);
+ main({ type: 'message_delta', usage: { output_tokens: 100 } });
+ main({ type: 'message_stop' });
+ send({
+ type: 'user',
+ message: { content: [{ type: 'tool_result', tool_use_id: 'toolu-bg', content: 'Async agent launched successfully.' }] },
+ });
+
+ vi.setSystemTime(1_600);
+ main({ type: 'message_start', message: { id: 'msg_p2', model: 'claude-sonnet-4.5', usage: { input_tokens: 12, output_tokens: 3 } } });
+ child({ type: 'message_start', message: { id: 'msg_c1', model: 'claude-sonnet-4.5', usage: { input_tokens: 5 } } });
+ child({ type: 'message_delta', usage: { output_tokens: 400 } });
+ send({
+ type: 'assistant',
+ message: { id: 'msg_p2', content: [{ type: 'text', text: 'working on it' }], usage: { output_tokens: 3 } },
+ });
+ vi.setSystemTime(2_100);
+ main({ type: 'message_delta', usage: { output_tokens: 150 } });
+ main({ type: 'message_stop' });
+ child({ type: 'message_stop' });
+ expect(ctx.rt.generation.sawSubagent).toBe(true);
+ expect(ctx.rt.generation.parentStreamedOutputIncomplete).toBe(false);
+ expect(ctx.rt.generation.reliable).toBe(true);
+
+ send({
+ type: 'result',
+ stop_reason: 'end_turn',
+ total_cost_usd: 0,
+ num_turns: 2,
+ usage: { input_tokens: 27, output_tokens: 650 },
+ });
+ queue.end();
+ const events: AgentEvent[] = [];
+ for await (const event of queue) events.push(event);
+ const generating = events.filter(
+ (event) => event.type === 'status' && (event.data as { status?: string }).status === 'Generating...',
+ );
+ expect(generating.every((event) => (event.data as { generationReliable?: boolean }).generationReliable)).toBe(true);
+ expect(generating.at(-1)?.data).toMatchObject({
+ outputTokens: 250,
+ // 1000→1500 first request; the clock resumes at the async-launch
+ // tool_result (1500) and runs to the second message_delta (2100).
+ generationDurationMs: 1_100,
+ generationReliable: true,
+ });
+ const doneStatus = events.find(
+ (event) => event.type === 'status' && (event.data as { status?: string }).status === 'Done',
+ );
+ expect(doneStatus?.data).toMatchObject({ outputTokens: 250, generationReliable: true });
+ resetClaudeGenerationTiming(ctx.rt.generation);
+ vi.useRealTimers();
+ });
+
+ it('settles a parent request that never sent message_stop at the next main message_start', () => {
+ for (const withDelta of [true, false]) {
+ const ctx = createTranslatorCtx();
+ const queue = createAsyncQueue<AgentEvent>();
+ const main = (event: Record<string, unknown>) =>
+ translateSdkMessage({ type: 'stream_event', event } as never, queue, ctx);
+ main({ type: 'message_start', message: { id: 'msg_a', model: 'claude-sonnet-4.5', usage: { input_tokens: 10 } } });
+ translateSdkMessage(
+ { type: 'assistant', message: { id: 'msg_a', content: [{ type: 'text', text: 'a' }] } } as never,
+ queue,
+ ctx,
+ );
+ if (withDelta) main({ type: 'message_delta', usage: { output_tokens: 40 } });
+ main({ type: 'message_start', message: { id: 'msg_b', model: 'claude-sonnet-4.5', usage: { input_tokens: 10 } } });
+ expect(ctx.rt.generation.parentStreamedOutputIncomplete).toBe(!withDelta);
+ resetClaudeGenerationTiming(ctx.rt.generation);
+ }
+ });
+
it('does not freeze the next turn when a previous turn left an unresolved tool id', () => {
vi.useFakeTimers();
vi.setSystemTime(1_000);
diff --git a/packages/maker-core/src/agents/claude-code/index.ts b/packages/maker-core/src/agents/claude-code/index.ts
index 0f479b0671..614582c52e 100644
--- a/packages/maker-core/src/agents/claude-code/index.ts
+++ b/packages/maker-core/src/agents/claude-code/index.ts
@@ -2833,6 +2833,7 @@ export class ClaudeCodeAgent extends BaseAgent {
usageTracker.beginTurn();
resetClaudeGenerationTiming(runtimeState.generation);
runtimeState.activeUsageSegmentByParent.clear();
+ runtimeState.mainOpenRequest = null;
runtimeState.activeUsagePriceVariantByParent.clear();
runtimeState.pendingUsagePriceVariantByParent.clear();
turnState.nextRequestPriceVariant = priceVariant;
diff --git a/packages/maker-core/src/agents/claude-code/translator.ts b/packages/maker-core/src/agents/claude-code/translator.ts
index 37a6052db2..9ed98154b4 100644
--- a/packages/maker-core/src/agents/claude-code/translator.ts
+++ b/packages/maker-core/src/agents/claude-code/translator.ts
@@ -196,6 +196,13 @@ export interface RuntimeState {
streamRequestIdByParent: Map<string, string>;
/** Per-parent active provider request used to merge message_start + message_delta usage. */
activeUsageSegmentByParent: Map<string, string>;
+ /**
+ * 主流当前 provider 请求:main message_start 打开;main message_stop、下一次
+ * main message_start 或 result 收口。Claude Code 每个 content block 结束就先
+ * yield 完整 assistant,携带 output usage 的 message_delta 在整条回复生成完才到,
+ * 所以「本请求 streamed output 是否完整」只能在请求边界判定,不能在 assistant 到达时判定。
+ */
+ mainOpenRequest: { requestId?: string; sawAssistant: boolean } | null;
/** Price variant frozen for the active request of each parent stream. */
activeUsagePriceVariantByParent: Map<string, 'standard' | 'priority'>;
/** Price variant captured for the next request before its message_start arrives. */
@@ -223,6 +230,7 @@ export function newRuntimeState(): RuntimeState {
streamStopTokenByKey: new Map(),
streamRequestIdByParent: new Map(),
activeUsageSegmentByParent: new Map(),
+ mainOpenRequest: null,
activeUsagePriceVariantByParent: new Map(),
pendingUsagePriceVariantByParent: new Map(),
toolResultBatchSeq: 0,
@@ -255,6 +263,33 @@ function mainActiveSegmentHasOutput(ctx: TranslateContext): boolean {
return false;
}
+/**
+ * 在主流请求边界收口:本请求已产出 assistant 却没有 streamed output usage 时,
+ * 父级分子残缺,子代理在场的 live tok/s 必须 fail closed。随后摘掉当前 usage 段,
+ * 下一请求不得沿用本请求的 streamed output。
+ */
+function settleMainRequest(ctx: TranslateContext): void {
+ const open = ctx.rt.mainOpenRequest;
+ if (!open) return;
+ if (open.sawAssistant && !mainActiveSegmentHasOutput(ctx)) {
+ noteClaudeParentStreamedOutputIncomplete(ctx.rt.generation);
+ }
+ ctx.rt.activeUsageSegmentByParent.delete(CLAUDE_MAIN_USAGE_PARENT);
+ ctx.rt.mainOpenRequest = null;
+}
+
+/** 主流完整 assistant 只登记到所属请求;它早于该请求的 message_delta,不能在此判完整性。 */
+function observeMainAssistant(ctx: TranslateContext, requestId: string | undefined): void {
+ const open = ctx.rt.mainOpenRequest;
+ if (open && (!requestId || !open.requestId || open.requestId === requestId)) {
+ open.sawAssistant = true;
+ return;
+ }
+ // 没见过 message_start 的请求:不会再有可归属的 message_delta,分子必然残缺。
+ settleMainRequest(ctx);
+ noteClaudeParentStreamedOutputIncomplete(ctx.rt.generation);
+}
+
function applySubagentLiveReliability(ctx: TranslateContext): void {
if (!ctx.rt.generation.sawSubagent) return;
// Live status cannot compare against result.usage yet. A parent request that
@@ -1415,15 +1450,7 @@ function handleAssistant(
// 而父级 Agent 工具区间已从分母排除。记 sawSubagent,live tok/s 只用父级
// streamed output,不再把整轮计时打成不可靠。
if (parentToolUseId) observeClaudeSubagentStream(ctx, parentToolUseId);
- else {
- // Active __main__ segment is this request only. Keep it while checking
- // completeness, then detach so the next open interval cannot inherit
- // the previous request's streamed output.
- if (!mainActiveSegmentHasOutput(ctx)) {
- noteClaudeParentStreamedOutputIncomplete(ctx.rt.generation);
- }
- ctx.rt.activeUsageSegmentByParent.delete(CLAUDE_MAIN_USAGE_PARENT);
- }
+ else observeMainAssistant(ctx, assistantRequestId);
// 完整 child assistant 是实际执行模型的正式观测来源。SDK 不保证 child 的
// partial message_start 一定向外暴露,所以不能只靠 handleStreamEvent 填模型;
// 同时保持 main 新增的 loop guard 按 parent scope 读取同一张 stream model 表。
@@ -1796,6 +1823,11 @@ function handleStreamEvent(
return;
}
+ if (event.type === 'message_stop') {
+ if (!parentToolUseId) settleMainRequest(ctx);
+ return;
+ }
+
if (event.type === 'message_start') {
// 新 API call 开始, 清掉残留 thinking buffer。
// message_start 内 message.model 是这一 API call 真实用的模型,
@@ -1805,8 +1837,16 @@ function handleStreamEvent(
model: event.message?.model ?? ctx.getModel(),
});
ctx.turn.apiCalls += 1;
+ // 上一请求缺 message_stop(中断、重试)时,在新请求开段前补收口。
+ if (!parentToolUseId) settleMainRequest(ctx);
const segmentId = `claude:${++ctx.rt.usageSegmentSeq}:${parentStreamKey}`;
ctx.rt.activeUsageSegmentByParent.set(parentStreamKey, segmentId);
+ if (!parentToolUseId) {
+ ctx.rt.mainOpenRequest = {
+ ...(typeof eventRequestId === 'string' && eventRequestId ? { requestId: eventRequestId } : {}),
+ sawAssistant: false,
+ };
+ }
const priceVariant =
ctx.rt.pendingUsagePriceVariantByParent.get(parentStreamKey) ??
ctx.turn.nextRequestPriceVariant ??
@@ -2110,6 +2150,7 @@ function handleResult(
// turn end usage 锁定: Claude Code result.usage 是 session aggregate,
// 这里先转成 turn delta; tracker.endTurn 内部覆盖 currentTurn 然后返回 snapshot 再 reset。
+ settleMainRequest(ctx);
finalizeClaudeGeneration(ctx.rt.generation);
const liveTurnOutput = liveParentOutputTokens(
ctx,