Skip to content

Commit 95045bb

Browse files
fix(server): retain normalized OpenCode turn usage
Accumulate owned step usage once and preserve partial or unavailable telemetry for failed, interrupted, or reconnected turns.
1 parent 9d5dd47 commit 95045bb

2 files changed

Lines changed: 274 additions & 1 deletion

File tree

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

Lines changed: 141 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -230,6 +230,147 @@ const makeOpenCodeRuntimeHarness = Effect.fn("makeOpenCodeRuntimeHarness")(funct
230230
});
231231

232232
describe("OpenCodeAdapterV2", () => {
233+
for (const ending of ["completed", "failed", "unresolved", "unavailable", "reconnect"] as const) {
234+
it.effect(`normalizes OpenCode step usage for ${ending} turns`, () =>
235+
Effect.gen(function* () {
236+
const nativeEvents = asyncEventStream();
237+
let promptId = "";
238+
const harness = yield* makeOpenCodeRuntimeHarness(`usage-${ending}`, "root", {
239+
event: { subscribe: async () => ({ stream: nativeEvents.stream }) },
240+
session: {
241+
create: async () => ({ data: { id: "root", time: { created: 1, updated: 1 } } }),
242+
promptAsync: async (input: { messageID: string }) => {
243+
promptId = input.messageID;
244+
return { data: true };
245+
},
246+
abort: async () => ({ data: true }),
247+
children: async () => ({ data: [] }),
248+
},
249+
});
250+
yield* harness.startTurn();
251+
const received = yield* harness.runtime.events.pipe(
252+
Stream.takeUntil((event) => event.type === "turn.terminal"),
253+
Stream.runCollect,
254+
Effect.forkScoped,
255+
);
256+
yield* Effect.promise(() =>
257+
nativeEvents.push({
258+
type: "message.updated",
259+
properties: {
260+
sessionID: "root",
261+
info: { id: promptId, role: "user", time: { created: 1 } },
262+
},
263+
}),
264+
);
265+
const step = (id: string, messageID = "assistant") => ({
266+
type: "message.part.updated",
267+
properties: {
268+
part: {
269+
type: "step-finish",
270+
id,
271+
sessionID: "root",
272+
messageID,
273+
reason: "stop",
274+
cost: 0.01,
275+
tokens: { input: 10, output: 5, reasoning: 2, cache: { read: 3, write: 4 } },
276+
},
277+
},
278+
});
279+
if (ending !== "unavailable") {
280+
yield* Effect.promise(() => nativeEvents.push(step("one")));
281+
yield* Effect.promise(() =>
282+
nativeEvents.push({
283+
type: "message.updated",
284+
properties: {
285+
sessionID: "root",
286+
info: {
287+
id: "assistant",
288+
role: "assistant",
289+
time: { created: 1 },
290+
parentID: promptId,
291+
},
292+
},
293+
}),
294+
);
295+
yield* Effect.promise(() => nativeEvents.push(step("one")));
296+
yield* Effect.promise(() => nativeEvents.push(step("two")));
297+
yield* Effect.promise(() =>
298+
nativeEvents.push({
299+
type: "message.part.removed",
300+
properties: { sessionID: "root", messageID: "assistant", partID: "one" },
301+
}),
302+
);
303+
yield* Effect.promise(() =>
304+
nativeEvents.push({
305+
type: "message.updated",
306+
properties: {
307+
sessionID: "root",
308+
info: {
309+
id: "old-assistant",
310+
role: "assistant",
311+
time: { created: 1 },
312+
parentID: "old-prompt",
313+
},
314+
},
315+
}),
316+
);
317+
yield* Effect.promise(() => nativeEvents.push(step("old", "old-assistant")));
318+
}
319+
if (ending === "unresolved")
320+
yield* Effect.promise(() => nativeEvents.push(step("unknown", "unknown-assistant")));
321+
if (ending === "reconnect") {
322+
yield* Effect.promise(() =>
323+
nativeEvents.push({ type: "server.connected", properties: {} }),
324+
);
325+
yield* Effect.promise(() =>
326+
nativeEvents.push({ type: "server.connected", properties: {} }),
327+
);
328+
}
329+
if (ending === "failed") {
330+
yield* Effect.promise(() =>
331+
nativeEvents.push({
332+
type: "session.error",
333+
properties: {
334+
sessionID: "root",
335+
error: { name: "UnknownError", data: { message: "failed" } },
336+
},
337+
}),
338+
);
339+
} else {
340+
yield* Effect.promise(() =>
341+
nativeEvents.push({
342+
type: "session.status",
343+
properties: { sessionID: "root", status: { type: "busy" } },
344+
}),
345+
);
346+
yield* Effect.promise(() =>
347+
nativeEvents.push({
348+
type: "session.status",
349+
properties: { sessionID: "root", status: { type: "idle" } },
350+
}),
351+
);
352+
}
353+
const events = yield* Fiber.join(received);
354+
const completed = events.findLast((event) => event.type === "provider_turn.updated");
355+
assert.deepEqual(
356+
completed?.providerTurn.turnTokenUsage,
357+
ending === "unavailable"
358+
? { usageStatus: "unavailable", usageScope: "main_agent", hasSubagents: false }
359+
: {
360+
usageStatus: ending === "completed" ? "complete" : "partial",
361+
usageScope: "main_agent",
362+
inputTokens: 34,
363+
cachedInputTokens: 6,
364+
cacheCreationTokens: 8,
365+
outputTokens: 14,
366+
reasoningTokens: 4,
367+
hasSubagents: false,
368+
},
369+
);
370+
}).pipe(Effect.provide(idAllocatorLayer), Effect.scoped),
371+
);
372+
}
373+
233374
for (const kind of ["permission", "question"] as const) {
234375
it.effect(`cancels an undelivered ${kind} reply at its deadline`, () =>
235376
Effect.gen(function* () {

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

Lines changed: 133 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -243,7 +243,57 @@ type TerminalTurnStatus = Extract<
243243
"completed" | "interrupted" | "failed" | "cancelled"
244244
>;
245245

246+
type OpenCodeStepUsage = Pick<
247+
Extract<OpenCodePart, { readonly type: "step-finish" }>,
248+
"id" | "tokens"
249+
>;
250+
251+
interface OpenCodeTurnTokenUsageAccumulator {
252+
readonly partIds: Set<string>;
253+
readonly promptMessageIds: Set<string>;
254+
readonly assistantOwnershipByMessageId: Map<string, "owned" | "other" | "unknown">;
255+
// Native removal does not undo usage. Keep unresolved counts until this turn settles.
256+
readonly unresolvedStepsByMessageId: Map<string, Map<string, OpenCodeStepUsage>>;
257+
inputTokens: number;
258+
cachedInputTokens: number;
259+
cacheCreationTokens: number;
260+
outputTokens: number;
261+
reasoningTokens: number;
262+
hasSubagents: boolean;
263+
complete: boolean;
264+
}
265+
266+
function makeOpenCodeTurnTokenUsageAccumulator(): OpenCodeTurnTokenUsageAccumulator {
267+
return {
268+
partIds: new Set(),
269+
promptMessageIds: new Set(),
270+
assistantOwnershipByMessageId: new Map(),
271+
unresolvedStepsByMessageId: new Map(),
272+
inputTokens: 0,
273+
cachedInputTokens: 0,
274+
cacheCreationTokens: 0,
275+
outputTokens: 0,
276+
reasoningTokens: 0,
277+
hasSubagents: false,
278+
complete: true,
279+
};
280+
}
281+
282+
function accumulateOpenCodeStepUsage(
283+
accumulator: OpenCodeTurnTokenUsageAccumulator,
284+
part: OpenCodeStepUsage,
285+
): void {
286+
if (accumulator.partIds.has(part.id)) return;
287+
accumulator.partIds.add(part.id);
288+
accumulator.inputTokens += part.tokens.input + part.tokens.cache.read + part.tokens.cache.write;
289+
accumulator.cachedInputTokens += part.tokens.cache.read;
290+
accumulator.cacheCreationTokens += part.tokens.cache.write;
291+
accumulator.outputTokens += part.tokens.output + part.tokens.reasoning;
292+
accumulator.reasoningTokens += part.tokens.reasoning;
293+
}
294+
246295
interface ActiveOpenCodeTurn {
296+
readonly usage: OpenCodeTurnTokenUsageAccumulator;
247297
readonly isRoot: boolean;
248298
readonly threadId: ThreadId;
249299
readonly runId: ProviderAdapterV2TurnInput["runId"] | null;
@@ -998,6 +1048,7 @@ export function makeOpenCodeAdapterV2(options: OpenCodeAdapterV2Options): Provid
9981048
};
9991049
const abortController = new AbortController();
10001050
let closing = false;
1051+
let hasConnected = false;
10011052

10021053
const emitProviderEvent = (event: ProviderAdapterV2Event) =>
10031054
Queue.offer(events, event).pipe(Effect.asVoid);
@@ -1127,6 +1178,32 @@ export function makeOpenCodeAdapterV2(options: OpenCodeAdapterV2Options): Provid
11271178
: providerRef(turn.nativeUserMessageId, "weak"),
11281179
status,
11291180
completedAt,
1181+
...(completedAt === null
1182+
? {}
1183+
: {
1184+
turnTokenUsage:
1185+
turn.usage.partIds.size === 0
1186+
? {
1187+
usageScope: "main_agent" as const,
1188+
usageStatus: "unavailable" as const,
1189+
hasSubagents: turn.usage.hasSubagents,
1190+
}
1191+
: {
1192+
usageScope: "main_agent" as const,
1193+
usageStatus:
1194+
status === "completed" &&
1195+
turn.usage.complete &&
1196+
turn.usage.unresolvedStepsByMessageId.size === 0
1197+
? ("complete" as const)
1198+
: ("partial" as const),
1199+
inputTokens: turn.usage.inputTokens,
1200+
cachedInputTokens: turn.usage.cachedInputTokens,
1201+
cacheCreationTokens: turn.usage.cacheCreationTokens,
1202+
outputTokens: turn.usage.outputTokens,
1203+
reasoningTokens: turn.usage.reasoningTokens,
1204+
hasSubagents: turn.usage.hasSubagents,
1205+
},
1206+
}),
11301207
};
11311208
Object.assign(turn.providerTurn, providerTurn);
11321209
state.providerTurns.set(String(providerTurn.id), providerTurn);
@@ -1272,6 +1349,7 @@ export function makeOpenCodeAdapterV2(options: OpenCodeAdapterV2Options): Provid
12721349
driver: OPENCODE_PROVIDER,
12731350
nativeItemId: part.id,
12741351
});
1352+
turn.usage.hasSubagents = true;
12751353
const input = toolInput(part);
12761354
const prompt = recordString(input, "prompt") ?? "";
12771355
const title = toolTitle(part) ?? recordString(input, "description") ?? null;
@@ -2223,6 +2301,7 @@ export function makeOpenCodeAdapterV2(options: OpenCodeAdapterV2Options): Provid
22232301
runAttemptId: null,
22242302
startedAt,
22252303
itemOrdinals: new Map(),
2304+
usage: makeOpenCodeTurnTokenUsageAccumulator(),
22262305
parts: new Map(),
22272306
partIdsByMessage: new Map(),
22282307
toolNamesByCallId: new Map(),
@@ -2373,7 +2452,30 @@ export function makeOpenCodeAdapterV2(options: OpenCodeAdapterV2Options): Provid
23732452
if (state === undefined) return;
23742453
const message = event.properties.info;
23752454
state.messageRoles.set(message.id, message.role);
2376-
if (message.role !== "user") return;
2455+
if (message.role === "assistant") {
2456+
const usage = state.activeTurn?.usage;
2457+
if (usage === undefined) return;
2458+
const prior = usage.assistantOwnershipByMessageId.get(message.id);
2459+
const ownership =
2460+
prior !== undefined && prior !== "unknown"
2461+
? prior
2462+
: !message.parentID
2463+
? "unknown"
2464+
: usage.promptMessageIds.has(message.parentID)
2465+
? "owned"
2466+
: "other";
2467+
usage.assistantOwnershipByMessageId.set(message.id, ownership);
2468+
if (ownership !== "unknown") {
2469+
if (ownership === "owned") {
2470+
for (const step of usage.unresolvedStepsByMessageId.get(message.id)?.values() ??
2471+
[]) {
2472+
accumulateOpenCodeStepUsage(usage, step);
2473+
}
2474+
}
2475+
usage.unresolvedStepsByMessageId.delete(message.id);
2476+
}
2477+
return;
2478+
}
23772479
const isNewUserMessage = !state.userMessageIds.includes(message.id);
23782480
if (isNewUserMessage) state.userMessageIds.push(message.id);
23792481
let turn = state.activeTurn;
@@ -2383,6 +2485,7 @@ export function makeOpenCodeAdapterV2(options: OpenCodeAdapterV2Options): Provid
23832485
const matchesAdmission =
23842486
turn !== null &&
23852487
(turn.admissionMessageId === null || turn.admissionMessageId === message.id);
2488+
if (turn !== null && matchesAdmission) turn.usage.promptMessageIds.add(message.id);
23862489
if (turn !== null && matchesAdmission && turn.nativeUserMessageId === null) {
23872490
turn.nativeUserMessageId = message.id;
23882491
yield* emitProviderTurn(state, turn, "running", null);
@@ -2405,6 +2508,22 @@ export function makeOpenCodeAdapterV2(options: OpenCodeAdapterV2Options): Provid
24052508
if (!turn.isRoot) yield* projectChildUserPart(state, turn, part);
24062509
return;
24072510
}
2511+
if (part.type === "step-finish") {
2512+
const usage = turn.usage;
2513+
const ownership = usage.assistantOwnershipByMessageId.get(part.messageID);
2514+
if (ownership === "owned") accumulateOpenCodeStepUsage(usage, part);
2515+
else if (
2516+
ownership === "unknown" ||
2517+
(ownership === undefined && !state.messageRoles.has(part.messageID))
2518+
) {
2519+
const steps =
2520+
usage.unresolvedStepsByMessageId.get(part.messageID) ??
2521+
new Map<string, OpenCodeStepUsage>();
2522+
steps.set(part.id, { id: part.id, tokens: part.tokens });
2523+
usage.unresolvedStepsByMessageId.set(part.messageID, steps);
2524+
}
2525+
return;
2526+
}
24082527
if (part.type === "tool") {
24092528
// Approval routing needs the tool name, without retaining its input and output.
24102529
turn.toolNamesByCallId.set(part.callID, part.tool);
@@ -2472,6 +2591,14 @@ export function makeOpenCodeAdapterV2(options: OpenCodeAdapterV2Options): Provid
24722591
payload: event,
24732592
});
24742593
switch (event.type) {
2594+
case "server.connected":
2595+
if (hasConnected) {
2596+
for (const state of threads.values()) {
2597+
if (state.activeTurn !== null) state.activeTurn.usage.complete = false;
2598+
}
2599+
}
2600+
hasConnected = true;
2601+
return;
24752602
case "message.updated":
24762603
yield* handleMessageUpdated(event);
24772604
yield* handleAssistantCompleted(event);
@@ -2971,6 +3098,7 @@ export function makeOpenCodeAdapterV2(options: OpenCodeAdapterV2Options): Provid
29713098
runAttemptId: turnInput.attemptId,
29723099
startedAt,
29733100
itemOrdinals: new Map(),
3101+
usage: makeOpenCodeTurnTokenUsageAccumulator(),
29743102
parts: new Map(),
29753103
partIdsByMessage: new Map(),
29763104
toolNamesByCallId: new Map(),
@@ -2990,6 +3118,8 @@ export function makeOpenCodeAdapterV2(options: OpenCodeAdapterV2Options): Provid
29903118
admissionSettled: Deferred.makeUnsafe<void>(),
29913119
admissionAbortController: new AbortController(),
29923120
};
3121+
if (turn.admissionMessageId !== null)
3122+
turn.usage.promptMessageIds.add(turn.admissionMessageId);
29933123
const admissionSettled = turn.admissionSettled;
29943124
const admissionAbortController = turn.admissionAbortController;
29953125
state.appThread = turnInput.appThread;
@@ -3157,6 +3287,8 @@ export function makeOpenCodeAdapterV2(options: OpenCodeAdapterV2Options): Provid
31573287
turn.idleDuringAdmission = false;
31583288
turn.admissionSettled = Deferred.makeUnsafe<void>();
31593289
turn.admissionAbortController = new AbortController();
3290+
if (turn.admissionMessageId !== null)
3291+
turn.usage.promptMessageIds.add(turn.admissionMessageId);
31603292
const admissionSettled = turn.admissionSettled;
31613293
const admissionAbortController = turn.admissionAbortController;
31623294
yield* sdkCall(

0 commit comments

Comments
 (0)