@tonyclaw/agent-inspector 3.1.32 → 4.0.2

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

@@ -1,297 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { z } from "zod";
-import { parseLogId } from "../../../contracts";
-import { addTestLogEntry, getLogById } from "../../../proxy/store";
-import { findProviderByModel } from "../../../proxy/providers";
-import { registry } from "../../../proxy/formats";
-import { formatForPath } from "../../../proxy/formats";
-import { extractModelFromBody } from "../../../proxy/schemas";
-import {
-  PROXY_IDENTITY,
-  PRESERVE_HEADERS,
-  HEADER_CONTENT_TYPE,
-  HEADER_USER_AGENT,
-  HEADER_X_PROXY_IDENTITY,
-  CONTENT_TYPE_EVENT_STREAM,
-  STATUS_FORBIDDEN,
-} from "../../../proxy/constants";
-import {
-  buildUpstreamUrl,
-  describeApiRoute,
-  injectProviderAuth,
-  selectUpstreamBase,
-  setUpstreamHost,
-} from "../../../proxy/upstream";
-import { computeTokensPerSecond } from "../../../proxy/streamTiming";
-import { safeFetch } from "../../../lib/safeFetch";
-import { DEFAULT_RUNTIME_BUDGET_POLICY } from "../../../lib/resourceLimits";
-
-type ReplayRequest = {
-  modifiedBody: string;
-};
-
-const ReplayRequestSchema = z.object({
-  modifiedBody: z.string(),
-});
-
-type ReplayResponse = {
-  success: boolean;
-  error?: string;
-  responseStatus?: number;
-  responseText?: string;
-  inputTokens?: number;
-  outputTokens?: number;
-  elapsedMs?: number;
-  firstChunkMs?: number | null;
-  totalStreamMs?: number | null;
-  tokensPerSecond?: number | null;
-  streaming?: boolean;
-  replayLogId?: number;
-};
-
-export const Route = createFileRoute("/api/logs/$id/replay")({
-  server: {
-    handlers: {
-      POST: async ({ params, request }: { params: { id: string }; request: Request }) => {
-        const id = parseLogId(params.id);
-        if (id === null) {
-          return Response.json({ error: "Invalid log ID" }, { status: 400 });
-        }
-
-        let replayRequest: ReplayRequest;
-        try {
-          const raw: unknown = await request.json();
-          const parsed = ReplayRequestSchema.safeParse(raw);
-          if (!parsed.success) {
-            return Response.json({ error: "Invalid request body" }, { status: 400 });
-          }
-          replayRequest = parsed.data;
-        } catch {
-          return Response.json({ error: "Invalid JSON body" }, { status: 400 });
-        }
-
-        const { modifiedBody } = replayRequest;
-
-        // Get original log for context
-        const log = await getLogById(id);
-        if (log === null) {
-          return Response.json({ error: "Log not found" }, { status: 404 });
-        }
-
-        // Extract model from modified body
-        const model = extractModelFromBody(modifiedBody);
-        if (model === null) {
-          return Response.json(
-            { error: "Could not extract model from request body" },
-            { status: 400 },
-          );
-        }
-
-        // Find provider
-        const matchedProviderConfig = findProviderByModel(model);
-        const provider = registry.findProvider(model);
-        if (provider === null) {
-          return Response.json(
-            { error: "No provider found for model" },
-            { status: STATUS_FORBIDDEN },
-          );
-        }
-
-        // Determine API path from original log
-        const route = describeApiRoute(log.path);
-
-        // Get format handler
-        const formatHandler = formatForPath(route.apiPath);
-        if (formatHandler === null) {
-          return Response.json({ error: "Unsupported path" }, { status: STATUS_FORBIDDEN });
-        }
-
-        // Build upstream URL
-        const upstreamBase = selectUpstreamBase(route, matchedProviderConfig);
-        const upstreamUrl = buildUpstreamUrl(upstreamBase, route.normalizedPath);
-
-        // Build headers
-        const headers = new Headers();
-        headers.set(HEADER_USER_AGENT, PROXY_IDENTITY);
-        headers.set(HEADER_X_PROXY_IDENTITY, PROXY_IDENTITY);
-        headers.set(HEADER_CONTENT_TYPE, "application/json");
-
-        for (const name of PRESERVE_HEADERS) {
-          const value = log.rawHeaders?.[name.toLowerCase()];
-          if (value !== undefined) {
-            headers.set(name, value);
-          }
-        }
-        setUpstreamHost(headers, upstreamBase);
-        injectProviderAuth(headers, matchedProviderConfig);
-
-        const startTime = Date.now();
-
-        // Send request
-        let upstreamRes: Response;
-        try {
-          const fetchResult = await safeFetch(
-            upstreamUrl,
-            {
-              method: "POST",
-              headers,
-              body: modifiedBody,
-            },
-            {
-              allowLoopback: process.env["AGENT_INSPECTOR_ALLOW_LOOPBACK"] === "1",
-              deadlineMs: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.replayDeadlineMs,
-              responseBytes: DEFAULT_RUNTIME_BUDGET_POLICY.upstream.replayResponseBytes,
-            },
-          );
-          if (!fetchResult.ok) {
-            return Response.json({
-              success: false,
-              error: fetchResult.reason,
-            } satisfies ReplayResponse);
-          }
-          upstreamRes = fetchResult.response;
-        } catch (err) {
-          return Response.json({
-            success: false,
-            error: String(err),
-          } satisfies ReplayResponse);
-        }
-
-        const isStream =
-          upstreamRes.headers.get(HEADER_CONTENT_TYPE)?.includes(CONTENT_TYPE_EVENT_STREAM) ??
-          false;
-
-        if (isStream) {
-          // Accumulate streaming response
-          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 {
-              // Stream read error
-            }
-          }
-          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,
-            path: log.path,
-            model,
-            sessionId: log.sessionId,
-            rawRequestBody: modifiedBody,
-            responseStatus: upstreamRes.status,
-            responseText,
-            inputTokens: tokens.inputTokens ?? null,
-            outputTokens,
-            cacheCreationInputTokens: tokens.cacheCreationInputTokens ?? null,
-            cacheReadInputTokens: tokens.cacheReadInputTokens ?? null,
-            elapsedMs,
-            firstChunkMs,
-            totalStreamMs,
-            tokensPerSecond,
-            streaming: true,
-            userAgent: log.userAgent,
-            origin: log.origin,
-            rawHeaders: log.rawHeaders,
-            headers: log.headers,
-            apiFormat: log.apiFormat,
-            isTest: true,
-            replayOfLogId: log.id,
-            providerName: log.providerName,
-            clientPort: log.clientPort,
-            clientPid: log.clientPid,
-            clientCwd: log.clientCwd,
-            clientProjectFolder: log.clientProjectFolder,
-            streamingChunks: undefined,
-            streamingChunksPath: null,
-            error: null,
-          });
-
-          return Response.json({
-            success: true,
-            responseStatus: upstreamRes.status,
-            responseText,
-            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(),
-            method: log.method,
-            path: log.path,
-            model,
-            sessionId: log.sessionId,
-            rawRequestBody: modifiedBody,
-            responseStatus: upstreamRes.status,
-            responseText,
-            inputTokens: tokens.inputTokens ?? null,
-            outputTokens: tokens.outputTokens ?? null,
-            cacheCreationInputTokens: tokens.cacheCreationInputTokens ?? null,
-            cacheReadInputTokens: tokens.cacheReadInputTokens ?? null,
-            elapsedMs,
-            firstChunkMs: null,
-            totalStreamMs: null,
-            tokensPerSecond: null,
-            streaming: false,
-            userAgent: log.userAgent,
-            origin: log.origin,
-            rawHeaders: log.rawHeaders,
-            headers: log.headers,
-            apiFormat: log.apiFormat,
-            isTest: true,
-            replayOfLogId: log.id,
-            providerName: log.providerName,
-            clientPort: log.clientPort,
-            clientPid: log.clientPid,
-            clientCwd: log.clientCwd,
-            clientProjectFolder: log.clientProjectFolder,
-            streamingChunks: undefined,
-            streamingChunksPath: null,
-            error: null,
-          });
-
-          return Response.json({
-            success: true,
-            responseStatus: upstreamRes.status,
-            responseText,
-            inputTokens: tokens.inputTokens ?? undefined,
-            outputTokens: tokens.outputTokens ?? undefined,
-            elapsedMs,
-            streaming: false,
-            replayLogId: savedReplayLog.id,
-          } satisfies ReplayResponse);
-        }
-      },
-    },
-  },
-});

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

