Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

Studio: time a continued reply as the whole answer, not just its last pass (#16451)

oobabooga92aaa2680847
diff --git a/studio/frontend/src/components/assistant-ui/thread.tsx b/studio/frontend/src/components/assistant-ui/thread.tsx
index 125ee4dee14..4d2a0a86999 100644
--- a/studio/frontend/src/components/assistant-ui/thread.tsx
+++ b/studio/frontend/src/components/assistant-ui/thread.tsx
@@ -144,6 +144,7 @@ import {
stopRecoveredRun,
pythonToolRunsInStudio,
withAttachmentOriginal,
+ priorPassTiming,
} from "@/features/chat";
import { TooltipIconButton } from "@/components/assistant-ui/tooltip-icon-button";
import {
@@ -7877,6 +7878,8 @@ function useContinuation() {
...(geminiReplayTurns.length > 0 ? { geminiReplayTurns } : {}),
...providerCompactionContinuationFields(metadata),
};
+ const priorTiming = priorPassTiming(metadata);
+ if (priorTiming) request.priorTiming = priorTiming;
return aui.thread().startRun({
parentId: parent,
runConfig: {
diff --git a/studio/frontend/src/features/chat/api/chat-adapter.ts b/studio/frontend/src/features/chat/api/chat-adapter.ts
index d26f06f51a2..159f0776f50 100644
--- a/studio/frontend/src/features/chat/api/chat-adapter.ts
+++ b/studio/frontend/src/features/chat/api/chat-adapter.ts
@@ -166,6 +166,12 @@ import {
type QueuedModelCapabilities,
} from "../utils/queued-model-capabilities";
import type { MessageTiming, ToolCallMessagePart } from "@assistant-ui/core";
+import {
+ addPass,
+ type PriorPassTiming,
+ withPriorServerTimings,
+ withPriorTiming,
+} from "../utils/continued-timing";
import type { ChatModelAdapter } from "@assistant-ui/react";
import { parsePartialJsonObject } from "assistant-stream/utils";
import {
@@ -5723,6 +5729,9 @@ export function createOpenAIStreamAdapter(
// A seed that ends inside the thought: the next reasoning delta extends it.
const resumesInsideThought = Boolean(resumedThought) && !continuation?.partial;
let cumulativeText = continuationPartial;
+ const passText = () => cumulativeText.slice(continuationPartial.length);
+ const priorTiming = continuation?.priorTiming;
+ let passSoFar: (() => PriorPassTiming) | null = null;
const geminiContinuationReplay = (
final: boolean,
): GeminiContinuationReplay | undefined =>
@@ -5821,6 +5830,7 @@ export function createOpenAIStreamAdapter(
// Provisional reason per yield since aborts skip terminal yields; a reported window outranks it.
const liveCustom = () => ({
...reasoningDurationTracker.metadata(),
+ resumeTiming: passSoFar ? addPass(priorTiming, passSoFar()) : priorTiming,
openaiCodexReasoning: codexReasoningLedger,
openaiResponsesReasoning: openAIResponsesReasoningLedger,
contextTruncation,
@@ -6378,6 +6388,24 @@ export function createOpenAIStreamAdapter(
};
// llama.cpp output count, including reasoning.
let windowCount: number | null = null;
+ let liveServerTimings: ServerTimings | undefined;
+ passSoFar = () => {
+ const now = Date.now();
+ return {
+ totalStreamTime: now - streamStartTime,
+ totalChunks,
+ toolCallCount: toolCallParts.length,
+ ...(windowCount !== null
+ ? { tokenCount: windowCount }
+ : cumulativeText.length > continuationPartial.length
+ ? { tokenCount: Math.max(1, Math.round((cumulativeText.length - continuationPartial.length) / 4)) }
+ : {}),
+ ...(firstTokenTime !== undefined ? { firstTokenTime } : {}),
+ startedAt: streamStartTime,
+ durationMs: now - streamStartTime,
+ ...(liveServerTimings ? { serverTimings: { ...liveServerTimings } as unknown as Record<string, number> } : {}),
+ };
+ };
// Colab-style proxies can swallow fetch aborts, so also POST /inference/cancel explicitly.
const onAbortCancel = () => {
@@ -6468,9 +6496,12 @@ export function createOpenAIStreamAdapter(
externalProvider?.name ??
(isExternalRequest ? "External provider" : "Local model"),
providerType: externalProvider?.providerType ?? "local",
- startedAt: streamStartTime,
+ startedAt: priorTiming?.startedAt ?? streamStartTime,
finishedAt,
- durationMs: finishedAt - streamStartTime,
+ durationMs:
+ (priorTiming ? (priorTiming.durationMs ?? priorTiming.totalStreamTime) : 0) +
+ finishedAt -
+ streamStartTime,
...(sandboxSessionId ? { sessionId: sandboxSessionId } : {}),
cancelId,
toolCalls: Array.from(
@@ -7826,6 +7857,7 @@ export function createOpenAIStreamAdapter(
| undefined;
// Timings can arrive without usage.
windowCount = windowEvidenceCount(chunkTimings) ?? windowCount;
+ if (chunkTimings && chunkTimings.diffusion !== true) liveServerTimings = chunkTimings;
// OpenAI usage may arrive in an empty trailing chunk or on the terminal Codex chunk.
if (chunk.usage) {
serverMetadata = {
@@ -8605,8 +8637,12 @@ export function createOpenAIStreamAdapter(
const meta = serverMetadata;
const finalTokenCount =
- meta?.usage?.completion_tokens ?? estimateTokenCount(cumulativeText);
- const finalTokPerSec = meta?.timings?.predicted_per_second;
+ meta?.usage?.completion_tokens ?? estimateTokenCount(passText());
+ const finalServerTimings = withPriorServerTimings(
+ meta?.timings,
+ priorTiming?.serverTimings,
+ );
+ const finalTokPerSec = finalServerTimings?.predicted_per_second;
const serverPromptEvalTime = meta?.timings?.prompt_ms;
// Prefer llama-server timings; fall back to provider usage envelope.
@@ -8751,14 +8787,18 @@ export function createOpenAIStreamAdapter(
"Compaction needs the conversation archive and the default checkpoint policy.",
});
}
- const finalTiming = buildTiming(
- streamStartTime,
- totalChunks,
- // What the user waited, as a resumed run records it. Server prompt eval has its own row.
- firstTokenTime ?? serverPromptEvalTime,
- finishedAt - streamStartTime,
- finalTokenCount,
- toolCallParts.length,
+ const finalTiming = withPriorTiming(
+ buildTiming(
+ streamStartTime,
+ totalChunks,
+ // What the user waited, as a resumed run records it. Server prompt eval has its own row.
+ firstTokenTime ?? serverPromptEvalTime,
+ finishedAt - streamStartTime,
+ finalTokenCount,
+ toolCallParts.length,
+ finalTokPerSec,
+ ),
+ priorTiming,
finalTokPerSec,
);
@@ -8802,7 +8842,7 @@ export function createOpenAIStreamAdapter(
: undefined,
// Persisted refusal flag driving the two-pass prune.
anthropicRefusal: anthropicRefusalSeen || undefined,
- serverTimings: meta?.timings ?? undefined,
+ serverTimings: finalServerTimings ?? undefined,
stopReason: lastFinishReason ?? undefined,
contextUsage: meta?.usage
? {
@@ -8953,13 +8993,16 @@ export function createOpenAIStreamAdapter(
closeReasoningContent();
const partialText = mergeContinuation(cumulativeText, { final: true });
const partialContent = buildAssistantContent(partialText);
- const partialTiming = buildTiming(
- streamStartTime,
- totalChunks,
- firstTokenTime,
- Date.now() - streamStartTime,
- estimateTokenCount(partialText),
- toolCallParts.length,
+ const partialTiming = withPriorTiming(
+ buildTiming(
+ streamStartTime,
+ totalChunks,
+ firstTokenTime,
+ Date.now() - streamStartTime,
+ estimateTokenCount(continuation ? passText() : partialText),
+ toolCallParts.length,
+ ),
+ priorTiming,
);
yield {
content: partialContent,
@@ -8993,6 +9036,7 @@ export function createOpenAIStreamAdapter(
),
},
timing: partialTiming,
+ resumeTiming: passSoFar ? addPass(priorTiming, passSoFar()) : priorTiming,
...generationCustom(),
},
},
diff --git a/studio/frontend/src/features/chat/index.ts b/studio/frontend/src/features/chat/index.ts
index 192a1c63ef7..92628eeb04a 100644
--- a/studio/frontend/src/features/chat/index.ts
+++ b/studio/frontend/src/features/chat/index.ts
@@ -424,6 +424,7 @@ export { showForkCreatedToast, showForkFailedToast } from "./utils/fork-toast";
export { clearAllChats, countAllChats } from "./utils/clear-all-chats";
export { stopRecoveredRun } from "./utils/chat-generation-recovery";
export { readIncompleteInfo } from "./utils/continuation";
+export { priorPassTiming } from "./utils/continued-timing";
export { offerToDeleteKeptSandboxes } from "./utils/offer-kept-sandbox-files";
export { pasteClipboardFiles } from "./utils/clipboard-files";
export {
diff --git a/studio/frontend/src/features/chat/utils/continuation.ts b/studio/frontend/src/features/chat/utils/continuation.ts
index 12d1ec18df9..08ea3fcb3ab 100644
--- a/studio/frontend/src/features/chat/utils/continuation.ts
+++ b/studio/frontend/src/features/chat/utils/continuation.ts
@@ -10,6 +10,7 @@ import {
parseGeminiThoughtReplayParts,
} from "../gemini-thought-replay.ts";
import type { ProviderCompactionContentPart } from "../types/api";
+import { type PriorPassTiming, readPriorPassTiming } from "./continued-timing.ts";
import { providerCompactionPart } from "./provider-compaction.ts";
/** Resuming a response that stopped early (`length`, `cancelled`, `interrupted`): the conversation is re-sent
@@ -366,6 +367,7 @@ export type ContinuationRequest = {
providerCompactionProviderType?: string;
providerCompactionModelId?: string;
providerCompactionConnectionKey?: string;
+ priorTiming?: PriorPassTiming;
};
type ProviderCompactionContinuationFields = Pick<
@@ -443,6 +445,7 @@ export function readContinuationRequest(
providerCompactionProviderType?: unknown;
providerCompactionModelId?: unknown;
providerCompactionConnectionKey?: unknown;
+ priorTiming?: unknown;
}
| undefined;
const partial = typeof request?.partial === "string" ? request.partial : "";
@@ -466,6 +469,7 @@ export function readContinuationRequest(
return null;
}
const duration = request?.reasoningDuration;
+ const priorTiming = readPriorPassTiming(request?.priorTiming);
return {
partial,
...(reasoning ? { reasoning } : {}),
@@ -482,6 +486,7 @@ export function readContinuationRequest(
...(answerParts.length > 0 ? { answerParts } : {}),
...(geminiReplayTurns.length > 0 ? { geminiReplayTurns } : {}),
...providerCompactionFields(request),
+ ...(priorTiming ? { priorTiming } : {}),
};
}
diff --git a/studio/frontend/src/features/chat/utils/continued-timing.ts b/studio/frontend/src/features/chat/utils/continued-timing.ts
new file mode 100644
index 00000000000..99aa1e1b6e0
--- /dev/null
+++ b/studio/frontend/src/features/chat/utils/continued-timing.ts
@@ -0,0 +1,154 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import type { MessageTiming } from "@assistant-ui/core";
+
+export type PriorPassTiming = {
+ totalStreamTime: number;
+ totalChunks: number;
+ toolCallCount: number;
+ tokenCount?: number;
+ firstTokenTime?: number;
+ durationMs?: number;
+ startedAt?: number;
+ serverTimings?: Record<string, number>;
+};
+
+function count(value: unknown): number | undefined {
+ return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+
+function record(value: unknown): Record<string, unknown> | undefined {
+ return value && typeof value === "object" && !Array.isArray(value)
+ ? (value as Record<string, unknown>)
+ : undefined;
+}
+
+function numbers(value: unknown): Record<string, number> | undefined {
+ const fields = record(value);
+ if (!fields) return undefined;
+ const kept = Object.entries(fields).filter(
+ (entry): entry is [string, number] => typeof entry[1] === "number" && Number.isFinite(entry[1]),
+ );
+ return kept.length > 0 ? Object.fromEntries(kept) : undefined;
+}
+
+// Stop retains the last streamed metadata, which has resumeTiming but no final timing.
+export function priorPassTiming(metadata: unknown): PriorPassTiming | undefined {
+ const message = record(metadata);
+ const custom = record(message?.custom);
+ const carried = readPriorPassTiming(custom?.resumeTiming);
+ if (carried) return carried;
+ const timing = record(custom?.timing) ?? record(message?.timing);
+ const details = record(custom?.responseDetails);
+ const serverTimings = record(custom?.serverTimings);
+ return readPriorPassTiming({
+ totalStreamTime: timing?.totalStreamTime,
+ totalChunks: timing?.totalChunks,
+ toolCallCount: timing?.toolCallCount,
+ tokenCount: timing?.tokenCount,
+ firstTokenTime: timing?.firstTokenTime,
+ durationMs: details?.durationMs,
+ startedAt: details?.startedAt,
+ serverTimings: serverTimings?.diffusion === true ? undefined : serverTimings,
+ });
+}
+
+export function readPriorPassTiming(value: unknown): PriorPassTiming | undefined {
+ const fields = record(value);
+ const totalStreamTime = count(fields?.totalStreamTime);
+ if (!fields || totalStreamTime === undefined) return undefined;
+ const optional = {
+ tokenCount: count(fields.tokenCount),
+ firstTokenTime: count(fields.firstTokenTime),
+ durationMs: count(fields.durationMs),
+ startedAt: count(fields.startedAt),
+ serverTimings: numbers(fields.serverTimings),
+ };
+ return {
+ totalStreamTime,
+ totalChunks: count(fields.totalChunks) ?? 0,
+ toolCallCount: count(fields.toolCallCount) ?? 0,
+ ...Object.fromEntries(Object.entries(optional).filter(([, v]) => v !== undefined)),
+ };
+}
+
+export function withPriorTiming(
+ timing: MessageTiming,
+ prior: PriorPassTiming | undefined,
+ tokensPerSecond?: number,
+): MessageTiming {
+ if (!prior) return timing;
+ const totalStreamTime = prior.totalStreamTime + (timing.totalStreamTime ?? 0);
+ const tokenCount =
+ prior.tokenCount !== undefined || timing.tokenCount !== undefined
+ ? (prior.tokenCount ?? 0) + (timing.tokenCount ?? 0)
+ : undefined;
+ return {
+ ...timing,
+ // Preserve start + duration = finish while excluding pauses between passes.
+ streamStartTime: timing.streamStartTime - prior.totalStreamTime,
+ firstTokenTime:
+ prior.firstTokenTime ??
+ (timing.firstTokenTime !== undefined ? prior.totalStreamTime + timing.firstTokenTime : undefined),
+ totalStreamTime,
+ tokenCount,
+ tokensPerSecond:
+ tokensPerSecond ??
+ (tokenCount !== undefined && totalStreamTime > 0 ? tokenCount / (totalStreamTime / 1000) : undefined),
+ totalChunks: prior.totalChunks + timing.totalChunks,
+ toolCallCount: prior.toolCallCount + timing.toolCallCount,
+ };
+}
+
+const ADDED = ["prompt_n", "prompt_ms", "cache_n", "predicted_n", "predicted_ms", "draft_n", "draft_n_accepted"];
+
+// Preserve llama.cpp's rate definition: decode steps / decode time, rather than tokens / wall time.
+export function withPriorServerTimings<T extends object>(
+ current: T | undefined,
+ prior: Record<string, number> | undefined,
+): T | undefined {
+ const now = current as Record<string, unknown> | undefined;
+ if (!now || !prior || now.diffusion === true) return current;
+ const value = (fields: Record<string, unknown>, key: string) => count(fields[key]) ?? 0;
+ const merged: Record<string, unknown> = { ...now };
+ for (const key of ADDED) {
+ if (key in now || key in prior) merged[key] = value(now, key) + value(prior, key);
+ }
+ for (const [rate, ms, n, perToken] of [
+ ["prompt_per_second", "prompt_ms", "prompt_n", "prompt_per_token_ms"],
+ ["predicted_per_second", "predicted_ms", "predicted_n", "predicted_per_token_ms"],
+ ] as const) {
+ const totalMs = value(merged, ms);
+ if (totalMs <= 0) continue;
+ merged[rate] = (value(now, rate) * value(now, ms) + value(prior, rate) * value(prior, ms)) / totalMs;
+ const tokens = value(merged, n);
+ if (tokens > 0) merged[perToken] = totalMs / tokens;
+ }
+ return merged as T;
+}
+
+export function addPass(prior: PriorPassTiming | undefined, pass: PriorPassTiming): PriorPassTiming {
+ if (!prior) return pass;
+ const optional = {
+ tokenCount:
+ prior.tokenCount !== undefined || pass.tokenCount !== undefined
+ ? (prior.tokenCount ?? 0) + (pass.tokenCount ?? 0)
+ : undefined,
+ firstTokenTime:
+ prior.firstTokenTime ??
+ (pass.firstTokenTime !== undefined ? prior.totalStreamTime + pass.firstTokenTime : undefined),
+ durationMs:
+ prior.durationMs !== undefined || pass.durationMs !== undefined
+ ? (prior.durationMs ?? prior.totalStreamTime) + (pass.durationMs ?? pass.totalStreamTime)
+ : undefined,
+ startedAt: prior.startedAt ?? pass.startedAt,
+ serverTimings: withPriorServerTimings(pass.serverTimings, prior.serverTimings) ?? prior.serverTimings,
+ };
+ return {
+ totalStreamTime: prior.totalStreamTime + pass.totalStreamTime,
+ totalChunks: prior.totalChunks + pass.totalChunks,
+ toolCallCount: prior.toolCallCount + pass.toolCallCount,
+ ...Object.fromEntries(Object.entries(optional).filter(([, v]) => v !== undefined)),
+ };
+}
diff --git a/studio/frontend/tests/continued-reply-timing.test.ts b/studio/frontend/tests/continued-reply-timing.test.ts
new file mode 100644
index 00000000000..e469a09a1d3
--- /dev/null
+++ b/studio/frontend/tests/continued-reply-timing.test.ts
@@ -0,0 +1,162 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import { replyFinishedTimestamp } from "../src/lib/message-timestamp.ts";
+
+import { readText } from "./helpers/kit.ts";
+
+const { addPass, priorPassTiming, readPriorPassTiming, withPriorServerTimings, withPriorTiming } = await import(
+ "../src/features/chat/utils/continued-timing.ts"
+);
+const { CONTINUATION_RUN_CONFIG_KEY, readContinuationRequest } = await import(
+ "../src/features/chat/utils/continuation.ts"
+);
+
+const firstPass = {
+ timing: { streamStartTime: 1000, firstTokenTime: 300, totalStreamTime: 4200, tokenCount: 128, totalChunks: 129, toolCallCount: 0 },
+ custom: {
+ timing: { streamStartTime: 1000, firstTokenTime: 300, totalStreamTime: 4200, tokenCount: 128, totalChunks: 129, toolCallCount: 0 },
+ serverTimings: {
+ prompt_n: 40, prompt_ms: 100, prompt_per_second: 400, cache_n: 0,
+ predicted_n: 128, predicted_ms: 3800, predicted_per_second: 127 / 3.8,
+ draft_n: 64, draft_n_accepted: 16,
+ },
+ responseDetails: { startedAt: 1000, finishedAt: 5200, durationMs: 4200 },
+ },
+};
+
+const secondPass = {
+ timing: { streamStartTime: 9000, firstTokenTime: 120, totalStreamTime: 348, tokenCount: 11, totalChunks: 12, toolCallCount: 0, tokensPerSecond: 31.6 },
+ serverTimings: {
+ prompt_n: 3, prompt_ms: 20, prompt_per_second: 150, cache_n: 168,
+ predicted_n: 11, predicted_ms: 300, predicted_per_second: 10 / 0.3,
+ } as Record<string, number>,
+};
+
+test("the resumed reply's figures are read from its metadata", () => {
+ const prior = priorPassTiming(firstPass);
+ assert.deepEqual(prior, {
+ totalStreamTime: 4200,
+ totalChunks: 129,
+ toolCallCount: 0,
+ tokenCount: 128,
+ firstTokenTime: 300,
+ durationMs: 4200,
+ startedAt: 1000,
+ serverTimings: firstPass.custom.serverTimings,
+ });
+ assert.equal(priorPassTiming({ custom: {} }), undefined, "no timing, nothing to carry");
+ assert.equal(priorPassTiming(undefined), undefined);
+ const diffusion = { ...firstPass, custom: { ...firstPass.custom, serverTimings: { diffusion: true, diffusion_steps: 8 } } };
+ assert.equal(priorPassTiming(diffusion)?.serverTimings, undefined);
+});
+
+test("the carried figures survive the run config and reject junk", () => {
+ const priorTiming = priorPassTiming(firstPass);
+ const request = readContinuationRequest({
+ custom: { [CONTINUATION_RUN_CONFIG_KEY]: { partial: "Once upon", priorTiming } },
+ });
+ assert.deepEqual(request?.priorTiming, priorTiming);
+ const junk = readContinuationRequest({
+ custom: { [CONTINUATION_RUN_CONFIG_KEY]: { partial: "Once upon", priorTiming: { totalStreamTime: "4s" } } },
+ });
+ assert.equal(junk?.priorTiming, undefined);
+ assert.equal(
+ readPriorPassTiming({ totalStreamTime: 10, tokenCount: -1, serverTimings: { predicted_n: Number.NaN } })?.tokenCount,
+ undefined,
+ );
+});
+
+test("a continued reply's tokens, time and speed cover the whole answer", () => {
+ const prior = priorPassTiming(firstPass);
+ const server = withPriorServerTimings(secondPass.serverTimings, prior?.serverTimings);
+ const timing = withPriorTiming(secondPass.timing, prior, server?.predicted_per_second);
+ assert.equal(timing.tokenCount, 139);
+ assert.equal(timing.totalStreamTime, 4548);
+ assert.equal(timing.firstTokenTime, 300, "the answer's first token came in the first pass");
+ assert.equal(timing.totalChunks, 141);
+ assert.ok(server);
+ assert.equal(server.predicted_n, 139);
+ assert.equal(server.predicted_ms, 4100);
+ assert.equal(server.prompt_n, 43);
+ assert.equal(server.draft_n, 64, "a pass without drafts adds none");
+ assert.equal(server.draft_n_accepted, 16);
+ assert.ok(Math.abs(server.predicted_per_second - (127 + 10) / 4.1) < 1e-9);
+ assert.equal(timing.tokensPerSecond, server.predicted_per_second);
+});
+
+test("a reply that was never continued keeps its own figures", () => {
+ const timing = withPriorTiming(secondPass.timing, undefined, 99);
+ assert.equal(timing, secondPass.timing);
+ assert.equal(withPriorServerTimings(secondPass.serverTimings, undefined), secondPass.serverTimings);
+ const diffusion = { diffusion: true, diffusion_steps: 8 };
+ assert.equal(withPriorServerTimings(diffusion, { predicted_n: 5 }), diffusion);
+});
+
+test("a failed continuation keeps its actual finish time after aggregating active duration", () => {
+ const timing = withPriorTiming(secondPass.timing, priorPassTiming(firstPass));
+ assert.equal(replyFinishedTimestamp({
+ status: { type: "incomplete" },
+ metadata: { custom: { timing } },
+ }), 9348);
+ assert.equal(timing.totalStreamTime, 4548);
+});
+
+test("a first pass with no token puts the first token in a later pass", () => {
+ const prior = { totalStreamTime: 2000, totalChunks: 0, toolCallCount: 0 };
+ const timing = withPriorTiming(secondPass.timing, prior);
+ assert.equal(timing.firstTokenTime, 2120);
+ assert.equal(timing.tokenCount, 11);
+});
+
+test("three passes add up when each Continue carries the passes before it", () => {
+ const pass = (ms: number, tokens: number, first: number, start: number) => ({
+ totalStreamTime: ms, totalChunks: tokens + 1, toolCallCount: 0, tokenCount: tokens, firstTokenTime: first,
+ startedAt: start, durationMs: ms,
+ serverTimings: { predicted_n: tokens, predicted_ms: ms - 50, predicted_per_second: (tokens - 1) / ((ms - 50) / 1000) },
+ });
+ const one = pass(500, 64, 120, 1000);
+ const two = addPass(one, pass(400, 64, 90, 9000));
+ const three = addPass(two, pass(300, 20, 80, 20000));
+ assert.equal(three.tokenCount, 148);
+ assert.equal(three.totalStreamTime, 1200);
+ assert.equal(three.durationMs, 1200);
+ assert.equal(three.firstTokenTime, 120, "the answer's first token came in the first pass");
+ assert.equal(three.startedAt, 1000);
+ assert.equal(three.serverTimings?.predicted_n, 148);
+ assert.equal(three.serverTimings?.predicted_ms, 1050);
+ const request = readContinuationRequest({ custom: { [CONTINUATION_RUN_CONFIG_KEY]: { partial: "x", priorTiming: two } } });
+ assert.deepEqual(request?.priorTiming, two);
+});
+
+test("a stopped or broken-off reply hands Resume every pass so far", () => {
+ const carried = addPass(priorPassTiming(firstPass), {
+ totalStreamTime: 900, totalChunks: 40, toolCallCount: 0, tokenCount: 39, startedAt: 9000, durationMs: 900,
+ serverTimings: { predicted_n: 39, predicted_ms: 800, predicted_per_second: 38 / 0.8 },
+ });
+ const stopped = { custom: { incomplete: { reason: "cancelled" }, resumeTiming: carried } };
+ assert.deepEqual(priorPassTiming(stopped), carried);
+ assert.equal(priorPassTiming(stopped)?.tokenCount, 128 + 39);
+ const brokeOff = { custom: { timing: { totalStreamTime: 5100, tokenCount: 167, totalChunks: 170 }, resumeTiming: carried } };
+ assert.equal(priorPassTiming(brokeOff)?.serverTimings?.predicted_n, 128 + 39);
+ assert.equal(priorPassTiming(brokeOff)?.startedAt, 1000);
+});
+
+test("Continue carries the figures and the adapter adds them on every way a pass ends", () => {
+ const thread = readText("../src/components/assistant-ui/thread.tsx");
+ assert.match(thread, /const priorTiming = priorPassTiming\(metadata\);\s*if \(priorTiming\) request\.priorTiming = priorTiming;/);
+ const adapter = readText("../src/features/chat/api/chat-adapter.ts");
+ assert.match(adapter, /const passText = \(\) => cumulativeText\.slice\(continuationPartial\.length\);/);
+ assert.match(adapter, /meta\?\.usage\?\.completion_tokens \?\? estimateTokenCount\(passText\(\)\)/);
+ assert.match(adapter, /estimateTokenCount\(continuation \? passText\(\) : partialText\)/);
+ assert.match(adapter, /const finalTiming = withPriorTiming\(/);
+ assert.match(adapter, /const partialTiming = withPriorTiming\(/);
+ assert.match(adapter, /serverTimings: finalServerTimings \?\? undefined,/);
+ assert.match(adapter, /startedAt: priorTiming\?\.startedAt \?\? streamStartTime,/);
+ const live = adapter.slice(adapter.indexOf("const liveCustom = () => ({"), adapter.indexOf("const liveCustom = () => ({") + 400);
+ assert.match(live, /resumeTiming: passSoFar \? addPass\(priorTiming, passSoFar\(\)\) : priorTiming,/);
+ const partial = adapter.slice(adapter.indexOf("const partialTiming = withPriorTiming("));
+ assert.match(partial, /resumeTiming: passSoFar \? addPass\(priorTiming, passSoFar\(\)\) : priorTiming,/);
+});