@tonyclaw/agent-inspector 2.0.25 → 2.0.26

package/src/lib/sessionInfoContract.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+
+export const SessionTokenUsageSchema = z.object({
+  input: z.number().int().nonnegative(),
+  output: z.number().int().nonnegative(),
+  cacheCreate: z.number().int().nonnegative(),
+  cacheRead: z.number().int().nonnegative(),
+  total: z.number().int().nonnegative(),
+});
+
+export const SessionLogSummarySchema = z.object({
+  id: z.number().int().positive(),
+  timestamp: z.string(),
+  provider: z.string().nullable(),
+  model: z.string().nullable(),
+  apiFormat: z.enum(["anthropic", "openai", "unknown"]),
+  method: z.string(),
+  path: z.string(),
+  status: z.number().nullable(),
+  isStreaming: z.boolean(),
+  hasError: z.boolean(),
+  error: z.string().nullable(),
+  latencyMs: z.number().nullable(),
+  tokens: z.object({
+    input: z.number().nullable(),
+    output: z.number().nullable(),
+    cacheCreate: z.number().nullable(),
+    cacheRead: z.number().nullable(),
+  }),
+  sessionId: z.string().nullable(),
+});
+
+export const SessionInfoSchema = z.object({
+  id: z.string(),
+  status: z.enum(["active", "failed", "completed", "empty"]),
+  logCoverage: z.enum(["recent", "history"]),
+  source: z.enum(["explicit", "client-process", "client-connection", "provider-test"]).nullable(),
+  runtimeMode: z.enum(["in-process", "worker-thread", "child-process"]).nullable(),
+  createdAt: z.string().nullable(),
+  updatedAt: z.string().nullable(),
+  requestCount: z.number().int().nonnegative(),
+  activeRequests: z.number().int().nonnegative(),
+  completedRequests: z.number().int().nonnegative(),
+  failedRequests: z.number().int().nonnegative(),
+  queuedTasks: z.number().int().nonnegative(),
+  runningTasks: z.number().int().nonnegative(),
+  lastTaskError: z.string().nullable(),
+  logCount: z.number().int().nonnegative(),
+  errorCount: z.number().int().nonnegative(),
+  models: z.array(z.string()),
+  providers: z.array(z.string()),
+  tokenUsage: SessionTokenUsageSchema,
+  lastLogId: z.number().nullable(),
+  lastModel: z.string().nullable(),
+  clientPid: z.number().nullable(),
+  clientProjectFolder: z.string().nullable(),
+  inspectorPath: z.string(),
+  inspectorUrl: z.string(),
+  apiPath: z.string(),
+  apiUrl: z.string(),
+  compactLogsPath: z.string(),
+  compactLogsUrl: z.string(),
+  latestLogLimit: z.number().int().positive(),
+  latestLogs: z.array(SessionLogSummarySchema),
+});
+
+export type SessionTokenUsage = z.infer<typeof SessionTokenUsageSchema>;
+export type SessionLogSummary = z.infer<typeof SessionLogSummarySchema>;
+export type SessionInfo = z.infer<typeof SessionInfoSchema>;

package/src/mcp/server.ts