@@ -1,23 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { parseLogId } from "../../../contracts";
-import { getLogById } from "../../../proxy/store";
-
-export const Route = createFileRoute("/api/logs/$id")({
-  server: {
-    handlers: {
-      GET: async ({ params }: { params: { id: string } }) => {
-        const id = parseLogId(params.id);
-        if (id === null) {
-          return Response.json({ error: "Invalid ID" }, { status: 400 });
-        }
-
-        const log = await getLogById(id);
-        if (log === null) {
-          return Response.json({ error: "Log not found" }, { status: 404 });
-        }
-
-        return Response.json(log);
-      },
-    },
-  },
-});

package/src/backend/routes/api/logs.import.ts

@@ -1,39 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import { parseImportedLogFile, sessionNameFromImportFileName } from "../../../proxy/logImporter";
-import { readBoundedLogImportUpload } from "../../../proxy/logImportUpload";
-import { compactLogForList, importCapturedLogs } from "../../../proxy/store";
-
-export const Route = createFileRoute("/api/logs/import")({
-  server: {
-    handlers: {
-      POST: async ({ request }: { request: Request }) => {
-        const upload = await readBoundedLogImportUpload(request);
-        if (!upload.ok) {
-          return Response.json({ error: upload.message }, { status: upload.status });
-        }
-
-        const sessionId = sessionNameFromImportFileName(upload.fileName);
-        const parsed = await parseImportedLogFile({
-          fileName: upload.fileName,
-          data: upload.data,
-        });
-
-        if (!parsed.ok) {
-          return Response.json(
-            { error: parsed.message, warnings: parsed.warnings },
-            { status: 400 },
-          );
-        }
-
-        const imported = await importCapturedLogs(parsed.logs, sessionId);
-        return Response.json({
-          sessionId,
-          imported: imported.length,
-          skipped: parsed.skipped,
-          warnings: parsed.warnings,
-          logs: imported.map((log) => compactLogForList(log)),
-        });
-      },
-    },
-  },
-});

