@tonyclaw/agent-inspector 2.0.28 → 2.0.30

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/groups.$groupId.evidence.ts

@@ -0,0 +1,62 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { GroupEvidenceExportOptionsSchema } from "../../lib/groupContract";
+import { exportGroupEvidence, readGroupEvidenceMarkdown } from "../../proxy/groupEvidenceExporter";
+import { getGroup } from "../../proxy/groupStore";
+
+type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
+
+async function readJsonBody(request: Request): Promise<JsonBodyResult> {
+  try {
+    const raw = await request.text();
+    if (raw.trim().length === 0) return { ok: true, value: undefined };
+    return { ok: true, value: JSON.parse(raw) };
+  } catch {
+    return { ok: false };
+  }
+}
+
+export const Route = createFileRoute("/api/groups/$groupId/evidence")({
+  server: {
+    handlers: {
+      GET: ({ params }: { params: { groupId: string } }) => {
+        const group = getGroup(params.groupId);
+        if (group === null) {
+          return Response.json({ error: "Group not found" }, { status: 404 });
+        }
+
+        const markdown = readGroupEvidenceMarkdown(group);
+        if (group.evidence === null || markdown === null) {
+          return Response.json(
+            { error: "Evidence has not been exported for this group" },
+            { status: 404 },
+          );
+        }
+
+        return Response.json({ group, evidence: group.evidence, markdown });
+      },
+      POST: async ({ params, request }: { params: { groupId: string }; request: Request }) => {
+        const group = getGroup(params.groupId);
+        if (group === null) {
+          return Response.json({ error: "Group not found" }, { status: 404 });
+        }
+
+        const body = await readJsonBody(request);
+        if (!body.ok) {
+          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+        }
+
+        const parsed = GroupEvidenceExportOptionsSchema.safeParse(body.value);
+        if (!parsed.success) {
+          return Response.json(
+            { error: "Invalid request body", details: parsed.error.format() },
+            { status: 400 },
+          );
+        }
+
+        return Response.json(
+          await exportGroupEvidence(group, parsed.data, new URL(request.url).origin),
+        );
+      },
+    },
+  },
+});

package/src/routes/api/groups.$groupId.sessions.ts

@@ -0,0 +1,50 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { AddInspectorGroupSessionInputSchema } from "../../lib/groupContract";
+import { addGroupSession, getGroup } from "../../proxy/groupStore";
+
+type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
+
+async function readJsonBody(request: Request): Promise<JsonBodyResult> {
+  try {
+    const raw = await request.text();
+    if (raw.trim().length === 0) return { ok: true, value: {} };
+    return { ok: true, value: JSON.parse(raw) };
+  } catch {
+    return { ok: false };
+  }
+}
+
+export const Route = createFileRoute("/api/groups/$groupId/sessions")({
+  server: {
+    handlers: {
+      GET: ({ params }: { params: { groupId: string } }) => {
+        const group = getGroup(params.groupId);
+        if (group === null) {
+          return Response.json({ error: "Group not found" }, { status: 404 });
+        }
+        return Response.json({ groupId: group.id, members: group.members });
+      },
+      POST: async ({ params, request }: { params: { groupId: string }; request: Request }) => {
+        const body = await readJsonBody(request);
+        if (!body.ok) {
+          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+        }
+
+        const parsed = AddInspectorGroupSessionInputSchema.safeParse(body.value);
+        if (!parsed.success) {
+          return Response.json(
+            { error: "Invalid request body", details: parsed.error.format() },
+            { status: 400 },
+          );
+        }
+
+        const updated = addGroupSession(params.groupId, parsed.data);
+        if (updated === null) {
+          return Response.json({ error: "Group not found" }, { status: 404 });
+        }
+
+        return Response.json(updated);
+      },
+    },
+  },
+});

package/src/routes/api/groups.$groupId.ts

@@ -0,0 +1,50 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { UpdateInspectorGroupInputSchema } from "../../lib/groupContract";
+import { getGroup, updateGroup } from "../../proxy/groupStore";
+
+type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
+
+async function readJsonBody(request: Request): Promise<JsonBodyResult> {
+  try {
+    const raw = await request.text();
+    if (raw.trim().length === 0) return { ok: true, value: {} };
+    return { ok: true, value: JSON.parse(raw) };
+  } catch {
+    return { ok: false };
+  }
+}
+
+export const Route = createFileRoute("/api/groups/$groupId")({
+  server: {
+    handlers: {
+      GET: ({ params }: { params: { groupId: string } }) => {
+        const group = getGroup(params.groupId);
+        if (group === null) {
+          return Response.json({ error: "Group not found" }, { status: 404 });
+        }
+        return Response.json(group);
+      },
+      PATCH: async ({ params, request }: { params: { groupId: string }; request: Request }) => {
+        const body = await readJsonBody(request);
+        if (!body.ok) {
+          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+        }
+
+        const parsed = UpdateInspectorGroupInputSchema.safeParse(body.value);
+        if (!parsed.success) {
+          return Response.json(
+            { error: "Invalid request body", details: parsed.error.format() },
+            { status: 400 },
+          );
+        }
+
+        const updated = updateGroup(params.groupId, parsed.data);
+        if (updated === null) {
+          return Response.json({ error: "Group not found" }, { status: 404 });
+        }
+
+        return Response.json(updated);
+      },
+    },
+  },
+});

package/src/routes/api/groups.ts

@@ -0,0 +1,39 @@
+import { createFileRoute } from "@tanstack/react-router";
+import { CreateInspectorGroupInputSchema } from "../../lib/groupContract";
+import { createGroup, listGroups } from "../../proxy/groupStore";
+
+type JsonBodyResult = { ok: true; value: unknown } | { ok: false };
+
+async function readJsonBody(request: Request): Promise<JsonBodyResult> {
+  try {
+    const raw = await request.text();
+    if (raw.trim().length === 0) return { ok: true, value: undefined };
+    return { ok: true, value: JSON.parse(raw) };
+  } catch {
+    return { ok: false };
+  }
+}
+
+export const Route = createFileRoute("/api/groups")({
+  server: {
+    handlers: {
+      GET: () => Response.json({ groups: listGroups() }),
+      POST: async ({ request }: { request: Request }) => {
+        const body = await readJsonBody(request);
+        if (!body.ok) {
+          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+        }
+
+        const parsed = CreateInspectorGroupInputSchema.safeParse(body.value);
+        if (!parsed.success) {
+          return Response.json(
+            { error: "Invalid request body", details: parsed.error.format() },
+            { status: 400 },
+          );
+        }
+
+        return Response.json(createGroup(parsed.data), { status: 201 });
+      },
+    },
+  },
+});

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",