@tonyclaw/agent-inspector 2.0.24 → 2.0.26

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());