package/src/backend/routes/api/logs.stream.ts

@@ -1,174 +0,0 @@
-import { createFileRoute } from "@tanstack/react-router";
-import {
-  compactLogForList,
-  onLogUpdate,
-  getLogSessionId,
-  listLogsCursorPage,
-} from "../../../proxy/store";
-import { parseLogId, type CapturedLog } from "../../../contracts";
-import {
-  createCapacityLimiter,
-  MAX_SSE_CLIENTS,
-  resourceLimitResponse,
-  type CapacityLimiter,
-} from "../../../lib/resourceLimits";
-
-const INITIAL_STREAM_LOG_LIMIT = 100;
-const UPDATE_COALESCE_MS = 50;
-const MAX_BUFFERED_UPDATE_EVENTS = 16;
-const sseClientLimiter = createCapacityLimiter(MAX_SSE_CLIENTS);
-
-export function getLogsStreamMetrics(): { activeClients: number; capacity: number } {
-  return {
-    activeClients: sseClientLimiter.activeCount(),
-    capacity: sseClientLimiter.capacity,
-  };
-}
-
-export function streamIncludesBodies(url: URL): boolean {
-  return url.searchParams.get("compact") === "0";
-}
-
-export function parseLastEventLogId(value: string | null): number | undefined {
-  if (value === null) return undefined;
-  return parseLogId(value) ?? undefined;
-}
-
-function encodeSse(value: unknown, id?: number): Uint8Array {
-  const idLine = id === undefined ? "" : `id: ${String(id)}\n`;
-  return new TextEncoder().encode(`${idLine}data: ${JSON.stringify(value)}\n\n`);
-}
-
-export function createLogsStreamResponse(
-  request: Request,
-  clientLimiter: CapacityLimiter = sseClientLimiter,
-): Response {
-  const lastEventIdHeader = request.headers.get("last-event-id");
-  const lastEventLogId = parseLastEventLogId(lastEventIdHeader);
-  if (lastEventIdHeader !== null && lastEventLogId === undefined) {
-    return Response.json({ error: "Invalid Last-Event-ID" }, { status: 400 });
-  }
-  const lease = clientLimiter.tryAcquire();
-  if (lease === null) {
-    return resourceLimitResponse({
-      error: `SSE client capacity reached. At most ${String(clientLimiter.capacity)} live clients are allowed; retry after a connection closes.`,
-      code: "sse-capacity-exceeded",
-      status: 503,
-      resource: "sse-clients",
-      limit: clientLimiter.capacity,
-      retryable: true,
-      retryAfterSeconds: 1,
-    });
-  }
-  const url = new URL(request.url);
-  const sessionId = url.searchParams.get("sessionId") ?? undefined;
-  const model = url.searchParams.get("model") ?? undefined;
-  const includeBodies = streamIncludesBodies(url);
-
-  let controllerRef: ReadableStreamDefaultController<Uint8Array> | null = null;
-  let cleanedUp = false;
-  let updateTimer: ReturnType<typeof setTimeout> | null = null;
-  const pendingUpdates = new Map<number, CapturedLog>();
-
-  const flushPendingUpdates = (): void => {
-    updateTimer = null;
-    const controller = controllerRef;
-    if (controller === null) return;
-    if (controller.desiredSize !== null && controller.desiredSize <= -MAX_BUFFERED_UPDATE_EVENTS) {
-      controller.close();
-      cleanup();
-      return;
-    }
-    for (const log of pendingUpdates.values()) {
-      if (
-        controller.desiredSize !== null &&
-        controller.desiredSize <= -MAX_BUFFERED_UPDATE_EVENTS
-      ) {
-        controller.close();
-        cleanup();
-        return;
-      }
-      const payloadLog = includeBodies ? log : compactLogForList(log);
-      controller.enqueue(encodeSse({ type: "update", log: payloadLog }, log.id));
-    }
-    pendingUpdates.clear();
-  };
-
-  const unsubscribe = onLogUpdate((log: CapturedLog) => {
-    if (controllerRef === null) return;
-    // Filter by session/model if specified
-    if (sessionId !== undefined && getLogSessionId(log) !== sessionId) return;
-    if (model !== undefined && log.model !== model) return;
-    pendingUpdates.set(log.id, log);
-    if (updateTimer === null) updateTimer = setTimeout(flushPendingUpdates, UPDATE_COALESCE_MS);
-  });
-
-  const cleanup = (): void => {
-    if (cleanedUp) return;
-    cleanedUp = true;
-    clearInterval(heartbeat);
-    if (updateTimer !== null) clearTimeout(updateTimer);
-    updateTimer = null;
-    pendingUpdates.clear();
-    unsubscribe();
-    lease.release();
-    controllerRef = null;
-    request.signal.removeEventListener("abort", cleanup);
-  };
-
-  // Send heartbeat comment every 30s to keep connection alive
-  const heartbeat = setInterval(() => {
-    if (controllerRef !== null) {
-      try {
-        controllerRef.enqueue(new TextEncoder().encode(": heartbeat\n\n"));
-      } catch {
-        cleanup();
-      }
-    }
-  }, 30000);
-
-  request.signal.addEventListener("abort", cleanup, { once: true });
-
-  const stream = new ReadableStream<Uint8Array>({
-    async start(controller) {
-      controllerRef = controller;
-      try {
-        const result = await listLogsCursorPage({
-          sessionId,
-          model,
-          limit: INITIAL_STREAM_LOG_LIMIT,
-          includeBodies,
-          afterLogId: lastEventLogId,
-          anchor: lastEventLogId === undefined ? "newest" : undefined,
-        });
-        if (cleanedUp) return;
-        const logs = result.logs;
-        const newestLogId = logs.at(-1)?.id;
-        controller.enqueue(encodeSse({ type: "init", logs }, newestLogId));
-      } catch (error) {
-        cleanup();
-        controller.error(error);
-      }
-    },
-    cancel() {
-      cleanup();
-    },
-  });
-
-  return new Response(stream, {
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-      "X-Accel-Buffering": "no",
-    },
-  });
-}
-
-export const Route = createFileRoute("/api/logs/stream")({
-  server: {
-    handlers: {
-      GET: ({ request }: { request: Request }) => createLogsStreamResponse(request),
-    },
-  },
-});