@@ -23,6 +23,7 @@ import {
   addProviderImpl,
   createSessionKnowledgeImpl,
   getProjectContextImpl,
+  getSessionImpl,
   getLogChunksImpl,
   getLogImpl,
   getProviderImpl,
@@ -201,6 +202,30 @@ function registerTools(server: McpServer): void {
     () => safeCall(() => listSessionsImpl(callApi)),
   );
 
+  server.registerTool(
+    "inspector_get_session",
+    {
+      title: "Get Inspector session info",
+      description:
+        "Returns a lightweight, evidence-friendly summary for one Inspector session: clickable inspectorUrl, compact logs URL, status, request/error counts, token totals, models/providers, and the latest compact log summaries. Defaults to recent in-memory/cache data for speed; set includeHistory=true only when you explicitly want to scan persisted jsonl history. It avoids raw request/response bodies so it is safe to use in evaluation artifacts.",
+      inputSchema: z.object({
+        sessionId: z.string().min(1).describe("The Inspector session id."),
+        includeHistory: z
+          .boolean()
+          .optional()
+          .describe("Scan persisted jsonl history for this session. Slower; default false."),
+        latestLogLimit: z
+          .number()
+          .int()
+          .positive()
+          .max(50)
+          .optional()
+          .describe("How many latest compact log summaries to include. Max 50, default 10."),
+      }),
+    },
+    (args) => safeCall(() => getSessionImpl(callApi, args)),
+  );
+
   server.registerTool(
     "inspector_list_models",
     {
@@ -389,6 +414,7 @@ export const TOOL_NAMES = [
   "inspector_get_log",
   "inspector_get_log_chunks",
   "inspector_list_sessions",
+  "inspector_get_session",
   "inspector_list_models",
   "inspector_list_providers",
   "inspector_get_provider",

package/src/mcp/toolHandlers.ts

@@ -17,6 +17,7 @@ import { Buffer } from "node:buffer";
 import { z } from "zod";
 import { LoopbackTimeoutError, type CallApiOptions } from "./loopback";
 import { extractLastUserMessagePreview, extractResponsePreview } from "./previewExtractor";
+import { SessionInfoSchema } from "../lib/sessionInfoContract";
 import { CapturedLogSchema, type CapturedLog } from "../proxy/schemas";
 
 /** Minimal callApi contract: same shape as the real `callApi` in loopback.ts. */
@@ -191,6 +192,32 @@ export async function listSessionsImpl(callApi: CallApiFn): Promise<ToolResult>
   return textJson(await res.json());
 }
 
+export type GetSessionArgs = {
+  sessionId: string;
+  includeHistory?: boolean;
+  latestLogLimit?: number;
+};
+
+export async function getSessionImpl(
+  callApi: CallApiFn,
+  args: GetSessionArgs,
+): Promise<ToolResult> {
+  const params = new URLSearchParams({ sessionId: args.sessionId });
+  if (args.latestLogLimit !== undefined) {
+    params.set("limit", String(args.latestLogLimit));
+  }
+  if (args.includeHistory === true) {
+    params.set("includeHistory", "1");
+  }
+  const path = `/api/sessions?${params.toString()}`;
+  const res = await callApi(path);
+  if (!res.ok) return toolError(`GET ${path} returned ${res.status}`);
+  const rawBody: unknown = await res.json();
+  const parsed = SessionInfoSchema.safeParse(rawBody);
+  if (!parsed.success) return toolError("GET /api/sessions returned an unparseable session info");
+  return textJson(parsed.data);
+}
+
 export async function listModelsImpl(callApi: CallApiFn): Promise<ToolResult> {
   const res = await callApi("/api/models");
   if (!res.ok) return toolError(`GET /api/models returned ${res.status}`);

package/src/proxy/sessionInfo.ts

@@ -0,0 +1,222 @@
+import type { SessionInfo, SessionLogSummary, SessionTokenUsage } from "../lib/sessionInfoContract";
+import { getSessionPath } from "../lib/sessionUrl";
+import type { CapturedLog } from "./schemas";
+import type { SessionSnapshot } from "./sessionSupervisor";
+
+export const SESSION_INFO_DEFAULT_LATEST_LOG_LIMIT = 10;
+export const SESSION_INFO_MAX_LATEST_LOG_LIMIT = 50;
+
+type SessionStatus = SessionInfo["status"];
+
+type BuildSessionInfoInput = {
+  sessionId: string;
+  baseUrl: string;
+  snapshot: SessionSnapshot | null;
+  summaries: readonly SessionLogSummary[];
+  logCoverage: SessionInfo["logCoverage"];
+  latestLogLimit?: number;
+};
+
+export function clampSessionInfoLogLimit(input: number | undefined): number {
+  if (input === undefined) return SESSION_INFO_DEFAULT_LATEST_LOG_LIMIT;
+  if (!Number.isFinite(input) || input < 1) return 1;
+  return Math.min(Math.floor(input), SESSION_INFO_MAX_LATEST_LOG_LIMIT);
+}
+
+function normalizeString(value: string | null | undefined): string | null {
+  if (value === null || value === undefined || value.length === 0) return null;
+  return value;
+}
+
+function truncateError(value: string | null | undefined): string | null {
+  const normalized = normalizeString(value);
+  if (normalized === null) return null;
+  if (normalized.length <= 500) return normalized;
+  return `${normalized.slice(0, 500)}...`;
+}
+
+function hasLogError(log: CapturedLog): boolean {
+  const error = normalizeString(log.error);
+  if (error !== null) return true;
+  return log.responseStatus !== null && log.responseStatus >= 400;
+}
+
+export function buildSessionLogSummary(log: CapturedLog): SessionLogSummary {
+  return {
+    id: log.id,
+    timestamp: log.timestamp,
+    provider: normalizeString(log.providerName),
+    model: normalizeString(log.model),
+    apiFormat: log.apiFormat,
+    method: log.method,
+    path: log.path,
+    status: log.responseStatus,
+    isStreaming: log.streaming,
+    hasError: hasLogError(log),
+    error: truncateError(log.error),
+    latencyMs: log.elapsedMs,
+    tokens: {
+      input: log.inputTokens,
+      output: log.outputTokens,
+      cacheCreate: log.cacheCreationInputTokens,
+      cacheRead: log.cacheReadInputTokens,
+    },
+    sessionId: normalizeString(log.sessionId),
+  };
+}
+
+function nonNegativeInteger(value: number | null): number {
+  if (value === null || !Number.isFinite(value) || value < 0) return 0;
+  return Math.floor(value);
+}
+
+function addTokenUsage(total: SessionTokenUsage, summary: SessionLogSummary): SessionTokenUsage {
+  const input = nonNegativeInteger(summary.tokens.input);
+  const output = nonNegativeInteger(summary.tokens.output);
+  const cacheCreate = nonNegativeInteger(summary.tokens.cacheCreate);
+  const cacheRead = nonNegativeInteger(summary.tokens.cacheRead);
+  return {
+    input: total.input + input,
+    output: total.output + output,
+    cacheCreate: total.cacheCreate + cacheCreate,
+    cacheRead: total.cacheRead + cacheRead,
+    total: total.total + input + output + cacheCreate + cacheRead,
+  };
+}
+
+function buildRelativePath(pathname: string, params: URLSearchParams): string {
+  const query = params.toString();
+  return query.length > 0 ? `${pathname}?${query}` : pathname;
+}
+
+function buildAbsoluteUrl(baseUrl: string, path: string): string {
+  try {
+    return new URL(path, baseUrl).toString();
+  } catch {
+    return path;
+  }
+}
+
+function buildApiPath(sessionId: string): string {
+  return buildRelativePath("/api/sessions", new URLSearchParams({ sessionId }));
+}
+
+function buildCompactLogsPath(sessionId: string): string {
+  return buildRelativePath("/api/logs", new URLSearchParams({ compact: "1", sessionId }));
+}
+
+function collectSortedValues(values: readonly (string | null)[]): string[] {
+  const set = new Set<string>();
+  for (const value of values) {
+    if (value !== null && value.length > 0) {
+      set.add(value);
+    }
+  }
+  return [...set].sort();
+}
+
+function countCompletedLogs(summaries: readonly SessionLogSummary[]): number {
+  let count = 0;
+  for (const summary of summaries) {
+    if (summary.status !== null || summary.latencyMs !== null) {
+      count += 1;
+    }
+  }
+  return count;
+}
+
+function countErrorLogs(summaries: readonly SessionLogSummary[]): number {
+  let count = 0;
+  for (const summary of summaries) {
+    if (summary.hasError) {
+      count += 1;
+    }
+  }
+  return count;
+}
+
+function deriveSessionStatus(input: {
+  activeRequests: number;
+  runningTasks: number;
+  failedRequests: number;
+  errorCount: number;
+  lastTaskError: string | null;
+  completedRequests: number;
+  logCount: number;
+}): SessionStatus {
+  if (input.activeRequests > 0 || input.runningTasks > 0) return "active";
+  if (input.failedRequests > 0 || input.errorCount > 0 || input.lastTaskError !== null) {
+    return "failed";
+  }
+  if (input.completedRequests > 0 || input.logCount > 0) return "completed";
+  return "empty";
+}
+
+export function buildSessionInfo(input: BuildSessionInfoInput): SessionInfo {
+  const latestLogLimit = clampSessionInfoLogLimit(input.latestLogLimit);
+  const summaries = [...input.summaries].sort((left, right) => right.id - left.id);
+  const latestLog = summaries[0] ?? null;
+  const oldestLog = summaries.length > 0 ? summaries[summaries.length - 1] : null;
+  const logCount =
+    input.logCoverage === "history"
+      ? summaries.length
+      : Math.max(input.snapshot?.requestCount ?? 0, summaries.length);
+  const errorCount = Math.max(countErrorLogs(summaries), input.snapshot?.failedRequests ?? 0);
+  const completedLogCount = countCompletedLogs(summaries);
+  const tokenUsage = summaries.reduce<SessionTokenUsage>(
+    (total, summary) => addTokenUsage(total, summary),
+    { input: 0, output: 0, cacheCreate: 0, cacheRead: 0, total: 0 },
+  );
+  const requestCount = Math.max(input.snapshot?.requestCount ?? 0, logCount);
+  const activeRequests = input.snapshot?.activeRequests ?? 0;
+  const completedRequests = Math.max(input.snapshot?.completedRequests ?? 0, completedLogCount);
+  const failedRequests = Math.max(input.snapshot?.failedRequests ?? 0, errorCount);
+  const queuedTasks = input.snapshot?.queuedTasks ?? 0;
+  const runningTasks = input.snapshot?.runningTasks ?? 0;
+  const lastTaskError = normalizeString(input.snapshot?.lastTaskError);
+  const inspectorPath = getSessionPath(input.sessionId);
+  const apiPath = buildApiPath(input.sessionId);
+  const compactLogsPath = buildCompactLogsPath(input.sessionId);
+
+  return {
+    id: input.sessionId,
+    status: deriveSessionStatus({
+      activeRequests,
+      runningTasks,
+      failedRequests,
+      errorCount,
+      lastTaskError,
+      completedRequests,
+      logCount,
+    }),
+    logCoverage: input.logCoverage,
+    source: input.snapshot?.source ?? null,
+    runtimeMode: input.snapshot?.runtimeMode ?? null,
+    createdAt: input.snapshot?.createdAt ?? oldestLog?.timestamp ?? null,
+    updatedAt: input.snapshot?.updatedAt ?? latestLog?.timestamp ?? null,
+    requestCount,
+    activeRequests,
+    completedRequests,
+    failedRequests,
+    queuedTasks,
+    runningTasks,
+    lastTaskError,
+    logCount,
+    errorCount,
+    models: collectSortedValues(summaries.map((summary) => summary.model)),
+    providers: collectSortedValues(summaries.map((summary) => summary.provider)),
+    tokenUsage,
+    lastLogId: input.snapshot?.lastLogId ?? latestLog?.id ?? null,
+    lastModel: normalizeString(input.snapshot?.lastModel) ?? latestLog?.model ?? null,
+    clientPid: input.snapshot?.clientPid ?? null,
+    clientProjectFolder: normalizeString(input.snapshot?.clientProjectFolder),
+    inspectorPath,
+    inspectorUrl: buildAbsoluteUrl(input.baseUrl, inspectorPath),
+    apiPath,
+    apiUrl: buildAbsoluteUrl(input.baseUrl, apiPath),
+    compactLogsPath,
+    compactLogsUrl: buildAbsoluteUrl(input.baseUrl, compactLogsPath),
+    latestLogLimit,
+    latestLogs: summaries.slice(0, latestLogLimit),
+  };
+}

package/src/proxy/sessionSupervisor.ts

@@ -159,11 +159,14 @@ function upsertSession(
 
   const existing = sessions.get(identity.id);
   const session = existing ?? createSessionRecord(identity.id, source, log);
-  session.updatedAt = new Date().toISOString();
-  session.lastLogId = log.id;
-  session.lastModel = log.model ?? session.lastModel;
-  session.clientPid = log.clientPid ?? session.clientPid;
-  session.clientProjectFolder = log.clientProjectFolder ?? session.clientProjectFolder;
+  const isSameOrNewerLog = session.lastLogId === null || log.id >= session.lastLogId;
+  if (isSameOrNewerLog) {
+    session.updatedAt = new Date().toISOString();
+    session.lastLogId = log.id;
+    session.lastModel = log.model ?? session.lastModel;
+    session.clientPid = log.clientPid ?? session.clientPid;
+    session.clientProjectFolder = log.clientProjectFolder ?? session.clientProjectFolder;
+  }
 
   sessions.set(identity.id, session);
   return session;

package/src/proxy/store.ts

@@ -30,11 +30,14 @@ import {
   type LogIndexEntry,
 } from "./logIndex";
 import { writeChunks } from "./chunkStorage";
+import type { SessionInfo, SessionLogSummary } from "../lib/sessionInfoContract";
+import { buildSessionInfo, buildSessionLogSummary } from "./sessionInfo";
 import type { CapturedLog } from "./schemas";
 import { CapturedLogSchema } from "./schemas";
 import {
   clearSessionRegistry,
   getLogSessionId,
+  getSessionSnapshots,
   getSessionIds,
   markSessionFinished,
   markSessionStarted,
@@ -42,6 +45,7 @@ import {
   rebuildSessionRegistry,
   resolveSessionIdentity,
   type SessionClientInfo,
+  type SessionSnapshot,
 } from "./sessionSupervisor";
 
 export type { CapturedLog };
@@ -87,6 +91,12 @@ export type ListLogsPageResult = {
   limit: number;
 };
 
+export type GetSessionInfoOptions = {
+  baseUrl: string;
+  includeHistory?: boolean;
+  latestLogLimit?: number;
+};
+
 // Memory cache: id -> CapturedLog (recent logs only, FIFO eviction)
 const memoryCache: Map<number, CapturedLog> = new Map();
 
@@ -506,6 +516,73 @@ export async function listLogsPage(options: ListLogsPageOptions): Promise<ListLo
   };
 }
 
+function findSessionSnapshot(sessionId: string): SessionSnapshot | null {
+  for (const snapshot of getSessionSnapshots()) {
+    if (snapshot.id === sessionId) return snapshot;
+  }
+  return null;
+}
+
+async function collectSessionLogSummaries(
+  sessionId: string,
+  includeHistory: boolean,
+): Promise<SessionLogSummary[]> {
+  const summariesById = new Map<number, SessionLogSummary>();
+  const observeMatchingLog = (log: CapturedLog): void => {
+    if (!matchesLogFilters(log, sessionId, undefined)) return;
+    summariesById.set(log.id, buildSessionLogSummary(log));
+  };
+
+  if (includeHistory) {
+    await visitPersistedLogs((log) => {
+      observeSessionLog(log);
+      observeMatchingLog(log);
+    });
+  }
+
+  for (const log of memoryCache.values()) {
+    observeMatchingLog(log);
+  }
+
+  return [...summariesById.values()];
+}
+
+async function includeSnapshotLastLogSummary(
+  sessionId: string,
+  snapshot: SessionSnapshot | null,
+  summaries: SessionLogSummary[],
+): Promise<SessionLogSummary[]> {
+  if (snapshot === null || snapshot.lastLogId === null) return summaries;
+  for (const summary of summaries) {
+    if (summary.id === snapshot.lastLogId) return summaries;
+  }
+
+  const log = await getLogById(snapshot.lastLogId);
+  if (log === null || !matchesLogFilters(log, sessionId, undefined)) return summaries;
+  return [...summaries, buildSessionLogSummary(log)];
+}
+
+export async function getSessionInfo(
+  sessionId: string,
+  options: GetSessionInfoOptions,
+): Promise<SessionInfo | null> {
+  const includeHistory = options.includeHistory === true;
+  const collectedSummaries = await collectSessionLogSummaries(sessionId, includeHistory);
+  const snapshot = findSessionSnapshot(sessionId);
+  const summaries = includeHistory
+    ? collectedSummaries
+    : await includeSnapshotLastLogSummary(sessionId, snapshot, collectedSummaries);
+  if (snapshot === null && summaries.length === 0) return null;
+  return buildSessionInfo({
+    sessionId,
+    baseUrl: options.baseUrl,
+    snapshot,
+    summaries,
+    logCoverage: includeHistory ? "history" : "recent",
+    latestLogLimit: options.latestLogLimit,
+  });
+}
+
 export function getSessions(): string[] {
   return getSessionIds();
 }

package/src/routes/api/sessions.ts

@@ -1,11 +1,38 @@
 import { createFileRoute } from "@tanstack/react-router";
-import { getSessionSnapshots, getSessions } from "../../proxy/store";
+import { getSessionInfo, getSessionSnapshots, getSessions } from "../../proxy/store";
+
+function parsePositiveInt(value: string | null): number | undefined {
+  if (value === null) return undefined;
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < 1) return undefined;
+  return parsed;
+}
+
+function parseBooleanFlag(value: string | null): boolean {
+  return value === "1" || value === "true";
+}
 
 export const Route = createFileRoute("/api/sessions")({
   server: {
     handlers: {
-      GET: ({ request }: { request: Request }) => {
+      GET: async ({ request }: { request: Request }) => {
         const url = new URL(request.url);
+        const sessionId = url.searchParams.get("sessionId");
+        if (sessionId !== null) {
+          if (sessionId.length === 0) {
+            return Response.json({ error: "sessionId is required" }, { status: 400 });
+          }
+          const info = await getSessionInfo(sessionId, {
+            baseUrl: url.origin,
+            includeHistory: parseBooleanFlag(url.searchParams.get("includeHistory")),
+            latestLogLimit: parsePositiveInt(url.searchParams.get("limit")),
+          });
+          if (info === null) {
+            return Response.json({ error: "Session not found" }, { status: 404 });
+          }
+          return Response.json(info);
+        }
+
         const details = url.searchParams.get("details");
         if (details === "true" || details === "1") {
           return Response.json(getSessionSnapshots());

package/.output/public/assets/_sessionId-DoqvnFx7.js

@@ -1 +0,0 @@
-import{R as s,j as e}from"./main-kBQ49n13.js";import{P as i}from"./ProxyViewerContainer-By3XtQhZ.js";function t(){const{sessionId:o}=s.useParams();return e.jsx(i,{initialSessionId:o},o)}export{t as component};

package/.output/public/assets/index-B0YcFeL-.js

@@ -1 +0,0 @@
-import{P as o}from"./ProxyViewerContainer-By3XtQhZ.js";import"./main-kBQ49n13.js";const r=o;export{r as component};