@tonyclaw/agent-inspector 2.0.27 → 2.0.29

package/src/lib/providerTestContract.ts

@@ -45,6 +45,9 @@ export const ProviderTestResultSchema = z.object({
   cacheCreationInputTokens: z.number().optional(),
   cacheReadInputTokens: z.number().optional(),
   latencyMs: z.number().optional(),
+  firstChunkMs: z.number().nullable().optional(),
+  totalStreamMs: z.number().nullable().optional(),
+  tokensPerSecond: z.number().nullable().optional(),
   content: z.array(ProviderTestContentSchema).optional(),
   rawResponse: z.string().optional(),
   streaming: z.boolean().optional(),

package/src/lib/sessionInfoContract.ts

@@ -21,6 +21,9 @@ export const SessionLogSummarySchema = z.object({
   hasError: z.boolean(),
   error: z.string().nullable(),
   latencyMs: z.number().nullable(),
+  firstChunkMs: z.number().nullable().optional(),
+  totalStreamMs: z.number().nullable().optional(),
+  tokensPerSecond: z.number().nullable().optional(),
   tokens: z.object({
     input: z.number().nullable(),
     output: z.number().nullable(),

package/src/mcp/toolHandlers.ts

@@ -132,6 +132,9 @@ export function buildLogSummary(log: CapturedLog) {
     isStreaming: log.streaming,
     hasError,
     latencyMs: log.elapsedMs,
+    firstChunkMs: log.firstChunkMs ?? null,
+    totalStreamMs: log.totalStreamMs ?? null,
+    tokensPerSecond: log.tokensPerSecond ?? null,
     tokens: {
       input: log.inputTokens,
       output: log.outputTokens,

package/src/proxy/evidenceAnalysis.ts

@@ -318,6 +318,11 @@ function logDetails(log: SessionLogSummary): string {
     `streaming=${log.isStreaming ? "yes" : "no"}`,
     `latencyMs=${formatNullable(log.latencyMs)}`,
   ];
+  if (log.isStreaming) {
+    parts.push(`firstChunkMs=${formatNullable(log.firstChunkMs ?? null)}`);
+    parts.push(`totalStreamMs=${formatNullable(log.totalStreamMs ?? null)}`);
+    parts.push(`tokensPerSecond=${formatNullable(log.tokensPerSecond ?? null)}`);
+  }
   if (log.error !== null) {
     parts.push(`error=${log.error}`);
   }

package/src/proxy/evidenceExporter.ts

@@ -112,14 +112,19 @@ function buildMarkdown(document: EvidenceDocument): string {
       lines.push("No compact logs were available.", "");
     } else {
       lines.push(
-        "| ID | Status | Model | Latency | Path | Error |",
-        "| --- | --- | --- | --- | --- | --- |",
+        "| ID | Status | Model | Latency | Stream | Path | Error |",
+        "| --- | --- | --- | --- | --- | --- | --- |",
       );
       for (const log of session.latestLogs) {
+        const streamTiming = log.isStreaming
+          ? `first=${log.firstChunkMs ?? "n/a"}ms total=${log.totalStreamMs ?? "n/a"}ms tps=${
+              log.tokensPerSecond ?? "n/a"
+            }`
+          : "n/a";
         lines.push(
           `| ${log.id} | ${log.status ?? "n/a"} | ${log.model ?? "n/a"} | ${
             log.latencyMs ?? "n/a"
-          } | ${log.path} | ${log.hasError ? "yes" : "no"} |`,
+          } | ${streamTiming} | ${log.path} | ${log.hasError ? "yes" : "no"} |`,
         );
       }
       lines.push("");

package/src/proxy/handler.ts

@@ -142,12 +142,14 @@ function handleStreamingResponse(
   const capture = new RawStreamCapture();
   const decoder = new TextDecoder();
   let finalizationScheduled = false;
+  let firstChunkMs: number | null = null;
 
   const scheduleStreamingFinalization = (type: "streaming" | "stream-abort"): void => {
     if (finalizationScheduled) return;
     finalizationScheduled = true;
 
-    const elapsedMs = Date.now() - startTime;
+    const totalStreamMs = Date.now() - startTime;
+    const elapsedMs = totalStreamMs;
     const rawStream = capture.snapshot();
     switch (type) {
       case "streaming":
@@ -159,6 +161,8 @@ function handleStreamingResponse(
           responseStatus: upstreamRes.status,
           rawStream,
           collectStreamingChunks,
+          firstChunkMs,
+          totalStreamMs,
         });
         return;
       case "stream-abort":
@@ -170,6 +174,8 @@ function handleStreamingResponse(
           rawStream,
           hasChunks: capture.hasChunks,
           collectStreamingChunks,
+          firstChunkMs,
+          totalStreamMs,
         });
         return;
     }
@@ -177,6 +183,7 @@ function handleStreamingResponse(
 
   const transform = new TransformStream<Uint8Array, Uint8Array>({
     async transform(chunk, controller) {
+      if (firstChunkMs === null) firstChunkMs = Date.now() - startTime;
       controller.enqueue(chunk);
       await capture.append(decoder.decode(chunk, { stream: true }));
     },

package/src/proxy/logFinalizer.ts

@@ -8,6 +8,7 @@ import type { RawStreamSource } from "./rawStreamCapture";
 import type { CapturedLog } from "./schemas";
 import { getSessionProcess, isSessionProcessAvailable } from "./sessionProcess";
 import { finalizeLogUpdate } from "./store";
+import { computeTokensPerSecond } from "./streamTiming";
 
 type BaseFinalizeLogJob = {
   log: CapturedLog;
@@ -26,6 +27,8 @@ export type FinalizeStreamingLogJob = BaseFinalizeLogJob & {
   responseStatus: number;
   rawStream: string | RawStreamSource;
   collectStreamingChunks: boolean;
+  firstChunkMs: number | null;
+  totalStreamMs: number;
 };
 
 export type FinalizeStreamAbortLogJob = BaseFinalizeLogJob & {
@@ -33,6 +36,8 @@ export type FinalizeStreamAbortLogJob = BaseFinalizeLogJob & {
   rawStream: string | RawStreamSource;
   hasChunks: boolean;
   collectStreamingChunks: boolean;
+  firstChunkMs: number | null;
+  totalStreamMs: number;
 };
 
 export type FinalizeLogJob =
@@ -73,6 +78,9 @@ export function buildFileLogEntry(log: CapturedLog, upstreamUrl: string): Record
     cacheCreationInputTokens: log.cacheCreationInputTokens,
     cacheReadInputTokens: log.cacheReadInputTokens,
     elapsedMs: log.elapsedMs,
+    firstChunkMs: log.firstChunkMs,
+    totalStreamMs: log.totalStreamMs,
+    tokensPerSecond: log.tokensPerSecond,
     streaming: log.streaming,
     userAgent: log.userAgent,
     origin: log.origin,
@@ -119,10 +127,31 @@ function finalizeWithError(
   log.responseStatus = log.responseStatus ?? fallbackStatus;
   log.responseText = log.responseText ?? fallbackResponseText;
   log.elapsedMs = job.elapsedMs;
+  applyOptionalStreamingTiming(log, job);
   log.error = message;
   return { log, upstreamUrl: job.upstreamUrl, error: message, cleanupRawStreamPath };
 }
 
+function applyOptionalStreamingTiming(log: CapturedLog, job: FinalizeLogJob): void {
+  switch (job.type) {
+    case "non-streaming":
+      log.firstChunkMs = null;
+      log.totalStreamMs = null;
+      log.tokensPerSecond = null;
+      return;
+    case "streaming":
+    case "stream-abort":
+      log.firstChunkMs = job.firstChunkMs;
+      log.totalStreamMs = job.totalStreamMs;
+      log.tokensPerSecond = computeTokensPerSecond({
+        outputTokens: log.outputTokens,
+        firstChunkMs: job.firstChunkMs,
+        totalStreamMs: job.totalStreamMs,
+      });
+      return;
+  }
+}
+
 function finalizeNonStreaming(
   job: FinalizeNonStreamingLogJob,
   log: CapturedLog,
@@ -136,6 +165,9 @@ function finalizeNonStreaming(
     const tokens = formatHandler.extractTokens(job.responseBody);
 
     log.elapsedMs = job.elapsedMs;
+    log.firstChunkMs = null;
+    log.totalStreamMs = null;
+    log.tokensPerSecond = null;
     log.responseStatus = job.responseStatus;
     log.responseText = job.responseBody;
     log.inputTokens = tokens.inputTokens;
@@ -238,6 +270,7 @@ function finalizeStreaming(job: FinalizeStreamingLogJob, log: CapturedLog): Fina
   const oversized = getOversizedRawStream(job.rawStream);
   if (oversized !== null) {
     log.elapsedMs = job.elapsedMs;
+    applyOptionalStreamingTiming(log, job);
     log.responseStatus = job.responseStatus;
     log.responseText = oversizedRawStreamText(oversized);
     return {
@@ -262,6 +295,7 @@ function finalizeStreaming(job: FinalizeStreamingLogJob, log: CapturedLog): Fina
       log.model ?? undefined,
       job.collectStreamingChunks,
     );
+    applyOptionalStreamingTiming(log, job);
     persistStreamingChunks(log);
 
     return { log, upstreamUrl: job.upstreamUrl, error: null, cleanupRawStreamPath };
@@ -294,6 +328,7 @@ function finalizeStreamAbort(job: FinalizeStreamAbortLogJob, log: CapturedLog):
   let cleanupRawStreamPath: string | null = null;
   try {
     log.elapsedMs = job.elapsedMs;
+    applyOptionalStreamingTiming(log, job);
     if (job.hasChunks && formatHandler !== null) {
       const oversized = getOversizedRawStream(job.rawStream);
       if (oversized !== null) {
@@ -314,6 +349,7 @@ function finalizeStreamAbort(job: FinalizeStreamAbortLogJob, log: CapturedLog):
         log.model ?? undefined,
         job.collectStreamingChunks,
       );
+      applyOptionalStreamingTiming(log, job);
       persistStreamingChunks(log);
     } else {
       log.responseText = "Client aborted";

package/src/proxy/schemas.ts

@@ -40,6 +40,9 @@ export const CapturedLogSchema = z.object({
   cacheCreationInputTokens: z.number().nullable(),
   cacheReadInputTokens: z.number().nullable(),
   elapsedMs: z.number().nullable(),
+  firstChunkMs: z.number().nullable().optional(),
+  totalStreamMs: z.number().nullable().optional(),
+  tokensPerSecond: z.number().nullable().optional(),
   streaming: z.boolean(),
   userAgent: z.string().nullable(),
   origin: z.string().nullable(),

package/src/proxy/sessionInfo.ts

@@ -55,6 +55,9 @@ export function buildSessionLogSummary(log: CapturedLog): SessionLogSummary {
     hasError: hasLogError(log),
     error: truncateError(log.error),
     latencyMs: log.elapsedMs,
+    firstChunkMs: log.firstChunkMs ?? null,
+    totalStreamMs: log.totalStreamMs ?? null,
+    tokensPerSecond: log.tokensPerSecond ?? null,
     tokens: {
       input: log.inputTokens,
       output: log.outputTokens,

package/src/proxy/store.ts

@@ -233,6 +233,9 @@ export async function createLog(
     cacheCreationInputTokens: null,
     cacheReadInputTokens: null,
     elapsedMs: null,
+    firstChunkMs: null,
+    totalStreamMs: null,
+    tokensPerSecond: null,
     streaming: false,
     userAgent,
     origin,

package/src/proxy/streamTiming.ts

@@ -0,0 +1,31 @@
+import type { StreamingChunk } from "./schemas";
+
+export function computeTokensPerSecond({
+  outputTokens,
+  firstChunkMs,
+  totalStreamMs,
+}: {
+  outputTokens: number | null | undefined;
+  firstChunkMs: number | null | undefined;
+  totalStreamMs: number | null | undefined;
+}): number | null {
+  if (outputTokens === null || outputTokens === undefined || outputTokens <= 0) return null;
+  if (totalStreamMs === null || totalStreamMs === undefined || totalStreamMs <= 0) return null;
+
+  const generationMs =
+    firstChunkMs === null || firstChunkMs === undefined
+      ? totalStreamMs
+      : totalStreamMs - firstChunkMs;
+  if (!Number.isFinite(generationMs) || generationMs <= 0) return null;
+
+  return Number((outputTokens / (generationMs / 1000)).toFixed(2));
+}
+
+export function firstChunkMsFromChunks(
+  chunks: readonly StreamingChunk[] | undefined,
+): number | null {
+  const first = chunks?.[0];
+  if (first === undefined) return null;
+  if (!Number.isFinite(first.timestamp) || first.timestamp < 0) return null;
+  return Math.floor(first.timestamp);
+}

package/src/routes/api/logs.$id.replay.ts

@@ -21,6 +21,7 @@ import {
   selectUpstreamBase,
   setUpstreamHost,
 } from "../../proxy/upstream";
+import { computeTokensPerSecond } from "../../proxy/streamTiming";
 
 type ReplayRequest = {
   modifiedBody: string;
@@ -38,6 +39,9 @@ type ReplayResponse = {
   inputTokens?: number;
   outputTokens?: number;
   elapsedMs?: number;
+  firstChunkMs?: number | null;
+  totalStreamMs?: number | null;
+  tokensPerSecond?: number | null;
   streaming?: boolean;
   replayLogId?: number;
 };
@@ -135,7 +139,6 @@ export const Route = createFileRoute("/api/logs/$id/replay")({
           } satisfies ReplayResponse);
         }
 
-        const elapsedMs = Date.now() - startTime;
         const isStream =
           upstreamRes.headers.get(HEADER_CONTENT_TYPE)?.includes(CONTENT_TYPE_EVENT_STREAM) ??
           false;
@@ -145,11 +148,13 @@ export const Route = createFileRoute("/api/logs/$id/replay")({
           const chunks: string[] = [];
           const decoder = new TextDecoder();
           const reader = upstreamRes.body?.getReader();
+          let firstChunkMs: number | null = null;
           if (reader) {
             try {
               while (true) {
                 const { done, value } = await reader.read();
                 if (done) break;
+                if (firstChunkMs === null) firstChunkMs = Date.now() - startTime;
                 chunks.push(decoder.decode(value, { stream: true }));
               }
             } catch {
@@ -157,11 +162,19 @@ export const Route = createFileRoute("/api/logs/$id/replay")({
             }
           }
           const fullResponse = chunks.join("");
+          const elapsedMs = Date.now() - startTime;
+          const totalStreamMs = elapsedMs;
 
           // Create a mock log for streaming extraction
           const mockLog: typeof log = { ...log };
           const responseText = formatHandler.extractStream(fullResponse, mockLog, model, false);
           const tokens = formatHandler.extractTokens(responseText);
+          const outputTokens = tokens.outputTokens ?? null;
+          const tokensPerSecond = computeTokensPerSecond({
+            outputTokens,
+            firstChunkMs,
+            totalStreamMs,
+          });
           const savedReplayLog = await addTestLogEntry({
             timestamp: new Date().toISOString(),
             method: log.method,
@@ -172,10 +185,13 @@ export const Route = createFileRoute("/api/logs/$id/replay")({
             responseStatus: upstreamRes.status,
             responseText,
             inputTokens: tokens.inputTokens ?? null,
-            outputTokens: tokens.outputTokens ?? null,
+            outputTokens,
             cacheCreationInputTokens: tokens.cacheCreationInputTokens ?? null,
             cacheReadInputTokens: tokens.cacheReadInputTokens ?? null,
             elapsedMs,
+            firstChunkMs,
+            totalStreamMs,
+            tokensPerSecond,
             streaming: true,
             userAgent: log.userAgent,
             origin: log.origin,
@@ -201,11 +217,15 @@ export const Route = createFileRoute("/api/logs/$id/replay")({
             inputTokens: tokens.inputTokens ?? undefined,
             outputTokens: tokens.outputTokens ?? undefined,
             elapsedMs,
+            firstChunkMs,
+            totalStreamMs,
+            tokensPerSecond,
             streaming: true,
             replayLogId: savedReplayLog.id,
           } satisfies ReplayResponse);
         } else {
           const responseText = await upstreamRes.text();
+          const elapsedMs = Date.now() - startTime;
           const tokens = formatHandler.extractTokens(responseText);
           const savedReplayLog = await addTestLogEntry({
             timestamp: new Date().toISOString(),
@@ -221,6 +241,9 @@ export const Route = createFileRoute("/api/logs/$id/replay")({
             cacheCreationInputTokens: tokens.cacheCreationInputTokens ?? null,
             cacheReadInputTokens: tokens.cacheReadInputTokens ?? null,
             elapsedMs,
+            firstChunkMs: null,
+            totalStreamMs: null,
+            tokensPerSecond: null,
             streaming: false,
             userAgent: log.userAgent,
             origin: log.origin,

package/src/routes/api/providers.$providerId.test.log.ts

@@ -8,6 +8,7 @@ import {
   type ProviderTestResult as TestResult,
   type ProviderTestState,
 } from "../../lib/providerTestContract";
+import { computeTokensPerSecond, firstChunkMsFromChunks } from "../../proxy/streamTiming";
 
 function hasSuccessField(result: ProviderTestState): result is TestResult {
   return Object.prototype.hasOwnProperty.call(result, "success");
@@ -29,6 +30,25 @@ function getResultHeaders(result: TestResult): Record<string, string> {
   return result.requestHeaders ?? result.debug?.requestHeaders ?? {};
 }
 
+function getResultTotalStreamMs(result: TestResult): number | null {
+  return result.totalStreamMs ?? (result.streaming === true ? (result.latencyMs ?? null) : null);
+}
+
+function getResultFirstChunkMs(result: TestResult): number | null {
+  return result.firstChunkMs ?? firstChunkMsFromChunks(result.streamingChunks?.chunks);
+}
+
+function getResultTokensPerSecond(result: TestResult): number | null {
+  return (
+    result.tokensPerSecond ??
+    computeTokensPerSecond({
+      outputTokens: result.outputTokens,
+      firstChunkMs: getResultFirstChunkMs(result),
+      totalStreamMs: getResultTotalStreamMs(result),
+    })
+  );
+}
+
 async function logModelResults(
   displayName: string,
   providerName: string,
@@ -65,6 +85,9 @@ async function logModelResults(
         cacheCreationInputTokens: nonStreamingResult.cacheCreationInputTokens ?? null,
         cacheReadInputTokens: nonStreamingResult.cacheReadInputTokens ?? null,
         elapsedMs: nonStreamingResult.latencyMs ?? 0,
+        firstChunkMs: null,
+        totalStreamMs: null,
+        tokensPerSecond: null,
         streaming: false,
         userAgent: "provider-test",
         origin: null,
@@ -91,7 +114,10 @@ async function logModelResults(
         outputTokens: streamingResult.outputTokens ?? null,
         cacheCreationInputTokens: streamingResult.cacheCreationInputTokens ?? null,
         cacheReadInputTokens: streamingResult.cacheReadInputTokens ?? null,
-        elapsedMs: streamingResult.latencyMs ?? 0,
+        elapsedMs: getResultTotalStreamMs(streamingResult) ?? 0,
+        firstChunkMs: getResultFirstChunkMs(streamingResult),
+        totalStreamMs: getResultTotalStreamMs(streamingResult),
+        tokensPerSecond: getResultTokensPerSecond(streamingResult),
         streaming: true,
         streamingChunks: captureFullDetails ? streamingResult.streamingChunks : undefined,
         userAgent: "provider-test",
@@ -127,6 +153,9 @@ async function logModelResults(
         cacheCreationInputTokens: null,
         cacheReadInputTokens: null,
         elapsedMs: nonStreamingResult.latencyMs ?? 0,
+        firstChunkMs: null,
+        totalStreamMs: null,
+        tokensPerSecond: null,
         streaming: false,
         userAgent: "provider-test",
         origin: null,
@@ -153,7 +182,10 @@ async function logModelResults(
         outputTokens: streamingResult.outputTokens ?? null,
         cacheCreationInputTokens: null,
         cacheReadInputTokens: null,
-        elapsedMs: streamingResult.latencyMs ?? 0,
+        elapsedMs: getResultTotalStreamMs(streamingResult) ?? 0,
+        firstChunkMs: getResultFirstChunkMs(streamingResult),
+        totalStreamMs: getResultTotalStreamMs(streamingResult),
+        tokensPerSecond: getResultTokensPerSecond(streamingResult),
         streaming: true,
         streamingChunks: captureFullDetails ? streamingResult.streamingChunks : undefined,
         userAgent: "provider-test",